From 97aab3746204e2700d10b8ae94e50656cfd00924 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Thu, 5 Apr 2018 20:49:48 +1000 Subject: [PATCH] Rename buf1, reader1, etc to io_buffer, io_reader Also remove the unused Buf1, Buf2 and Usize tokens. --- cmd/wuffs-c/internal/cgen/base-header.h | 28 ++- cmd/wuffs-c/internal/cgen/base-impl.h | 38 ++-- cmd/wuffs-c/internal/cgen/data.go | 50 ++--- cmd/wuffs-c/internal/cgen/expr.go | 50 ++--- cmd/wuffs-c/internal/cgen/func.go | 19 +- cmd/wuffs-c/internal/cgen/statement.go | 4 +- cmd/wuffs-c/internal/cgen/var.go | 18 +- doc/changelog.md | 1 + example/gifplayer/gifplayer.c | 10 +- example/library/library.c | 8 +- example/zcat/zcat.c | 14 +- fuzz/c/fuzzlib/fuzzlib.cc | 14 +- fuzz/c/std/gif_fuzzer.cc | 6 +- fuzz/c/std/zlib_fuzzer.cc | 6 +- gen/c/std/crc32.c | 66 +++---- gen/c/std/deflate.c | 172 ++++++++-------- gen/c/std/gif.c | 185 +++++++++--------- gen/c/std/gzip.c | 92 +++++---- gen/c/std/zlib.c | 92 +++++---- gen/h/std/crc32.h | 28 ++- gen/h/std/deflate.h | 32 ++- gen/h/std/gif.h | 34 ++-- gen/h/std/gzip.h | 36 ++-- gen/h/std/zlib.h | 36 ++-- lang/ast/ast.go | 8 +- lang/builtin/builtin.go | 66 +++---- lang/check/bounds.go | 25 ++- lang/check/optimize.go | 4 +- lang/check/resolve.go | 8 +- lang/token/list.go | 27 +-- script/wuffs-deflate-decoder-decode-huffman.c | 8 +- std/deflate/decode_deflate.wuffs | 8 +- std/deflate/decode_huffman_fast.wuffs | 2 +- std/deflate/decode_huffman_slow.wuffs | 2 +- std/gif/decode_gif.wuffs | 20 +- std/gif/decode_lzw.wuffs | 2 +- std/gzip/decode_gzip.wuffs | 2 +- std/zlib/decode_zlib.wuffs | 2 +- test/c/mimiclib/deflate-gzip-zlib.c | 48 ++--- test/c/mimiclib/gif.c | 5 +- test/c/std/crc32.c | 20 +- test/c/std/deflate.c | 106 +++++----- test/c/std/gif.c | 94 ++++----- test/c/std/gzip.c | 36 ++-- test/c/std/zlib.c | 54 ++--- test/c/testlib/testlib.c | 84 ++++---- 46 files changed, 823 insertions(+), 847 deletions(-) diff --git a/cmd/wuffs-c/internal/cgen/base-header.h b/cmd/wuffs-c/internal/cgen/base-header.h index 0bb3e403..b2bc77ce 100644 --- a/cmd/wuffs-c/internal/cgen/base-header.h +++ b/cmd/wuffs-c/internal/cgen/base-header.h @@ -96,9 +96,7 @@ typedef struct { // ---------------- I/O -// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc. - -// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus +// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length), plus // additional indexes into that buffer, plus an opened / closed flag. // // A value with all fields NULL or zero is a valid, empty buffer. @@ -108,44 +106,44 @@ typedef struct { size_t wi; // Write index. Invariant: wi <= len. size_t ri; // Read index. Invariant: ri <= wi. bool closed; // No further writes are expected. -} wuffs_base__buf1; +} wuffs_base__io_buffer; -// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream: +// wuffs_base__io_limit provides a limited view of a 1-dimensional byte stream: // its first N bytes. That N can be greater than a buffer's current read or // write capacity. N decreases naturally over time as bytes are read from or // written to the stream. // // A value with all fields NULL or zero is a valid, unlimited view. -typedef struct wuffs_base__limit1 { - uint64_t* ptr_to_len; // Pointer to N. - struct wuffs_base__limit1* next; // Linked list of limits. -} wuffs_base__limit1; +typedef struct wuffs_base__io_limit { + uint64_t* ptr_to_len; // Pointer to N. + struct wuffs_base__io_limit* next; // Linked list of limits. +} wuffs_base__io_limit; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__reader1; +} wuffs_base__io_reader; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__writer1; +} wuffs_base__io_writer; // ---------------- Images diff --git a/cmd/wuffs-c/internal/cgen/base-impl.h b/cmd/wuffs-c/internal/cgen/base-impl.h index a87a0004..8d56a5ca 100644 --- a/cmd/wuffs-c/internal/cgen/base-impl.h +++ b/cmd/wuffs-c/internal/cgen/base-impl.h @@ -186,9 +186,9 @@ static inline uint64_t wuffs_base__slice_u8__copy_from_slice( return length; } -static inline uint32_t wuffs_base__writer1__copy_from_history32( +static inline uint32_t wuffs_base__io_writer__copy_from_history32( uint8_t** ptr_ptr, - uint8_t* start, // May be NULL, meaning an unmarked writer1. + uint8_t* start, // May be NULL, meaning an unmarked io_writer. uint8_t* end, uint32_t distance, uint32_t length) { @@ -212,7 +212,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32( // copy_from_history32 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__writer1__copy_from_history32__bco below. + // See also wuffs_base__io_writer__copy_from_history32__bco below. // // Alternatively, or additionally, have a sloppy_copy_from_history32 method // that copies 8 bytes at a time, possibly writing more than length bytes? @@ -228,14 +228,14 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32( return length; } -// wuffs_base__writer1__copy_from_history32__bco is a Bounds Check Optimized -// version of the wuffs_base__writer1__copy_from_history32 function above. The -// caller needs to prove that: +// wuffs_base__io_writer__copy_from_history32__bco is a Bounds Check Optimized +// version of the wuffs_base__io_writer__copy_from_history32 function above. +// The caller needs to prove that: // - start != NULL // - distance > 0 // - distance <= (*ptr_ptr - start) // - length <= (end - *ptr_ptr) -static inline uint32_t wuffs_base__writer1__copy_from_history32__bco( +static inline uint32_t wuffs_base__io_writer__copy_from_history32__bco( uint8_t** ptr_ptr, uint8_t* start, uint8_t* end, @@ -256,7 +256,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32__bco( return length; } -static inline uint32_t wuffs_base__writer1__copy_from_reader32( +static inline uint32_t wuffs_base__io_writer__copy_from_reader32( uint8_t** ptr_wptr, uint8_t* wend, uint8_t** ptr_rptr, @@ -279,7 +279,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_reader32( return n; } -static inline uint64_t wuffs_base__writer1__copy_from_slice( +static inline uint64_t wuffs_base__io_writer__copy_from_slice( uint8_t** ptr_wptr, uint8_t* wend, wuffs_base__slice_u8 src) { @@ -295,7 +295,7 @@ static inline uint64_t wuffs_base__writer1__copy_from_slice( return n; } -static inline uint32_t wuffs_base__writer1__copy_from_slice32( +static inline uint32_t wuffs_base__io_writer__copy_from_slice32( uint8_t** ptr_wptr, uint8_t* wend, wuffs_base__slice_u8 src, @@ -317,7 +317,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32( // Note that the *__limit and *__mark methods are private (in base-impl.h) not // public (in base-header.h). We assume that, at the boundary between user code -// and Wuffs code, the reader1 and writer1's private_impl fields (including +// and Wuffs code, the io_reader and io_writer's private_impl fields (including // limit and mark) are NULL. Otherwise, some internal assumptions break down. // For example, limits could be represented as pointers, even though // conceptually they are counts, but that pointer-to-count correspondence @@ -327,26 +327,26 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32( // code is still Wuffs code, not user code. Other Wuffs test code modifies // private_impl fields directly. -static inline wuffs_base__reader1 wuffs_base__reader1__limit( - wuffs_base__reader1* o, +static inline wuffs_base__io_reader wuffs_base__io_reader__limit( + wuffs_base__io_reader* o, uint64_t* ptr_to_len) { - wuffs_base__reader1 ret = *o; + wuffs_base__io_reader ret = *o; ret.private_impl.limit.ptr_to_len = ptr_to_len; ret.private_impl.limit.next = &o->private_impl.limit; return ret; } -static inline wuffs_base__empty_struct wuffs_base__reader1__mark( - wuffs_base__reader1* o, +static inline wuffs_base__empty_struct wuffs_base__io_reader__mark( + wuffs_base__io_reader* o, uint8_t* mark) { o->private_impl.mark = mark; return ((wuffs_base__empty_struct){}); } -// TODO: static inline wuffs_base__writer1 wuffs_base__writer1__limit() +// TODO: static inline wuffs_base__io_writer wuffs_base__io_writer__limit() -static inline wuffs_base__empty_struct wuffs_base__writer1__mark( - wuffs_base__writer1* o, +static inline wuffs_base__empty_struct wuffs_base__io_writer__mark( + wuffs_base__io_writer* o, uint8_t* mark) { o->private_impl.mark = mark; return ((wuffs_base__empty_struct){}); diff --git a/cmd/wuffs-c/internal/cgen/data.go b/cmd/wuffs-c/internal/cgen/data.go index 794e7939..239509ec 100644 --- a/cmd/wuffs-c/internal/cgen/data.go +++ b/cmd/wuffs-c/internal/cgen/data.go @@ -20,25 +20,25 @@ const baseHeader = "" + "#ifndef WUFFS_BASE_HEADER_H\n#define WUFFS_BASE_HEADER_H\n\n// Copyright 2017 The Wuffs Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// https://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n#include \n#include \n#include \n\n// Wuffs requires a word size of at least 32 bits because it assumes that\n// converting a u32 to usize will never overflow. For example, the size of a\n// decoded image is often represented, explicitly or implicitly in an image\n// file, as a u32, and it is convenient to compare that to a buffer size.\n//\n// Si" + "milarly, the word size is at most 64 bits because it assumes that\n// converting a usize to u64 will never overflow.\n#if __WORDSIZE < 32\n#error \"Wuffs requires a word size of at least 32 bits\"\n#elif __WORDSIZE > 64\n#error \"Wuffs requires a word size of at most 64 bits\"\n#endif\n\n// WUFFS_VERSION is the major.minor version number as a uint32. The major\n// number is the high 16 bits. The minor number is the low 16 bits.\n//\n// The intention is to bump the version number at least on every API / ABI\n// backwards incompatible change.\n//\n// For now, the API and ABI are simply unstable and can change at any time.\n//\n// TODO: don't hard code this in base-header.h.\n#define WUFFS_VERSION 0x00001\n\n// ---------------- Fundamentals\n\n// Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a\n// second. See https://github.com/OculusVR/Flicks\ntypedef uint64_t wuffs_base__flicks;\n\n#define WUFFS_BASE__FLICKS_PER_SECOND 705600000ULL\n\n// wuffs_base__rectangle is a rectangle on the integer grid. It contains all\n// p" + "oints (x, y) such that ((min_x <= x) && (x < max_x)) and likewise for y. It\n// is therefore empty if min_x >= max_x. There are multiple representations of\n// an empty rectangle.\n//\n// A value with all fields zero is a valid, empty rectangle.\n//\n// The X and Y axes increase right and down.\ntypedef struct {\n uint32_t min_x;\n uint32_t min_y;\n uint32_t max_x;\n uint32_t max_y;\n} wuffs_base__rectangle;\n\nstatic inline uint32_t wuffs_base__rectangle__width(wuffs_base__rectangle r) {\n return r.max_x > r.min_x ? r.max_x - r.min_x : 0;\n}\n\nstatic inline uint32_t wuffs_base__rectangle__height(wuffs_base__rectangle r) {\n return r.max_y > r.min_y ? r.max_y - r.min_y : 0;\n}\n\n// wuffs_base__slice_u8 is a 1-dimensional buffer.\n//\n// A value with all fields NULL or zero is a valid, empty slice.\ntypedef struct {\n uint8_t* ptr;\n size_t len;\n} wuffs_base__slice_u8;\n\n// wuffs_base__table_u8 is a 2-dimensional buffer.\n//\n// A value with all fields NULL or zero is a valid, empty table.\ntypedef struct {\n uint8_t* ptr;\n size_" + - "t width;\n size_t height;\n size_t stride;\n} wuffs_base__table_u8;\n\n// ---------------- I/O\n\n// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc.\n\n// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus\n// additional indexes into that buffer, plus an opened / closed flag.\n//\n// A value with all fields NULL or zero is a valid, empty buffer.\ntypedef struct {\n uint8_t* ptr; // Pointer.\n size_t len; // Length.\n size_t wi; // Write index. Invariant: wi <= len.\n size_t ri; // Read index. Invariant: ri <= wi.\n bool closed; // No further writes are expected.\n} wuffs_base__buf1;\n\n// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream:\n// its first N bytes. That N can be greater than a buffer's current read or\n// write capacity. N decreases naturally over time as bytes are read from or\n// written to the stream.\n//\n// A value with all fields NULL or zero is a valid, unlimited view.\ntypedef struct wuffs_base__limit1 {\n uint64_t* ptr_to_len; " + - " // Pointer to N.\n struct wuffs_base__limit1* next; // Linked list of limits.\n} wuffs_base__limit1;\n\ntypedef struct {\n // TODO: move buf into private_impl? As it is, it looks like users can modify\n // the buf field to point to a different buffer, which can turn the limit and\n // mark fields into dangling pointers.\n wuffs_base__buf1* buf;\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__limit1 limit;\n uint8_t* mark;\n } private_impl;\n} wuffs_base__reader1;\n\ntypedef struct {\n // TODO: move buf into private_impl? As it is, it looks like users can modify\n // the buf field to point to a different buffer, which can turn the limit and\n // mark fields into dangling pointers.\n wuffs_base__buf1* buf;\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__limit1 limit;\n uint8_t* mark;\n } private_impl" + - ";\n} wuffs_base__writer1;\n\n// ---------------- Images\n\n// wuffs_base__pixel_format encodes the format of the bytes that constitute an\n// image frame's pixel data. Its bits:\n// - bit 31 is reserved.\n// - bits 30 .. 28 encodes color (and channel order, in terms of memory).\n// - bits 27 .. 26 are reserved.\n// - bits 25 .. 24 encodes transparency.\n// - bit 23 indicates big-endian/MSB-first (as opposed to little/LSB).\n// - bit 22 indicates floating point (as opposed to integer).\n// - bits 21 .. 20 are the number of planes, minus 1. Zero means packed.\n// - bits 19 .. 16 encodes the number of bits (depth) in an index value.\n// Zero means direct, not palette-indexed.\n// - bits 15 .. 12 encodes the number of bits (depth) in the 3rd channel.\n// - bits 11 .. 8 encodes the number of bits (depth) in the 2nd channel.\n// - bits 7 .. 4 encodes the number of bits (depth) in the 1st channel.\n// - bits 3 .. 0 encodes the number of bits (depth) in the 0th channel.\n//\n// The " + - "bit fields of a wuffs_base__pixel_format are not independent. For\n// example, the number of planes should not be greater than the number of\n// channels. Similarly, bits 15..4 are unused (and should be zero) if bits\n// 31..24 (color and transparency) together imply only 1 channel (gray, no\n// alpha) and floating point samples should mean a bit depth of 16, 32 or 64.\n//\n// Formats hold between 1 and 4 channels. For example: Y (1 channel: gray), YA\n// (2 channels: gray and alpha), BGR (3 channels: blue, green, red) or CMYK (4\n// channels: cyan, magenta, yellow, black).\n//\n// For direct formats with N > 1 channels, those channels can be laid out in\n// either 1 (packed) or N (planar) planes. For example, RGBA data is usually\n// packed, but YUV data is usually planar, due to chroma subsampling (for\n// details, see the wuffs_base__pixel_subsampling type). For indexed formats,\n// the palette (always 256 × 4 bytes) holds up to 4 packed bytes of color data\n// per index value, and there is only 1 plane (for the index)." + - " The distance\n// between successive palette elements is always 4 bytes.\n//\n// The color field is encoded in 3 bits:\n// - 0 means A (Alpha).\n// - 1 means Y or YA (Gray, Alpha).\n// - 2 means BGR, BGRX or BGRA (Blue, Green, Red, X-padding or Alpha).\n// - 3 means RGB, RGBX or RGBA (Red, Green, Blue, X-padding or Alpha).\n// - 4 means YUV or YUVA (Luma, Chroma-blue, Chroma-red, Alpha).\n// - 5 means CMY or CMYK (Cyan, Magenta, Yellow, Black).\n// - all other values are reserved.\n//\n// In Wuffs, channels are given in memory order, regardless of endianness,\n// since the C type for the pixel data is an array of bytes, not an array of\n// uint32_t. For example, packed BGRA with 8 bits per channel means that the\n// bytes in memory are always Blue, Green, Red then Alpha. On big-endian\n// systems, that is the uint32_t 0xBBGGRRAA. On little-endian, 0xAARRGGBB.\n//\n// When the color field (3 bits) encodes multiple options, the transparency\n// field (2 bits) distinguishes them:\n// - " + - "0 means fully opaque, no extra channels\n// - 1 means fully opaque, one extra channel (X or K, padding or black).\n// - 2 means one extra alpha channel, other channels are non-premultiplied.\n// - 3 means one extra alpha channel, other channels are premultiplied.\n//\n// The zero wuffs_base__pixel_format value is an invalid pixel format, as it is\n// invalid to combine the zero color (alpha only) with the zero transparency.\n//\n// Bit depth is encoded in 4 bits:\n// - 0 means the channel or index is unused.\n// - x means a bit depth of x, for x in the range 1..8.\n// - 9 means a bit depth of 10.\n// - 10 means a bit depth of 12.\n// - 11 means a bit depth of 16.\n// - 12 means a bit depth of 24.\n// - 13 means a bit depth of 32.\n// - 14 means a bit depth of 48.\n// - 15 means a bit depth of 64.\n//\n// For example, wuffs_base__pixel_format 0x3280BBBB is a natural format for\n// decoding a PNG image - network byte order (also known as big-endian),\n// packed, non-premultiplied alpha - that happens to be 16-bi" + - "t-depth truecolor\n// with alpha (RGBA). In memory order:\n//\n// ptr+0 ptr+1 ptr+2 ptr+3 ptr+4 ptr+5 ptr+6 ptr+7\n// Rhi Rlo Ghi Glo Bhi Blo Ahi Alo\n//\n// For example, the value wuffs_base__pixel_format 0x20000565 means BGR with no\n// alpha or padding, 5/6/5 bits for blue/green/red, packed 2 bytes per pixel,\n// laid out LSB-first in memory order:\n//\n// ptr+0........... ptr+1...........\n// MSB LSB MSB LSB\n// G₂G₁G₀B₄B₃B₂B₁B₀ R₄R₃R₂R₁R₀G₅G₄G₃\n//\n// On little-endian systems (but not big-endian), this Wuffs pixel format value\n// (0x20000565) corresponds to the Cairo library's CAIRO_FORMAT_RGB16_565, the\n// SDL2 (Simple DirectMedia Layer 2) library's SDL_PIXELFORMAT_RGB565 and the\n// Skia library's kRGB_565_SkColorType. Note BGR in Wuffs versus RGB in the\n// other libraries.\n//\n// Regardless of endianness, this Wuffs pixel format value (0x20000565)\n// corresponds to the V4L2 (Video For Linux 2) library's V4L2_PIX_FMT_RGB565\n// and t" + - "he Wayland-DRM library's WL_DRM_FORMAT_RGB565.\n//\n// Different software libraries name their pixel formats (and especially their\n// channel order) either according to memory layout or as bits of a native\n// integer type like uint32_t. The two conventions differ because of a system's\n// endianness. As mentioned earlier, Wuffs pixel formats are always in memory\n// order. More detail of other software libraries' naming conventions is in the\n// Pixel Format Guide at https://afrantzis.github.io/pixel-format-guide/\n//\n// Do not manipulate these bits directly; they are private implementation\n// details. Use methods such as wuffs_base__pixel_format__num_planes instead.\ntypedef uint32_t wuffs_base__pixel_format;\n\n// Common 8-bit-depth pixel formats. This list is not exhaustive; not all valid\n// wuffs_base__pixel_format values are present.\n\n#define WUFFS_BASE__PIXEL_FORMAT__INVALID ((wuffs_base__pixel_format)0x00000000)\n\n#define WUFFS_BASE__PIXEL_FORMAT__A ((wuffs_base__pixel_format)0x02000008)\n\n#define WUFFS_BASE__PIX" + - "EL_FORMAT__Y ((wuffs_base__pixel_format)0x10000008)\n#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x12000008)\n#define WUFFS_BASE__PIXEL_FORMAT__YA_PREMUL \\\n ((wuffs_base__pixel_format)0x13000008)\n\n#define WUFFS_BASE__PIXEL_FORMAT__BGR ((wuffs_base__pixel_format)0x20000888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRX ((wuffs_base__pixel_format)0x21008888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRX_INDEXED \\\n ((wuffs_base__pixel_format)0x21088888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x22008888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_INDEXED \\\n ((wuffs_base__pixel_format)0x22088888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL \\\n ((wuffs_base__pixel_format)0x23008888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__RGB ((wuffs_base__pixel_format)0x30000888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBX ((wuffs_base__pixel_format)0x31008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBX_INDEXED \\\n ((wuffs_base__pixel_format)0x31088888)\n#define WUFFS_BASE__PI" + - "XEL_FORMAT__RGBA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x32008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_INDEXED \\\n ((wuffs_base__pixel_format)0x32088888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL \\\n ((wuffs_base__pixel_format)0x33008888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__YUV ((wuffs_base__pixel_format)0x40200888)\n#define WUFFS_BASE__PIXEL_FORMAT__YUVK ((wuffs_base__pixel_format)0x41308888)\n#define WUFFS_BASE__PIXEL_FORMAT__YUVA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x42308888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__CMY ((wuffs_base__pixel_format)0x50200888)\n#define WUFFS_BASE__PIXEL_FORMAT__CMYK ((wuffs_base__pixel_format)0x51308888)\n\nstatic inline bool wuffs_base__pixel_format__is_valid(\n wuffs_base__pixel_format f) {\n return f != 0;\n}\n\nstatic inline bool wuffs_base__pixel_format__is_indexed(\n wuffs_base__pixel_format f) {\n return ((f >> 16) & 0x0F) != 0;\n}\n\n#define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4\n\nstatic inline uint32_t wuffs_base__pixel_format__num_planes(\n wuffs_" + - "base__pixel_format f) {\n return f ? (((f >> 20) & 0x03) + 1) : 0;\n}\n\ntypedef struct {\n wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX];\n} wuffs_base__pixel_buffer;\n\n// wuffs_base__pixel_subsampling encodes the mapping of pixel space coordinates\n// (x, y) to pixel buffer indices (i, j). That mapping can differ for each\n// plane p. For a depth of 8 bits (1 byte), the p'th plane's sample starts at\n// (planes[p].ptr + (j * planes[p].stride) + i).\n//\n// For packed pixel formats, the mapping is trivial: i = x and j = y. For\n// planar pixel formats, the mapping can differ due to chroma subsampling. For\n// example, consider a three plane YUV pixel format with 4:2:2 subsampling. For\n// the luma (Y) channel, there is one sample for every pixel, but for the\n// chroma (U, V) channels, there is one sample for every two pixels: pairs of\n// horizontally adjacent pixels form one macropixel, i = x / 2 and j == y. In\n// general, for a given p:\n// - i = (x + bias_x) >> shift_x.\n// - j = (y + bias_y) >>" + - " shift_y.\n// where biases and shifts are in the range 0..3 and 0..2 respectively.\n//\n// In general, the biases will be zero after decoding an image. However, making\n// a sub-image may change the bias, since the (x, y) coordinates are relative\n// to the sub-image's top-left origin, but the backing pixel buffers were\n// created relative to the original image's origin.\n//\n// For each plane p, each of those four numbers (biases and shifts) are encoded\n// in two bits, which combine to form an 8 bit unsigned integer:\n//\n// e_p = (bias_x << 6) | (shift_x << 4) | (bias_y << 2) | (shift_y << 0)\n//\n// Those e_p values (e_0 for the first plane, e_1 for the second plane, etc)\n// combine to form a wuffs_base__pixel_subsampling value:\n//\n// pixsub = (e_3 << 24) | (e_2 << 16) | (e_1 << 8) | (e_0 << 0)\n//\n// Do not manipulate these bits directly; they are private implementation\n// details. Use methods such as wuffs_base__pixel_subsampling__bias_x instead.\ntypedef uint32_t wuffs_base__pixel_subsampling;\n\n#define WUFFS_BASE_" + - "_PIXEL_SUBSAMPLING__NONE ((wuffs_base__pixel_subsampling)0);\n\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__444 \\\n ((wuffs_base__pixel_subsampling)0x000000);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__440 \\\n ((wuffs_base__pixel_subsampling)0x010100);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__422 \\\n ((wuffs_base__pixel_subsampling)0x101000);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__420 \\\n ((wuffs_base__pixel_subsampling)0x111100);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__411 \\\n ((wuffs_base__pixel_subsampling)0x202000);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__410 \\\n ((wuffs_base__pixel_subsampling)0x212100);\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__bias_x(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 6;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__shift_x(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 4;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t" + - " wuffs_base__pixel_subsampling__bias_y(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 2;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__shift_y(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 0;\n return (s >> shift) & 0x03;\n}\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__pixel_format pixfmt;\n wuffs_base__pixel_subsampling pixsub;\n uint32_t width;\n uint32_t height;\n uint32_t num_loops;\n } private_impl;\n} wuffs_base__image_config;\n\nstatic inline void wuffs_base__image_config__initialize(\n wuffs_base__image_config* c,\n wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height,\n uint32_t num_loops) {\n if (!c) {\n return;\n }\n // TODO: move the check from wuffs" + - "_base__image_config__is_valid here. Should\n // this function return bool? An error type?\n c->private_impl.pixfmt = pixfmt;\n c->private_impl.pixsub = pixsub;\n c->private_impl.width = width;\n c->private_impl.height = height;\n c->private_impl.num_loops = num_loops;\n}\n\nstatic inline void wuffs_base__image_config__invalidate(\n wuffs_base__image_config* c) {\n if (c) {\n *c = ((wuffs_base__image_config){});\n }\n}\n\nstatic inline bool wuffs_base__image_config__is_valid(\n wuffs_base__image_config* c) {\n if (!c || !c->private_impl.pixfmt) {\n return false;\n }\n uint64_t wh =\n ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);\n // TODO: handle things other than 1 byte per pixel.\n //\n // TODO: move the check to wuffs_base__image_config__initialize.\n return wh <= ((uint64_t)SIZE_MAX);\n}\n\nstatic inline wuffs_base__pixel_format wuffs_base__image_config__pixel_format(\n wuffs_base__image_config* c) {\n return c ? c->private_impl.pixfmt : 0;\n}\n\nstatic inline wuffs_base__pixel_" + - "subsampling\nwuffs_base__image_config__pixel_subsampling(wuffs_base__image_config* c) {\n return wuffs_base__image_config__is_valid(c) ? c->private_impl.pixsub : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__width(\n wuffs_base__image_config* c) {\n return wuffs_base__image_config__is_valid(c) ? c->private_impl.width : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__height(\n wuffs_base__image_config* c) {\n return wuffs_base__image_config__is_valid(c) ? c->private_impl.height : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__num_loops(\n wuffs_base__image_config* c) {\n return wuffs_base__image_config__is_valid(c) ? c->private_impl.num_loops : 0;\n}\n\n// TODO: this is the right API for planar (not packed) pixbufs? Should it allow\n// decoding into a color model different from the format's intrinsic one? For\n// example, decoding a JPEG image straight to RGBA instead of to YCbCr?\nstatic inline size_t wuffs_base__image_config__pixbuf_size(\n wuffs_base__image_config* c) {\n if (wuffs_" + - "base__image_config__is_valid(c)) {\n uint64_t wh =\n ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);\n // TODO: handle things other than 1 byte per pixel.\n return (size_t)wh;\n }\n return 0;\n}\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__image_config config;\n uint32_t loop_count; // 0-based count of the current loop.\n wuffs_base__pixel_buffer pixbuf;\n // TODO: color spaces.\n wuffs_base__rectangle dirty_rect;\n wuffs_base__flicks duration;\n uint8_t palette[1024];\n } private_impl;\n} wuffs_base__image_buffer;\n\nstatic inline void wuffs_base__image_buffer__initialize(\n wuffs_base__image_buffer* f,\n wuffs_base__image_config config,\n wuffs_base__pixel_buffer pixbuf) {\n if (!f) {\n return;\n }\n *f = ((wuffs_base__image_buffer){});\n f->private_impl.config = config;\n f->private_impl.pixbuf = pixbuf;\n}\n\nstatic inline void wu" + - "ffs_base__image_buffer__update(\n wuffs_base__image_buffer* f,\n wuffs_base__rectangle dirty_rect,\n wuffs_base__flicks duration,\n uint8_t* palette_ptr,\n size_t palette_len) {\n if (!f) {\n return;\n }\n f->private_impl.dirty_rect = dirty_rect;\n f->private_impl.duration = duration;\n if (palette_ptr) {\n memmove(f->private_impl.palette, palette_ptr,\n palette_len <= 1024 ? palette_len : 1024);\n }\n}\n\n// wuffs_base__image_buffer__loop returns whether the image decoder should loop\n// back to the beginning of the animation, assuming that we've reached the end\n// of the encoded stream. If so, it increments f's count of the animation loops\n// played so far.\nstatic inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* f) {\n if (!f) {\n return false;\n }\n uint32_t n = f->private_impl.config.private_impl.num_loops;\n if (n == 0) {\n return true;\n }\n if (f->private_impl.loop_count < n - 1) {\n f->private_impl.loop_count++;\n return true;\n }\n return false;\n}\n\n// w" + - "uffs_base__image_buffer__dirty_rect returns an upper bound for what part of\n// this frame's pixels differs from the previous frame.\nstatic inline wuffs_base__rectangle wuffs_base__image_buffer__dirty_rect(\n wuffs_base__image_buffer* f) {\n return f ? f->private_impl.dirty_rect : ((wuffs_base__rectangle){0});\n}\n\n// wuffs_base__image_buffer__duration returns the amount of time to display\n// this frame. Zero means to display forever - a still (non-animated) image.\nstatic inline wuffs_base__flicks wuffs_base__image_buffer__duration(\n wuffs_base__image_buffer* f) {\n return f ? f->private_impl.duration : 0;\n}\n\n// wuffs_base__image_buffer__palette returns the palette that the pixel data\n// can index. The backing array is inside f and has length 1024.\nstatic inline uint8_t* wuffs_base__image_buffer__palette(\n wuffs_base__image_buffer* f) {\n return f ? f->private_impl.palette : NULL;\n}\n\n#endif // WUFFS_BASE_HEADER_H\n" + + "t width;\n size_t height;\n size_t stride;\n} wuffs_base__table_u8;\n\n// ---------------- I/O\n\n// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length), plus\n// additional indexes into that buffer, plus an opened / closed flag.\n//\n// A value with all fields NULL or zero is a valid, empty buffer.\ntypedef struct {\n uint8_t* ptr; // Pointer.\n size_t len; // Length.\n size_t wi; // Write index. Invariant: wi <= len.\n size_t ri; // Read index. Invariant: ri <= wi.\n bool closed; // No further writes are expected.\n} wuffs_base__io_buffer;\n\n// wuffs_base__io_limit provides a limited view of a 1-dimensional byte stream:\n// its first N bytes. That N can be greater than a buffer's current read or\n// write capacity. N decreases naturally over time as bytes are read from or\n// written to the stream.\n//\n// A value with all fields NULL or zero is a valid, unlimited view.\ntypedef struct wuffs_base__io_limit {\n uint64_t* ptr_to_len; // Pointer to N.\n struct wuffs_base__io_limi" + + "t* next; // Linked list of limits.\n} wuffs_base__io_limit;\n\ntypedef struct {\n // TODO: move buf into private_impl? As it is, it looks like users can modify\n // the buf field to point to a different buffer, which can turn the limit and\n // mark fields into dangling pointers.\n wuffs_base__io_buffer* buf;\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__io_limit limit;\n uint8_t* mark;\n } private_impl;\n} wuffs_base__io_reader;\n\ntypedef struct {\n // TODO: move buf into private_impl? As it is, it looks like users can modify\n // the buf field to point to a different buffer, which can turn the limit and\n // mark fields into dangling pointers.\n wuffs_base__io_buffer* buf;\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__io_limit limit;\n uint8_t* mark;\n } private_impl;\n} wuffs_base__io_writer;\n" + + "\n// ---------------- Images\n\n// wuffs_base__pixel_format encodes the format of the bytes that constitute an\n// image frame's pixel data. Its bits:\n// - bit 31 is reserved.\n// - bits 30 .. 28 encodes color (and channel order, in terms of memory).\n// - bits 27 .. 26 are reserved.\n// - bits 25 .. 24 encodes transparency.\n// - bit 23 indicates big-endian/MSB-first (as opposed to little/LSB).\n// - bit 22 indicates floating point (as opposed to integer).\n// - bits 21 .. 20 are the number of planes, minus 1. Zero means packed.\n// - bits 19 .. 16 encodes the number of bits (depth) in an index value.\n// Zero means direct, not palette-indexed.\n// - bits 15 .. 12 encodes the number of bits (depth) in the 3rd channel.\n// - bits 11 .. 8 encodes the number of bits (depth) in the 2nd channel.\n// - bits 7 .. 4 encodes the number of bits (depth) in the 1st channel.\n// - bits 3 .. 0 encodes the number of bits (depth) in the 0th channel.\n//\n// The bit fields of a wuffs_bas" + + "e__pixel_format are not independent. For\n// example, the number of planes should not be greater than the number of\n// channels. Similarly, bits 15..4 are unused (and should be zero) if bits\n// 31..24 (color and transparency) together imply only 1 channel (gray, no\n// alpha) and floating point samples should mean a bit depth of 16, 32 or 64.\n//\n// Formats hold between 1 and 4 channels. For example: Y (1 channel: gray), YA\n// (2 channels: gray and alpha), BGR (3 channels: blue, green, red) or CMYK (4\n// channels: cyan, magenta, yellow, black).\n//\n// For direct formats with N > 1 channels, those channels can be laid out in\n// either 1 (packed) or N (planar) planes. For example, RGBA data is usually\n// packed, but YUV data is usually planar, due to chroma subsampling (for\n// details, see the wuffs_base__pixel_subsampling type). For indexed formats,\n// the palette (always 256 × 4 bytes) holds up to 4 packed bytes of color data\n// per index value, and there is only 1 plane (for the index). The distance\n// between " + + "successive palette elements is always 4 bytes.\n//\n// The color field is encoded in 3 bits:\n// - 0 means A (Alpha).\n// - 1 means Y or YA (Gray, Alpha).\n// - 2 means BGR, BGRX or BGRA (Blue, Green, Red, X-padding or Alpha).\n// - 3 means RGB, RGBX or RGBA (Red, Green, Blue, X-padding or Alpha).\n// - 4 means YUV or YUVA (Luma, Chroma-blue, Chroma-red, Alpha).\n// - 5 means CMY or CMYK (Cyan, Magenta, Yellow, Black).\n// - all other values are reserved.\n//\n// In Wuffs, channels are given in memory order, regardless of endianness,\n// since the C type for the pixel data is an array of bytes, not an array of\n// uint32_t. For example, packed BGRA with 8 bits per channel means that the\n// bytes in memory are always Blue, Green, Red then Alpha. On big-endian\n// systems, that is the uint32_t 0xBBGGRRAA. On little-endian, 0xAARRGGBB.\n//\n// When the color field (3 bits) encodes multiple options, the transparency\n// field (2 bits) distinguishes them:\n// - 0 means fully opaque, no " + + "extra channels\n// - 1 means fully opaque, one extra channel (X or K, padding or black).\n// - 2 means one extra alpha channel, other channels are non-premultiplied.\n// - 3 means one extra alpha channel, other channels are premultiplied.\n//\n// The zero wuffs_base__pixel_format value is an invalid pixel format, as it is\n// invalid to combine the zero color (alpha only) with the zero transparency.\n//\n// Bit depth is encoded in 4 bits:\n// - 0 means the channel or index is unused.\n// - x means a bit depth of x, for x in the range 1..8.\n// - 9 means a bit depth of 10.\n// - 10 means a bit depth of 12.\n// - 11 means a bit depth of 16.\n// - 12 means a bit depth of 24.\n// - 13 means a bit depth of 32.\n// - 14 means a bit depth of 48.\n// - 15 means a bit depth of 64.\n//\n// For example, wuffs_base__pixel_format 0x3280BBBB is a natural format for\n// decoding a PNG image - network byte order (also known as big-endian),\n// packed, non-premultiplied alpha - that happens to be 16-bit-depth truecolor\n// with" + + " alpha (RGBA). In memory order:\n//\n// ptr+0 ptr+1 ptr+2 ptr+3 ptr+4 ptr+5 ptr+6 ptr+7\n// Rhi Rlo Ghi Glo Bhi Blo Ahi Alo\n//\n// For example, the value wuffs_base__pixel_format 0x20000565 means BGR with no\n// alpha or padding, 5/6/5 bits for blue/green/red, packed 2 bytes per pixel,\n// laid out LSB-first in memory order:\n//\n// ptr+0........... ptr+1...........\n// MSB LSB MSB LSB\n// G₂G₁G₀B₄B₃B₂B₁B₀ R₄R₃R₂R₁R₀G₅G₄G₃\n//\n// On little-endian systems (but not big-endian), this Wuffs pixel format value\n// (0x20000565) corresponds to the Cairo library's CAIRO_FORMAT_RGB16_565, the\n// SDL2 (Simple DirectMedia Layer 2) library's SDL_PIXELFORMAT_RGB565 and the\n// Skia library's kRGB_565_SkColorType. Note BGR in Wuffs versus RGB in the\n// other libraries.\n//\n// Regardless of endianness, this Wuffs pixel format value (0x20000565)\n// corresponds to the V4L2 (Video For Linux 2) library's V4L2_PIX_FMT_RGB565\n// and the Wayland-DRM library's " + + "WL_DRM_FORMAT_RGB565.\n//\n// Different software libraries name their pixel formats (and especially their\n// channel order) either according to memory layout or as bits of a native\n// integer type like uint32_t. The two conventions differ because of a system's\n// endianness. As mentioned earlier, Wuffs pixel formats are always in memory\n// order. More detail of other software libraries' naming conventions is in the\n// Pixel Format Guide at https://afrantzis.github.io/pixel-format-guide/\n//\n// Do not manipulate these bits directly; they are private implementation\n// details. Use methods such as wuffs_base__pixel_format__num_planes instead.\ntypedef uint32_t wuffs_base__pixel_format;\n\n// Common 8-bit-depth pixel formats. This list is not exhaustive; not all valid\n// wuffs_base__pixel_format values are present.\n\n#define WUFFS_BASE__PIXEL_FORMAT__INVALID ((wuffs_base__pixel_format)0x00000000)\n\n#define WUFFS_BASE__PIXEL_FORMAT__A ((wuffs_base__pixel_format)0x02000008)\n\n#define WUFFS_BASE__PIXEL_FORMAT__Y ((wuffs_base" + + "__pixel_format)0x10000008)\n#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x12000008)\n#define WUFFS_BASE__PIXEL_FORMAT__YA_PREMUL \\\n ((wuffs_base__pixel_format)0x13000008)\n\n#define WUFFS_BASE__PIXEL_FORMAT__BGR ((wuffs_base__pixel_format)0x20000888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRX ((wuffs_base__pixel_format)0x21008888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRX_INDEXED \\\n ((wuffs_base__pixel_format)0x21088888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x22008888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_INDEXED \\\n ((wuffs_base__pixel_format)0x22088888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL \\\n ((wuffs_base__pixel_format)0x23008888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__RGB ((wuffs_base__pixel_format)0x30000888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBX ((wuffs_base__pixel_format)0x31008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBX_INDEXED \\\n ((wuffs_base__pixel_format)0x31088888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMU" + + "L \\\n ((wuffs_base__pixel_format)0x32008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_INDEXED \\\n ((wuffs_base__pixel_format)0x32088888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL \\\n ((wuffs_base__pixel_format)0x33008888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__YUV ((wuffs_base__pixel_format)0x40200888)\n#define WUFFS_BASE__PIXEL_FORMAT__YUVK ((wuffs_base__pixel_format)0x41308888)\n#define WUFFS_BASE__PIXEL_FORMAT__YUVA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x42308888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__CMY ((wuffs_base__pixel_format)0x50200888)\n#define WUFFS_BASE__PIXEL_FORMAT__CMYK ((wuffs_base__pixel_format)0x51308888)\n\nstatic inline bool wuffs_base__pixel_format__is_valid(\n wuffs_base__pixel_format f) {\n return f != 0;\n}\n\nstatic inline bool wuffs_base__pixel_format__is_indexed(\n wuffs_base__pixel_format f) {\n return ((f >> 16) & 0x0F) != 0;\n}\n\n#define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4\n\nstatic inline uint32_t wuffs_base__pixel_format__num_planes(\n wuffs_base__pixel_format f) {\n " + + " return f ? (((f >> 20) & 0x03) + 1) : 0;\n}\n\ntypedef struct {\n wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX];\n} wuffs_base__pixel_buffer;\n\n// wuffs_base__pixel_subsampling encodes the mapping of pixel space coordinates\n// (x, y) to pixel buffer indices (i, j). That mapping can differ for each\n// plane p. For a depth of 8 bits (1 byte), the p'th plane's sample starts at\n// (planes[p].ptr + (j * planes[p].stride) + i).\n//\n// For packed pixel formats, the mapping is trivial: i = x and j = y. For\n// planar pixel formats, the mapping can differ due to chroma subsampling. For\n// example, consider a three plane YUV pixel format with 4:2:2 subsampling. For\n// the luma (Y) channel, there is one sample for every pixel, but for the\n// chroma (U, V) channels, there is one sample for every two pixels: pairs of\n// horizontally adjacent pixels form one macropixel, i = x / 2 and j == y. In\n// general, for a given p:\n// - i = (x + bias_x) >> shift_x.\n// - j = (y + bias_y) >> shift_y.\n// where biases" + + " and shifts are in the range 0..3 and 0..2 respectively.\n//\n// In general, the biases will be zero after decoding an image. However, making\n// a sub-image may change the bias, since the (x, y) coordinates are relative\n// to the sub-image's top-left origin, but the backing pixel buffers were\n// created relative to the original image's origin.\n//\n// For each plane p, each of those four numbers (biases and shifts) are encoded\n// in two bits, which combine to form an 8 bit unsigned integer:\n//\n// e_p = (bias_x << 6) | (shift_x << 4) | (bias_y << 2) | (shift_y << 0)\n//\n// Those e_p values (e_0 for the first plane, e_1 for the second plane, etc)\n// combine to form a wuffs_base__pixel_subsampling value:\n//\n// pixsub = (e_3 << 24) | (e_2 << 16) | (e_1 << 8) | (e_0 << 0)\n//\n// Do not manipulate these bits directly; they are private implementation\n// details. Use methods such as wuffs_base__pixel_subsampling__bias_x instead.\ntypedef uint32_t wuffs_base__pixel_subsampling;\n\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__NONE " + + "((wuffs_base__pixel_subsampling)0);\n\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__444 \\\n ((wuffs_base__pixel_subsampling)0x000000);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__440 \\\n ((wuffs_base__pixel_subsampling)0x010100);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__422 \\\n ((wuffs_base__pixel_subsampling)0x101000);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__420 \\\n ((wuffs_base__pixel_subsampling)0x111100);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__411 \\\n ((wuffs_base__pixel_subsampling)0x202000);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__410 \\\n ((wuffs_base__pixel_subsampling)0x212100);\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__bias_x(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 6;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__shift_x(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 4;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t wuffs_base__pixel_subsam" + + "pling__bias_y(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 2;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__shift_y(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 0;\n return (s >> shift) & 0x03;\n}\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__pixel_format pixfmt;\n wuffs_base__pixel_subsampling pixsub;\n uint32_t width;\n uint32_t height;\n uint32_t num_loops;\n } private_impl;\n} wuffs_base__image_config;\n\nstatic inline void wuffs_base__image_config__initialize(\n wuffs_base__image_config* c,\n wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height,\n uint32_t num_loops) {\n if (!c) {\n return;\n }\n // TODO: move the check from wuffs_base__image_config__is_v" + + "alid here. Should\n // this function return bool? An error type?\n c->private_impl.pixfmt = pixfmt;\n c->private_impl.pixsub = pixsub;\n c->private_impl.width = width;\n c->private_impl.height = height;\n c->private_impl.num_loops = num_loops;\n}\n\nstatic inline void wuffs_base__image_config__invalidate(\n wuffs_base__image_config* c) {\n if (c) {\n *c = ((wuffs_base__image_config){});\n }\n}\n\nstatic inline bool wuffs_base__image_config__is_valid(\n wuffs_base__image_config* c) {\n if (!c || !c->private_impl.pixfmt) {\n return false;\n }\n uint64_t wh =\n ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);\n // TODO: handle things other than 1 byte per pixel.\n //\n // TODO: move the check to wuffs_base__image_config__initialize.\n return wh <= ((uint64_t)SIZE_MAX);\n}\n\nstatic inline wuffs_base__pixel_format wuffs_base__image_config__pixel_format(\n wuffs_base__image_config* c) {\n return c ? c->private_impl.pixfmt : 0;\n}\n\nstatic inline wuffs_base__pixel_subsampling\nwuffs_base__i" + + "mage_config__pixel_subsampling(wuffs_base__image_config* c) {\n return wuffs_base__image_config__is_valid(c) ? c->private_impl.pixsub : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__width(\n wuffs_base__image_config* c) {\n return wuffs_base__image_config__is_valid(c) ? c->private_impl.width : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__height(\n wuffs_base__image_config* c) {\n return wuffs_base__image_config__is_valid(c) ? c->private_impl.height : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__num_loops(\n wuffs_base__image_config* c) {\n return wuffs_base__image_config__is_valid(c) ? c->private_impl.num_loops : 0;\n}\n\n// TODO: this is the right API for planar (not packed) pixbufs? Should it allow\n// decoding into a color model different from the format's intrinsic one? For\n// example, decoding a JPEG image straight to RGBA instead of to YCbCr?\nstatic inline size_t wuffs_base__image_config__pixbuf_size(\n wuffs_base__image_config* c) {\n if (wuffs_base__image_config__is_va" + + "lid(c)) {\n uint64_t wh =\n ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);\n // TODO: handle things other than 1 byte per pixel.\n return (size_t)wh;\n }\n return 0;\n}\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__image_config config;\n uint32_t loop_count; // 0-based count of the current loop.\n wuffs_base__pixel_buffer pixbuf;\n // TODO: color spaces.\n wuffs_base__rectangle dirty_rect;\n wuffs_base__flicks duration;\n uint8_t palette[1024];\n } private_impl;\n} wuffs_base__image_buffer;\n\nstatic inline void wuffs_base__image_buffer__initialize(\n wuffs_base__image_buffer* f,\n wuffs_base__image_config config,\n wuffs_base__pixel_buffer pixbuf) {\n if (!f) {\n return;\n }\n *f = ((wuffs_base__image_buffer){});\n f->private_impl.config = config;\n f->private_impl.pixbuf = pixbuf;\n}\n\nstatic inline void wuffs_base__image_buffer__u" + + "pdate(\n wuffs_base__image_buffer* f,\n wuffs_base__rectangle dirty_rect,\n wuffs_base__flicks duration,\n uint8_t* palette_ptr,\n size_t palette_len) {\n if (!f) {\n return;\n }\n f->private_impl.dirty_rect = dirty_rect;\n f->private_impl.duration = duration;\n if (palette_ptr) {\n memmove(f->private_impl.palette, palette_ptr,\n palette_len <= 1024 ? palette_len : 1024);\n }\n}\n\n// wuffs_base__image_buffer__loop returns whether the image decoder should loop\n// back to the beginning of the animation, assuming that we've reached the end\n// of the encoded stream. If so, it increments f's count of the animation loops\n// played so far.\nstatic inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* f) {\n if (!f) {\n return false;\n }\n uint32_t n = f->private_impl.config.private_impl.num_loops;\n if (n == 0) {\n return true;\n }\n if (f->private_impl.loop_count < n - 1) {\n f->private_impl.loop_count++;\n return true;\n }\n return false;\n}\n\n// wuffs_base__image_buffer__" + + "dirty_rect returns an upper bound for what part of\n// this frame's pixels differs from the previous frame.\nstatic inline wuffs_base__rectangle wuffs_base__image_buffer__dirty_rect(\n wuffs_base__image_buffer* f) {\n return f ? f->private_impl.dirty_rect : ((wuffs_base__rectangle){0});\n}\n\n// wuffs_base__image_buffer__duration returns the amount of time to display\n// this frame. Zero means to display forever - a still (non-animated) image.\nstatic inline wuffs_base__flicks wuffs_base__image_buffer__duration(\n wuffs_base__image_buffer* f) {\n return f ? f->private_impl.duration : 0;\n}\n\n// wuffs_base__image_buffer__palette returns the palette that the pixel data\n// can index. The backing array is inside f and has length 1024.\nstatic inline uint8_t* wuffs_base__image_buffer__palette(\n wuffs_base__image_buffer* f) {\n return f ? f->private_impl.palette : NULL;\n}\n\n#endif // WUFFS_BASE_HEADER_H\n" + "" const baseImpl = "" + @@ -48,12 +48,12 @@ const baseImpl = "" + "(expr) (__builtin_expect(!!(expr), 1))\n#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))\n#else\n#define WUFFS_BASE__LIKELY(expr) (expr)\n#define WUFFS_BASE__UNLIKELY(expr) (expr)\n#endif\n\n// Uncomment this #include for printf-debugging.\n// #include \n\n// ---------------- Static Inline Functions\n//\n// The helpers below are functions, instead of macros, because their arguments\n// can be an expression that we shouldn't evaluate more than once.\n//\n// They are in base-impl.h and hence copy/pasted into every generated C file,\n// instead of being in some \"base.c\" file, since a design goal is that users of\n// the generated C code can often just #include a single .c file, such as\n// \"gif.c\", without having to additionally include or otherwise build and link\n// a \"base.c\" file.\n//\n// They are static, so that linking multiple wuffs .o files won't complain about\n// duplicate function definitions.\n//\n// They are explicitly marked inline, even if modern compilers don't use the\n// inline attribute to g" + "uide optimizations such as inlining, to avoid the\n// -Wunused-function warning, and we like to compile with -Wall -Werror.\n\nstatic inline uint16_t wuffs_base__load_u16be(uint8_t* p) {\n return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0);\n}\n\nstatic inline uint16_t wuffs_base__load_u16le(uint8_t* p) {\n return ((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8);\n}\n\nstatic inline uint32_t wuffs_base__load_u32be(uint8_t* p) {\n return ((uint32_t)(p[0]) << 24) | ((uint32_t)(p[1]) << 16) |\n ((uint32_t)(p[2]) << 8) | ((uint32_t)(p[3]) << 0);\n}\n\nstatic inline uint32_t wuffs_base__load_u32le(uint8_t* p) {\n return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24);\n}\n\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i(\n wuffs_base__slice_u8 s,\n uint64_t i) {\n if ((i <= SIZE_MAX) && (i <= s.len)) {\n return ((wuffs_base__slice_u8){\n .ptr = s.ptr + i,\n .len = s.len - i,\n });\n }\n return ((wuffs_base__sli" + "ce_u8){});\n}\n\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_j(\n wuffs_base__slice_u8 s,\n uint64_t j) {\n if ((j <= SIZE_MAX) && (j <= s.len)) {\n return ((wuffs_base__slice_u8){.ptr = s.ptr, .len = j});\n }\n return ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_ij(\n wuffs_base__slice_u8 s,\n uint64_t i,\n uint64_t j) {\n if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) {\n return ((wuffs_base__slice_u8){\n .ptr = s.ptr + i,\n .len = j - i,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\n// wuffs_base__slice_u8__prefix returns up to the first up_to bytes of s.\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__prefix(\n wuffs_base__slice_u8 s,\n uint64_t up_to) {\n if ((uint64_t)(s.len) > up_to) {\n s.len = up_to;\n }\n return s;\n}\n\n// wuffs_base__slice_u8__suffix returns up to the last up_to bytes of s.\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8_suffix(\n wuffs_base__slice_u8 s,\n " + - " uint64_t up_to) {\n if ((uint64_t)(s.len) > up_to) {\n s.ptr += (uint64_t)(s.len) - up_to;\n s.len = up_to;\n }\n return s;\n}\n\n// wuffs_base__slice_u8__copy_from_slice calls memmove(dst.ptr, src.ptr,\n// length) where length is the minimum of dst.len and src.len.\n//\n// Passing a wuffs_base__slice_u8 with all fields NULL or zero (a valid, empty\n// slice) is valid and results in a no-op.\nstatic inline uint64_t wuffs_base__slice_u8__copy_from_slice(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src) {\n size_t length = dst.len < src.len ? dst.len : src.len;\n if (length > 0) {\n memmove(dst.ptr, src.ptr, length);\n }\n return length;\n}\n\nstatic inline uint32_t wuffs_base__writer1__copy_from_history32(\n uint8_t** ptr_ptr,\n uint8_t* start, // May be NULL, meaning an unmarked writer1.\n uint8_t* end,\n uint32_t distance,\n uint32_t length) {\n if (!start || !distance) {\n return 0;\n }\n uint8_t* ptr = *ptr_ptr;\n if ((size_t)(ptr - start) < (size_t)(distance)) {\n return 0;\n }\n s" + - "tart = ptr - distance;\n size_t n = end - ptr;\n if ((size_t)(length) > n) {\n length = n;\n } else {\n n = length;\n }\n // TODO: unrolling by 3 seems best for the std/deflate benchmarks, but that\n // is mostly because 3 is the minimum length for the deflate format. This\n // function implementation shouldn't overfit to that one format. Perhaps the\n // copy_from_history32 Wuffs method should also take an unroll hint argument,\n // and the cgen can look if that argument is the constant expression '3'.\n //\n // See also wuffs_base__writer1__copy_from_history32__bco below.\n //\n // Alternatively, or additionally, have a sloppy_copy_from_history32 method\n // that copies 8 bytes at a time, possibly writing more than length bytes?\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\n// wuffs_base__writer1__copy_from_history32__bco is a Bounds Check Optimized\n// version of the " + - "wuffs_base__writer1__copy_from_history32 function above. The\n// caller needs to prove that:\n// - start != NULL\n// - distance > 0\n// - distance <= (*ptr_ptr - start)\n// - length <= (end - *ptr_ptr)\nstatic inline uint32_t wuffs_base__writer1__copy_from_history32__bco(\n uint8_t** ptr_ptr,\n uint8_t* start,\n uint8_t* end,\n uint32_t distance,\n uint32_t length) {\n uint8_t* ptr = *ptr_ptr;\n start = ptr - distance;\n uint32_t n = length;\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\nstatic inline uint32_t wuffs_base__writer1__copy_from_reader32(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n uint8_t** ptr_rptr,\n uint8_t* rend,\n uint32_t length) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = length;\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n uint8_t* rptr = *ptr_rptr;\n if (n > rend - rptr) {\n n = rend - rptr;\n }\n if (n > 0) {\n memm" + - "ove(wptr, rptr, n);\n *ptr_wptr += n;\n *ptr_rptr += n;\n }\n return n;\n}\n\nstatic inline uint64_t wuffs_base__writer1__copy_from_slice(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n wuffs_base__slice_u8 src) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = src.len;\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n if (n > 0) {\n memmove(wptr, src.ptr, n);\n *ptr_wptr += n;\n }\n return n;\n}\n\nstatic inline uint32_t wuffs_base__writer1__copy_from_slice32(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n wuffs_base__slice_u8 src,\n uint32_t length) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = src.len;\n if (n > length) {\n n = length;\n }\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n if (n > 0) {\n memmove(wptr, src.ptr, n);\n *ptr_wptr += n;\n }\n return n;\n}\n\n// Note that the *__limit and *__mark methods are private (in base-impl.h) not\n// public (in base-header.h). We assume that, at the boundary between user code\n// and Wuffs code, the reader1 and writer1's private_impl fields (including\n// " + - "limit and mark) are NULL. Otherwise, some internal assumptions break down.\n// For example, limits could be represented as pointers, even though\n// conceptually they are counts, but that pointer-to-count correspondence\n// becomes invalid if a buffer is re-used (e.g. on resuming a coroutine).\n//\n// Admittedly, some of the Wuffs test code calls these methods, but that test\n// code is still Wuffs code, not user code. Other Wuffs test code modifies\n// private_impl fields directly.\n\nstatic inline wuffs_base__reader1 wuffs_base__reader1__limit(\n wuffs_base__reader1* o,\n uint64_t* ptr_to_len) {\n wuffs_base__reader1 ret = *o;\n ret.private_impl.limit.ptr_to_len = ptr_to_len;\n ret.private_impl.limit.next = &o->private_impl.limit;\n return ret;\n}\n\nstatic inline wuffs_base__empty_struct wuffs_base__reader1__mark(\n wuffs_base__reader1* o,\n uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n\n// TODO: static inline wuffs_base__writer1 wuffs_base__writer1__limit()\n\nstatic" + - " inline wuffs_base__empty_struct wuffs_base__writer1__mark(\n wuffs_base__writer1* o,\n uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n" + + " uint64_t up_to) {\n if ((uint64_t)(s.len) > up_to) {\n s.ptr += (uint64_t)(s.len) - up_to;\n s.len = up_to;\n }\n return s;\n}\n\n// wuffs_base__slice_u8__copy_from_slice calls memmove(dst.ptr, src.ptr,\n// length) where length is the minimum of dst.len and src.len.\n//\n// Passing a wuffs_base__slice_u8 with all fields NULL or zero (a valid, empty\n// slice) is valid and results in a no-op.\nstatic inline uint64_t wuffs_base__slice_u8__copy_from_slice(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src) {\n size_t length = dst.len < src.len ? dst.len : src.len;\n if (length > 0) {\n memmove(dst.ptr, src.ptr, length);\n }\n return length;\n}\n\nstatic inline uint32_t wuffs_base__io_writer__copy_from_history32(\n uint8_t** ptr_ptr,\n uint8_t* start, // May be NULL, meaning an unmarked io_writer.\n uint8_t* end,\n uint32_t distance,\n uint32_t length) {\n if (!start || !distance) {\n return 0;\n }\n uint8_t* ptr = *ptr_ptr;\n if ((size_t)(ptr - start) < (size_t)(distance)) {\n return 0;\n }" + + "\n start = ptr - distance;\n size_t n = end - ptr;\n if ((size_t)(length) > n) {\n length = n;\n } else {\n n = length;\n }\n // TODO: unrolling by 3 seems best for the std/deflate benchmarks, but that\n // is mostly because 3 is the minimum length for the deflate format. This\n // function implementation shouldn't overfit to that one format. Perhaps the\n // copy_from_history32 Wuffs method should also take an unroll hint argument,\n // and the cgen can look if that argument is the constant expression '3'.\n //\n // See also wuffs_base__io_writer__copy_from_history32__bco below.\n //\n // Alternatively, or additionally, have a sloppy_copy_from_history32 method\n // that copies 8 bytes at a time, possibly writing more than length bytes?\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\n// wuffs_base__io_writer__copy_from_history32__bco is a Bounds Check Optimized\n// version" + + " of the wuffs_base__io_writer__copy_from_history32 function above.\n// The caller needs to prove that:\n// - start != NULL\n// - distance > 0\n// - distance <= (*ptr_ptr - start)\n// - length <= (end - *ptr_ptr)\nstatic inline uint32_t wuffs_base__io_writer__copy_from_history32__bco(\n uint8_t** ptr_ptr,\n uint8_t* start,\n uint8_t* end,\n uint32_t distance,\n uint32_t length) {\n uint8_t* ptr = *ptr_ptr;\n start = ptr - distance;\n uint32_t n = length;\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\nstatic inline uint32_t wuffs_base__io_writer__copy_from_reader32(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n uint8_t** ptr_rptr,\n uint8_t* rend,\n uint32_t length) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = length;\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n uint8_t* rptr = *ptr_rptr;\n if (n > rend - rptr) {\n n = rend - rptr;\n }\n if (n >" + + " 0) {\n memmove(wptr, rptr, n);\n *ptr_wptr += n;\n *ptr_rptr += n;\n }\n return n;\n}\n\nstatic inline uint64_t wuffs_base__io_writer__copy_from_slice(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n wuffs_base__slice_u8 src) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = src.len;\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n if (n > 0) {\n memmove(wptr, src.ptr, n);\n *ptr_wptr += n;\n }\n return n;\n}\n\nstatic inline uint32_t wuffs_base__io_writer__copy_from_slice32(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n wuffs_base__slice_u8 src,\n uint32_t length) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = src.len;\n if (n > length) {\n n = length;\n }\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n if (n > 0) {\n memmove(wptr, src.ptr, n);\n *ptr_wptr += n;\n }\n return n;\n}\n\n// Note that the *__limit and *__mark methods are private (in base-impl.h) not\n// public (in base-header.h). We assume that, at the boundary between user code\n// and Wuffs code, the io_reader and io_writer's private_impl" + + " fields (including\n// limit and mark) are NULL. Otherwise, some internal assumptions break down.\n// For example, limits could be represented as pointers, even though\n// conceptually they are counts, but that pointer-to-count correspondence\n// becomes invalid if a buffer is re-used (e.g. on resuming a coroutine).\n//\n// Admittedly, some of the Wuffs test code calls these methods, but that test\n// code is still Wuffs code, not user code. Other Wuffs test code modifies\n// private_impl fields directly.\n\nstatic inline wuffs_base__io_reader wuffs_base__io_reader__limit(\n wuffs_base__io_reader* o,\n uint64_t* ptr_to_len) {\n wuffs_base__io_reader ret = *o;\n ret.private_impl.limit.ptr_to_len = ptr_to_len;\n ret.private_impl.limit.next = &o->private_impl.limit;\n return ret;\n}\n\nstatic inline wuffs_base__empty_struct wuffs_base__io_reader__mark(\n wuffs_base__io_reader* o,\n uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n\n// TODO: static inline wuffs_base__io_writer " + + "wuffs_base__io_writer__limit()\n\nstatic inline wuffs_base__empty_struct wuffs_base__io_writer__mark(\n wuffs_base__io_writer* o,\n uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n" + "" type template_args_short_read struct { diff --git a/cmd/wuffs-c/internal/cgen/expr.go b/cmd/wuffs-c/internal/cgen/expr.go index c418bfc7..6e1fb3ba 100644 --- a/cmd/wuffs-c/internal/cgen/expr.go +++ b/cmd/wuffs-c/internal/cgen/expr.go @@ -175,7 +175,7 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, pp pare return fmt.Errorf(`TODO: cgen an "in.src.limit" expression`) } if isInSrc(g.tm, n, t.KeyMark, 0) { - b.printf("wuffs_base__reader1__mark(&%ssrc, %srptr_src)", aPrefix, bPrefix) + b.printf("wuffs_base__io_reader__mark(&%ssrc, %srptr_src)", aPrefix, bPrefix) return nil } if isInSrc(g.tm, n, t.KeySinceMark, 0) { @@ -185,16 +185,16 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, pp pare aPrefix, aPrefix, bPrefix, aPrefix) return nil } - // TODO: reader1.is_marked, not just writer1.is_marked? + // TODO: io_reader.is_marked, not just io_writer.is_marked? if isInDst(g.tm, n, t.KeyLimit, 1) { return fmt.Errorf(`TODO: cgen an "in.dst.limit" expression`) } if isInDst(g.tm, n, t.KeyMark, 0) { // TODO: is a private_impl.mark the right representation? What if - // the function is passed a (ptr writer1) instead of a (writer1)? - // Do we still want to have that mark live outside of the function - // scope? - b.printf("wuffs_base__writer1__mark(&%sdst, %swptr_dst)", aPrefix, bPrefix) + // the function is passed a (ptr io_writer) instead of a + // (io_writer)? Do we still want to have that mark live outside of + // the function scope? + b.printf("wuffs_base__io_writer__mark(&%sdst, %swptr_dst)", aPrefix, bPrefix) return nil } if isInDst(g.tm, n, t.KeySinceMark, 0) { @@ -224,7 +224,8 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, pp pare return nil } if isInDst(g.tm, n, t.KeyCopyFromReader32, 2) { - b.printf("wuffs_base__writer1__copy_from_reader32(&%swptr_dst, %swend_dst", bPrefix, bPrefix) + b.printf("wuffs_base__io_writer__copy_from_reader32(&%swptr_dst, %swend_dst", + bPrefix, bPrefix) // TODO: don't assume that the first argument is "in.src". b.printf(", &%srptr_src, %srend_src,", bPrefix, bPrefix) a := n.Args()[1].Arg().Value() @@ -239,7 +240,8 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, pp pare if n.BoundsCheckOptimized() { bco = "__bco" } - b.printf("wuffs_base__writer1__copy_from_history32%s(&%swptr_dst, %sdst.private_impl.mark , %swend_dst", + b.printf("wuffs_base__io_writer__copy_from_history32%s("+ + "&%swptr_dst, %sdst.private_impl.mark , %swend_dst", bco, bPrefix, aPrefix, bPrefix) for _, o := range n.Args() { b.writeb(',') @@ -251,7 +253,8 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, pp pare return nil } if isInDst(g.tm, n, t.KeyCopyFromSlice32, 2) { - b.printf("wuffs_base__writer1__copy_from_slice32(&%swptr_dst, %swend_dst", bPrefix, bPrefix) + b.printf("wuffs_base__io_writer__copy_from_slice32("+ + "&%swptr_dst, %swend_dst", bPrefix, bPrefix) for _, o := range n.Args() { b.writeb(',') if err := g.writeExpr(b, o.Arg().Value(), rp, parenthesesOptional, depth); err != nil { @@ -262,7 +265,7 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, pp pare return nil } if isInDst(g.tm, n, t.KeyCopyFromSlice, 1) { - b.printf("wuffs_base__writer1__copy_from_slice(&%swptr_dst, %swend_dst,", bPrefix, bPrefix) + b.printf("wuffs_base__io_writer__copy_from_slice(&%swptr_dst, %swend_dst,", bPrefix, bPrefix) a := n.Args()[0].Arg().Value() if err := g.writeExpr(b, a, rp, parenthesesOptional, depth); err != nil { return err @@ -352,7 +355,7 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, pp pare } if isThatMethod(g.tm, n, t.KeyMark, 0) { // TODO: don't hard-code v_r or b_rptr_src. - b.printf("wuffs_base__reader1__mark(&v_r, b_rptr_src)") + b.printf("wuffs_base__io_reader__mark(&v_r, b_rptr_src)") return nil } if isThatMethod(g.tm, n, t.KeySinceMark, 0) { @@ -624,20 +627,17 @@ func (g *gen) writeCTypeName(b *buffer, n *a.TypeExpr, varNamePrefix string, var } var cTypeNames = [...]string{ - t.KeyI8: "int8_t", - t.KeyI16: "int16_t", - t.KeyI32: "int32_t", - t.KeyI64: "int64_t", - t.KeyU8: "uint8_t", - t.KeyU16: "uint16_t", - t.KeyU32: "uint32_t", - t.KeyU64: "uint64_t", - t.KeyUsize: "size_t", - t.KeyBool: "bool", - t.KeyBuf1: "wuffs_base__buf1", - t.KeyReader1: "wuffs_base__reader1", - t.KeyWriter1: "wuffs_base__writer1", - t.KeyBuf2: "wuffs_base__buf2", + t.KeyI8: "int8_t", + t.KeyI16: "int16_t", + t.KeyI32: "int32_t", + t.KeyI64: "int64_t", + t.KeyU8: "uint8_t", + t.KeyU16: "uint16_t", + t.KeyU32: "uint32_t", + t.KeyU64: "uint64_t", + t.KeyBool: "bool", + t.KeyIOReader: "wuffs_base__io_reader", + t.KeyIOWriter: "wuffs_base__io_writer", } var cOpNames = [256]string{ diff --git a/cmd/wuffs-c/internal/cgen/func.go b/cmd/wuffs-c/internal/cgen/func.go index 20c2002d..c93be850 100644 --- a/cmd/wuffs-c/internal/cgen/func.go +++ b/cmd/wuffs-c/internal/cgen/func.go @@ -401,14 +401,13 @@ func (g *gen) writeFuncImplArgChecks(b *buffer, n *a.Func) error { } var numTypeBounds = [256][2]*big.Int{ - t.KeyI8: {big.NewInt(-1 << 7), big.NewInt(1<<7 - 1)}, - t.KeyI16: {big.NewInt(-1 << 15), big.NewInt(1<<15 - 1)}, - t.KeyI32: {big.NewInt(-1 << 31), big.NewInt(1<<31 - 1)}, - t.KeyI64: {big.NewInt(-1 << 63), big.NewInt(1<<63 - 1)}, - t.KeyU8: {zero, big.NewInt(0).SetUint64(1<<8 - 1)}, - t.KeyU16: {zero, big.NewInt(0).SetUint64(1<<16 - 1)}, - t.KeyU32: {zero, big.NewInt(0).SetUint64(1<<32 - 1)}, - t.KeyU64: {zero, big.NewInt(0).SetUint64(1<<64 - 1)}, - t.KeyUsize: {zero, zero}, - t.KeyBool: {zero, one}, + t.KeyI8: {big.NewInt(-1 << 7), big.NewInt(1<<7 - 1)}, + t.KeyI16: {big.NewInt(-1 << 15), big.NewInt(1<<15 - 1)}, + t.KeyI32: {big.NewInt(-1 << 31), big.NewInt(1<<31 - 1)}, + t.KeyI64: {big.NewInt(-1 << 63), big.NewInt(1<<63 - 1)}, + t.KeyU8: {zero, big.NewInt(0).SetUint64(1<<8 - 1)}, + t.KeyU16: {zero, big.NewInt(0).SetUint64(1<<16 - 1)}, + t.KeyU32: {zero, big.NewInt(0).SetUint64(1<<32 - 1)}, + t.KeyU64: {zero, big.NewInt(0).SetUint64(1<<64 - 1)}, + t.KeyBool: {zero, one}, } diff --git a/cmd/wuffs-c/internal/cgen/statement.go b/cmd/wuffs-c/internal/cgen/statement.go index 40b4e352..5a8c682e 100644 --- a/cmd/wuffs-c/internal/cgen/statement.go +++ b/cmd/wuffs-c/internal/cgen/statement.go @@ -442,7 +442,7 @@ func (g *gen) writeCallSuspendibles(b *buffer, n *a.Expr, depth uint32) error { // TODO: delete these hacks that only matches "in.src.read_u8?()" etc. // - // TODO: check reader1.buf and writer1.buf is non-NULL. + // TODO: check io_reader.buf and io_writer.buf is non-NULL. if isInSrc(g.tm, n, t.KeyReadU8, 0) { if g.currFunk.tempW > maxTemp { return fmt.Errorf("too many temporary variables required") @@ -682,7 +682,7 @@ func (g *gen) writeCallSuspendibles(b *buffer, n *a.Expr, depth uint32) error { // TODO: don't hard-code a_dst or v_r or l_rlimit or v_block_size. b.writes("uint64_t l_rlimit0 = v_block_size;\n") b.printf("%sstatus %s%d = %slzw_decoder__decode(&self->private_impl.f_lzw, %sdst,"+ - "wuffs_base__reader1__limit(&%sr, &l_rlimit0));\n", + "wuffs_base__io_reader__limit(&%sr, &l_rlimit0));\n", g.pkgPrefix, tPrefix, temp, g.pkgPrefix, aPrefix, vPrefix) if err := g.writeLoadExprDerivedVars(b, n); err != nil { diff --git a/cmd/wuffs-c/internal/cgen/var.go b/cmd/wuffs-c/internal/cgen/var.go index 204c375c..d9d1a149 100644 --- a/cmd/wuffs-c/internal/cgen/var.go +++ b/cmd/wuffs-c/internal/cgen/var.go @@ -66,7 +66,7 @@ func (g *gen) findDerivedVars() { switch oTyp.QID() { default: continue - case t.QID{0, t.IDReader1}, t.QID{0, t.IDWriter1}: + case t.QID{0, t.IDIOReader}, t.QID{0, t.IDIOWriter}: // No-op. } if !g.needDerivedVar(o.Name()) { @@ -94,7 +94,7 @@ func (g *gen) writeLoadDerivedVar(b *buffer, name t.ID, typ *a.TypeExpr, header } nameStr := name.Str(g.tm) switch typ.QID() { - case t.QID{0, t.IDReader1}: + case t.QID{0, t.IDIOReader}: if header { b.printf("uint8_t* %srptr_%s = NULL;", bPrefix, nameStr) b.printf("uint8_t* %srstart_%s = NULL;", bPrefix, nameStr) @@ -110,7 +110,7 @@ func (g *gen) writeLoadDerivedVar(b *buffer, name t.ID, typ *a.TypeExpr, header b.printf("uint64_t len = %s%s.buf->wi - %s%s.buf->ri;", aPrefix, nameStr, aPrefix, nameStr) - b.printf("wuffs_base__limit1* lim;\n") + b.printf("wuffs_base__io_limit* lim;\n") b.printf("for (lim = &%s%s.private_impl.limit; lim; lim = lim->next) {\n", aPrefix, nameStr) b.printf("if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {\n") b.printf("len = *lim->ptr_to_len;\n") @@ -122,7 +122,7 @@ func (g *gen) writeLoadDerivedVar(b *buffer, name t.ID, typ *a.TypeExpr, header b.printf("}\n") - case t.QID{0, t.IDWriter1}: + case t.QID{0, t.IDIOWriter}: if header { b.printf("uint8_t* %swptr_%s = NULL;", bPrefix, nameStr) b.printf("uint8_t* %swstart_%s = NULL;", bPrefix, nameStr) @@ -140,7 +140,7 @@ func (g *gen) writeLoadDerivedVar(b *buffer, name t.ID, typ *a.TypeExpr, header b.printf("if (!%s%s.buf->closed) {", aPrefix, nameStr) b.printf("uint64_t len = %s%s.buf->len - %s%s.buf->wi;", aPrefix, nameStr, aPrefix, nameStr) - b.printf("wuffs_base__limit1* lim;\n") + b.printf("wuffs_base__io_limit* lim;\n") b.printf("for (lim = &%s%s.private_impl.limit; lim; lim = lim->next) {\n", aPrefix, nameStr) b.printf("if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {\n") b.printf("len = *lim->ptr_to_len;\n") @@ -171,14 +171,14 @@ func (g *gen) writeSaveDerivedVar(b *buffer, name t.ID, typ *a.TypeExpr, footer } nameStr := name.Str(g.tm) switch typ.QID() { - case t.QID{0, t.IDReader1}: + case t.QID{0, t.IDIOReader}: b.printf("if (%s%s.buf) {", aPrefix, nameStr) b.printf("size_t n = %srptr_%s - (%s%s.buf->ptr + %s%s.buf->ri);", bPrefix, nameStr, aPrefix, nameStr, aPrefix, nameStr) b.printf("%s%s.buf->ri += n;", aPrefix, nameStr) - b.printf("wuffs_base__limit1* lim;\n") + b.printf("wuffs_base__io_limit* lim;\n") b.printf("for (lim = &%s%s.private_impl.limit; lim; lim = lim->next) {\n", aPrefix, nameStr) b.printf("if (lim->ptr_to_len) {\n") b.printf("*lim->ptr_to_len -= n;\n") @@ -192,14 +192,14 @@ func (g *gen) writeSaveDerivedVar(b *buffer, name t.ID, typ *a.TypeExpr, footer b.printf("}\n") - case t.QID{0, t.IDWriter1}: + case t.QID{0, t.IDIOWriter}: b.printf("if (%s%s.buf) {", aPrefix, nameStr) b.printf("size_t n = %swptr_%s - (%s%s.buf->ptr + %s%s.buf->wi);", bPrefix, nameStr, aPrefix, nameStr, aPrefix, nameStr) b.printf("%s%s.buf->wi += n;", aPrefix, nameStr) - b.printf("wuffs_base__limit1* lim;\n") + b.printf("wuffs_base__io_limit* lim;\n") b.printf("for (lim = &%s%s.private_impl.limit; lim; lim = lim->next) {\n", aPrefix, nameStr) b.printf("if (lim->ptr_to_len) {\n") b.printf("*lim->ptr_to_len -= n;\n") diff --git a/doc/changelog.md b/doc/changelog.md index 5bfe7fef..e1aac1f8 100644 --- a/doc/changelog.md +++ b/doc/changelog.md @@ -12,6 +12,7 @@ - Spun `std/zlib` out of `std/flate`. - Let the `std/zlib` decoder ignore checksums. - Renamed `std/flate` to `std/deflate`. +- Renamed `buf1`, `reader1`, etc to `io_buffer`, `io_reader`, etc. - Supported animated (not just single frame) GIFs. - Marked the `std/gif` LZW decoder as private. - Marked some internal status codes as private. diff --git a/example/gifplayer/gifplayer.c b/example/gifplayer/gifplayer.c index 86c3fde5..228353b6 100644 --- a/example/gifplayer/gifplayer.c +++ b/example/gifplayer/gifplayer.c @@ -70,9 +70,9 @@ const char* play() { wuffs_gif__decoder dec; wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0); - wuffs_base__buf1 src = { + wuffs_base__io_buffer src = { .ptr = src_buffer, .len = src_len, .wi = src_len, .closed = true}; - wuffs_base__reader1 src_reader = {.buf = &src}; + wuffs_base__io_reader src_reader = {.buf = &src}; wuffs_base__image_config ic = {{0}}; wuffs_gif__status s = @@ -80,7 +80,7 @@ const char* play() { if (s) { return wuffs_gif__status__string(s); } - if (!wuffs_base__image_config__valid(&ic)) { + if (!wuffs_base__image_config__is_valid(&ic)) { return "invalid image configuration"; } uint32_t width = wuffs_base__image_config__width(&ic); @@ -111,8 +111,8 @@ const char* play() { } while (true) { - wuffs_base__buf1 dst = {.ptr = dst_buffer, .len = dst_len}; - wuffs_base__writer1 dst_writer = {.buf = &dst}; + wuffs_base__io_buffer dst = {.ptr = dst_buffer, .len = dst_len}; + wuffs_base__io_writer dst_writer = {.buf = &dst}; // TODO: provide API and support for when the frame rect is different from // the image rect. s = wuffs_gif__decoder__decode_frame(&dec, dst_writer, src_reader); diff --git a/example/library/library.c b/example/library/library.c index 059a720a..b18cc10c 100644 --- a/example/library/library.c +++ b/example/library/library.c @@ -48,11 +48,11 @@ static void ignore_return_value(int ignored) {} static const char* decode() { uint8_t dst_buffer[DST_BUFFER_SIZE]; - wuffs_base__buf1 dst = {.ptr = dst_buffer, .len = DST_BUFFER_SIZE}; - wuffs_base__buf1 src = { + wuffs_base__io_buffer dst = {.ptr = dst_buffer, .len = DST_BUFFER_SIZE}; + wuffs_base__io_buffer src = { .ptr = lgtm_ptr, .len = lgtm_len, .wi = lgtm_len, .closed = true}; - wuffs_base__writer1 dst_writer = {.buf = &dst}; - wuffs_base__reader1 src_reader = {.buf = &src}; + wuffs_base__io_writer dst_writer = {.buf = &dst}; + wuffs_base__io_reader src_reader = {.buf = &src}; wuffs_deflate__decoder dec; wuffs_deflate__decoder__initialize(&dec, WUFFS_VERSION, 0); diff --git a/example/zcat/zcat.c b/example/zcat/zcat.c index e91d92aa..115291bf 100644 --- a/example/zcat/zcat.c +++ b/example/zcat/zcat.c @@ -65,15 +65,15 @@ static const char* decode() { continue; } - wuffs_base__buf1 src = {.ptr = src_buffer, - .len = SRC_BUFFER_SIZE, - .wi = n_src, - .closed = n_src == 0}; - wuffs_base__reader1 src_reader = {.buf = &src}; + wuffs_base__io_buffer src = {.ptr = src_buffer, + .len = SRC_BUFFER_SIZE, + .wi = n_src, + .closed = n_src == 0}; + wuffs_base__io_reader src_reader = {.buf = &src}; while (true) { - wuffs_base__buf1 dst = {.ptr = dst_buffer, .len = DST_BUFFER_SIZE}; - wuffs_base__writer1 dst_writer = {.buf = &dst}; + wuffs_base__io_buffer dst = {.ptr = dst_buffer, .len = DST_BUFFER_SIZE}; + wuffs_base__io_writer dst_writer = {.buf = &dst}; wuffs_gzip__status s = wuffs_gzip__decoder__decode(&dec, dst_writer, src_reader); diff --git a/fuzz/c/fuzzlib/fuzzlib.cc b/fuzz/c/fuzzlib/fuzzlib.cc index 6b7aaa48..cff1c08f 100644 --- a/fuzz/c/fuzzlib/fuzzlib.cc +++ b/fuzz/c/fuzzlib/fuzzlib.cc @@ -26,7 +26,7 @@ void intentional_segfault() { *intentional_segfault_ptr = 0; } -void fuzz(wuffs_base__reader1 src_reader, uint32_t hash); +void fuzz(wuffs_base__io_reader src_reader, uint32_t hash); extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { // Hash input as per https://en.wikipedia.org/wiki/Jenkins_hash_function @@ -41,12 +41,12 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { hash ^= hash >> 11; hash += hash << 15; - wuffs_base__buf1 src = {.ptr = (uint8_t*)(data), - .len = size, - .wi = size, - .ri = 0, - .closed = true}; - fuzz((wuffs_base__reader1){.buf = &src}, hash); + wuffs_base__io_buffer src = {.ptr = (uint8_t*)(data), + .len = size, + .wi = size, + .ri = 0, + .closed = true}; + fuzz((wuffs_base__io_reader){.buf = &src}, hash); return 0; } diff --git a/fuzz/c/std/gif_fuzzer.cc b/fuzz/c/std/gif_fuzzer.cc index 06c98313..a2177da1 100644 --- a/fuzz/c/std/gif_fuzzer.cc +++ b/fuzz/c/std/gif_fuzzer.cc @@ -38,7 +38,7 @@ It should print "PASS", amongst other information, and exit(0). #include "../../../gen/c/std/gif.c" #include "../fuzzlib/fuzzlib.cc" -void fuzz(wuffs_base__reader1 src_reader, uint32_t hash) { +void fuzz(wuffs_base__io_reader src_reader, uint32_t hash) { void* pixbuf = NULL; // Use a {} code block so that "goto exit" doesn't trigger "jump bypasses @@ -64,8 +64,8 @@ void fuzz(wuffs_base__reader1 src_reader, uint32_t hash) { goto exit; } - wuffs_base__buf1 dst = {.ptr = (uint8_t*)(pixbuf), .len = pixbuf_size}; - wuffs_base__writer1 dst_writer = {.buf = &dst}; + wuffs_base__io_buffer dst = {.ptr = (uint8_t*)(pixbuf), .len = pixbuf_size}; + wuffs_base__io_writer dst_writer = {.buf = &dst}; while (true) { // TODO: handle the frame rect being larger than the image rect. The diff --git a/fuzz/c/std/zlib_fuzzer.cc b/fuzz/c/std/zlib_fuzzer.cc index c6841415..8fd556c8 100644 --- a/fuzz/c/std/zlib_fuzzer.cc +++ b/fuzz/c/std/zlib_fuzzer.cc @@ -39,7 +39,7 @@ It should print "PASS", amongst other information, and exit(0). #include "../../../gen/c/std/zlib.c" #include "../fuzzlib/fuzzlib.cc" -void fuzz(wuffs_base__reader1 src_reader, uint32_t hash) { +void fuzz(wuffs_base__io_reader src_reader, uint32_t hash) { wuffs_zlib__status s; wuffs_zlib__decoder dec; wuffs_zlib__decoder__initialize(&dec, WUFFS_VERSION, 0); @@ -51,8 +51,8 @@ void fuzz(wuffs_base__reader1 src_reader, uint32_t hash) { const size_t dstbuf_size = 65536; uint8_t dstbuf[dstbuf_size]; - wuffs_base__buf1 dst = {.ptr = dstbuf, .len = dstbuf_size}; - wuffs_base__writer1 dst_writer = {.buf = &dst}; + wuffs_base__io_buffer dst = {.ptr = dstbuf, .len = dstbuf_size}; + wuffs_base__io_writer dst_writer = {.buf = &dst}; while (true) { dst.wi = 0; diff --git a/gen/c/std/crc32.c b/gen/c/std/crc32.c index 8b432bdd..8f0ffa0e 100644 --- a/gen/c/std/crc32.c +++ b/gen/c/std/crc32.c @@ -99,9 +99,7 @@ typedef struct { // ---------------- I/O -// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc. - -// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus +// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length), plus // additional indexes into that buffer, plus an opened / closed flag. // // A value with all fields NULL or zero is a valid, empty buffer. @@ -111,44 +109,44 @@ typedef struct { size_t wi; // Write index. Invariant: wi <= len. size_t ri; // Read index. Invariant: ri <= wi. bool closed; // No further writes are expected. -} wuffs_base__buf1; +} wuffs_base__io_buffer; -// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream: +// wuffs_base__io_limit provides a limited view of a 1-dimensional byte stream: // its first N bytes. That N can be greater than a buffer's current read or // write capacity. N decreases naturally over time as bytes are read from or // written to the stream. // // A value with all fields NULL or zero is a valid, unlimited view. -typedef struct wuffs_base__limit1 { - uint64_t* ptr_to_len; // Pointer to N. - struct wuffs_base__limit1* next; // Linked list of limits. -} wuffs_base__limit1; +typedef struct wuffs_base__io_limit { + uint64_t* ptr_to_len; // Pointer to N. + struct wuffs_base__io_limit* next; // Linked list of limits. +} wuffs_base__io_limit; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__reader1; +} wuffs_base__io_reader; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__writer1; +} wuffs_base__io_writer; // ---------------- Images @@ -848,9 +846,9 @@ static inline uint64_t wuffs_base__slice_u8__copy_from_slice( return length; } -static inline uint32_t wuffs_base__writer1__copy_from_history32( +static inline uint32_t wuffs_base__io_writer__copy_from_history32( uint8_t** ptr_ptr, - uint8_t* start, // May be NULL, meaning an unmarked writer1. + uint8_t* start, // May be NULL, meaning an unmarked io_writer. uint8_t* end, uint32_t distance, uint32_t length) { @@ -874,7 +872,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32( // copy_from_history32 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__writer1__copy_from_history32__bco below. + // See also wuffs_base__io_writer__copy_from_history32__bco below. // // Alternatively, or additionally, have a sloppy_copy_from_history32 method // that copies 8 bytes at a time, possibly writing more than length bytes? @@ -890,14 +888,14 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32( return length; } -// wuffs_base__writer1__copy_from_history32__bco is a Bounds Check Optimized -// version of the wuffs_base__writer1__copy_from_history32 function above. The -// caller needs to prove that: +// wuffs_base__io_writer__copy_from_history32__bco is a Bounds Check Optimized +// version of the wuffs_base__io_writer__copy_from_history32 function above. +// The caller needs to prove that: // - start != NULL // - distance > 0 // - distance <= (*ptr_ptr - start) // - length <= (end - *ptr_ptr) -static inline uint32_t wuffs_base__writer1__copy_from_history32__bco( +static inline uint32_t wuffs_base__io_writer__copy_from_history32__bco( uint8_t** ptr_ptr, uint8_t* start, uint8_t* end, @@ -918,7 +916,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32__bco( return length; } -static inline uint32_t wuffs_base__writer1__copy_from_reader32( +static inline uint32_t wuffs_base__io_writer__copy_from_reader32( uint8_t** ptr_wptr, uint8_t* wend, uint8_t** ptr_rptr, @@ -941,7 +939,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_reader32( return n; } -static inline uint64_t wuffs_base__writer1__copy_from_slice( +static inline uint64_t wuffs_base__io_writer__copy_from_slice( uint8_t** ptr_wptr, uint8_t* wend, wuffs_base__slice_u8 src) { @@ -957,7 +955,7 @@ static inline uint64_t wuffs_base__writer1__copy_from_slice( return n; } -static inline uint32_t wuffs_base__writer1__copy_from_slice32( +static inline uint32_t wuffs_base__io_writer__copy_from_slice32( uint8_t** ptr_wptr, uint8_t* wend, wuffs_base__slice_u8 src, @@ -979,7 +977,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32( // Note that the *__limit and *__mark methods are private (in base-impl.h) not // public (in base-header.h). We assume that, at the boundary between user code -// and Wuffs code, the reader1 and writer1's private_impl fields (including +// and Wuffs code, the io_reader and io_writer's private_impl fields (including // limit and mark) are NULL. Otherwise, some internal assumptions break down. // For example, limits could be represented as pointers, even though // conceptually they are counts, but that pointer-to-count correspondence @@ -989,26 +987,26 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32( // code is still Wuffs code, not user code. Other Wuffs test code modifies // private_impl fields directly. -static inline wuffs_base__reader1 wuffs_base__reader1__limit( - wuffs_base__reader1* o, +static inline wuffs_base__io_reader wuffs_base__io_reader__limit( + wuffs_base__io_reader* o, uint64_t* ptr_to_len) { - wuffs_base__reader1 ret = *o; + wuffs_base__io_reader ret = *o; ret.private_impl.limit.ptr_to_len = ptr_to_len; ret.private_impl.limit.next = &o->private_impl.limit; return ret; } -static inline wuffs_base__empty_struct wuffs_base__reader1__mark( - wuffs_base__reader1* o, +static inline wuffs_base__empty_struct wuffs_base__io_reader__mark( + wuffs_base__io_reader* o, uint8_t* mark) { o->private_impl.mark = mark; return ((wuffs_base__empty_struct){}); } -// TODO: static inline wuffs_base__writer1 wuffs_base__writer1__limit() +// TODO: static inline wuffs_base__io_writer wuffs_base__io_writer__limit() -static inline wuffs_base__empty_struct wuffs_base__writer1__mark( - wuffs_base__writer1* o, +static inline wuffs_base__empty_struct wuffs_base__io_writer__mark( + wuffs_base__io_writer* o, uint8_t* mark) { o->private_impl.mark = mark; return ((wuffs_base__empty_struct){}); diff --git a/gen/c/std/deflate.c b/gen/c/std/deflate.c index 61af6a27..1427f4f5 100644 --- a/gen/c/std/deflate.c +++ b/gen/c/std/deflate.c @@ -99,9 +99,7 @@ typedef struct { // ---------------- I/O -// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc. - -// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus +// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length), plus // additional indexes into that buffer, plus an opened / closed flag. // // A value with all fields NULL or zero is a valid, empty buffer. @@ -111,44 +109,44 @@ typedef struct { size_t wi; // Write index. Invariant: wi <= len. size_t ri; // Read index. Invariant: ri <= wi. bool closed; // No further writes are expected. -} wuffs_base__buf1; +} wuffs_base__io_buffer; -// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream: +// wuffs_base__io_limit provides a limited view of a 1-dimensional byte stream: // its first N bytes. That N can be greater than a buffer's current read or // write capacity. N decreases naturally over time as bytes are read from or // written to the stream. // // A value with all fields NULL or zero is a valid, unlimited view. -typedef struct wuffs_base__limit1 { - uint64_t* ptr_to_len; // Pointer to N. - struct wuffs_base__limit1* next; // Linked list of limits. -} wuffs_base__limit1; +typedef struct wuffs_base__io_limit { + uint64_t* ptr_to_len; // Pointer to N. + struct wuffs_base__io_limit* next; // Linked list of limits. +} wuffs_base__io_limit; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__reader1; +} wuffs_base__io_reader; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__writer1; +} wuffs_base__io_writer; // ---------------- Images @@ -740,8 +738,8 @@ void wuffs_deflate__decoder__initialize(wuffs_deflate__decoder* self, wuffs_deflate__status wuffs_deflate__decoder__decode( wuffs_deflate__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src); + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src); #ifdef __cplusplus } // extern "C" @@ -940,9 +938,9 @@ static inline uint64_t wuffs_base__slice_u8__copy_from_slice( return length; } -static inline uint32_t wuffs_base__writer1__copy_from_history32( +static inline uint32_t wuffs_base__io_writer__copy_from_history32( uint8_t** ptr_ptr, - uint8_t* start, // May be NULL, meaning an unmarked writer1. + uint8_t* start, // May be NULL, meaning an unmarked io_writer. uint8_t* end, uint32_t distance, uint32_t length) { @@ -966,7 +964,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32( // copy_from_history32 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__writer1__copy_from_history32__bco below. + // See also wuffs_base__io_writer__copy_from_history32__bco below. // // Alternatively, or additionally, have a sloppy_copy_from_history32 method // that copies 8 bytes at a time, possibly writing more than length bytes? @@ -982,14 +980,14 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32( return length; } -// wuffs_base__writer1__copy_from_history32__bco is a Bounds Check Optimized -// version of the wuffs_base__writer1__copy_from_history32 function above. The -// caller needs to prove that: +// wuffs_base__io_writer__copy_from_history32__bco is a Bounds Check Optimized +// version of the wuffs_base__io_writer__copy_from_history32 function above. +// The caller needs to prove that: // - start != NULL // - distance > 0 // - distance <= (*ptr_ptr - start) // - length <= (end - *ptr_ptr) -static inline uint32_t wuffs_base__writer1__copy_from_history32__bco( +static inline uint32_t wuffs_base__io_writer__copy_from_history32__bco( uint8_t** ptr_ptr, uint8_t* start, uint8_t* end, @@ -1010,7 +1008,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32__bco( return length; } -static inline uint32_t wuffs_base__writer1__copy_from_reader32( +static inline uint32_t wuffs_base__io_writer__copy_from_reader32( uint8_t** ptr_wptr, uint8_t* wend, uint8_t** ptr_rptr, @@ -1033,7 +1031,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_reader32( return n; } -static inline uint64_t wuffs_base__writer1__copy_from_slice( +static inline uint64_t wuffs_base__io_writer__copy_from_slice( uint8_t** ptr_wptr, uint8_t* wend, wuffs_base__slice_u8 src) { @@ -1049,7 +1047,7 @@ static inline uint64_t wuffs_base__writer1__copy_from_slice( return n; } -static inline uint32_t wuffs_base__writer1__copy_from_slice32( +static inline uint32_t wuffs_base__io_writer__copy_from_slice32( uint8_t** ptr_wptr, uint8_t* wend, wuffs_base__slice_u8 src, @@ -1071,7 +1069,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32( // Note that the *__limit and *__mark methods are private (in base-impl.h) not // public (in base-header.h). We assume that, at the boundary between user code -// and Wuffs code, the reader1 and writer1's private_impl fields (including +// and Wuffs code, the io_reader and io_writer's private_impl fields (including // limit and mark) are NULL. Otherwise, some internal assumptions break down. // For example, limits could be represented as pointers, even though // conceptually they are counts, but that pointer-to-count correspondence @@ -1081,26 +1079,26 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32( // code is still Wuffs code, not user code. Other Wuffs test code modifies // private_impl fields directly. -static inline wuffs_base__reader1 wuffs_base__reader1__limit( - wuffs_base__reader1* o, +static inline wuffs_base__io_reader wuffs_base__io_reader__limit( + wuffs_base__io_reader* o, uint64_t* ptr_to_len) { - wuffs_base__reader1 ret = *o; + wuffs_base__io_reader ret = *o; ret.private_impl.limit.ptr_to_len = ptr_to_len; ret.private_impl.limit.next = &o->private_impl.limit; return ret; } -static inline wuffs_base__empty_struct wuffs_base__reader1__mark( - wuffs_base__reader1* o, +static inline wuffs_base__empty_struct wuffs_base__io_reader__mark( + wuffs_base__io_reader* o, uint8_t* mark) { o->private_impl.mark = mark; return ((wuffs_base__empty_struct){}); } -// TODO: static inline wuffs_base__writer1 wuffs_base__writer1__limit() +// TODO: static inline wuffs_base__io_writer wuffs_base__io_writer__limit() -static inline wuffs_base__empty_struct wuffs_base__writer1__mark( - wuffs_base__writer1* o, +static inline wuffs_base__empty_struct wuffs_base__io_writer__mark( + wuffs_base__io_writer* o, uint8_t* mark) { o->private_impl.mark = mark; return ((wuffs_base__empty_struct){}); @@ -1216,20 +1214,20 @@ static const uint32_t wuffs_deflate__dcode_magic_numbers[32] = { static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks( wuffs_deflate__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src); + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src); static wuffs_deflate__status wuffs_deflate__decoder__decode_uncompressed( wuffs_deflate__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src); + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src); static wuffs_deflate__status wuffs_deflate__decoder__init_fixed_huffman( wuffs_deflate__decoder* self); static wuffs_deflate__status wuffs_deflate__decoder__init_dynamic_huffman( wuffs_deflate__decoder* self, - wuffs_base__reader1 a_src); + wuffs_base__io_reader a_src); static wuffs_deflate__status wuffs_deflate__decoder__init_huff( wuffs_deflate__decoder* self, @@ -1240,13 +1238,13 @@ static wuffs_deflate__status wuffs_deflate__decoder__init_huff( static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_fast( wuffs_deflate__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src); + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src); static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_slow( wuffs_deflate__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src); + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src); // ---------------- Initializer Implementations @@ -1270,8 +1268,8 @@ void wuffs_deflate__decoder__initialize(wuffs_deflate__decoder* self, wuffs_deflate__status wuffs_deflate__decoder__decode( wuffs_deflate__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src) { + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src) { if (!self) { return WUFFS_DEFLATE__ERROR_BAD_RECEIVER; } @@ -1297,7 +1295,7 @@ wuffs_deflate__status wuffs_deflate__decoder__decode( b_wend_dst = b_wptr_dst; if (!a_dst.buf->closed) { uint64_t len = a_dst.buf->len - a_dst.buf->wi; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -1319,13 +1317,13 @@ wuffs_deflate__status wuffs_deflate__decoder__decode( WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; while (true) { - wuffs_base__writer1__mark(&a_dst, b_wptr_dst); + wuffs_base__io_writer__mark(&a_dst, b_wptr_dst); { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); if (a_dst.buf) { size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); a_dst.buf->wi += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1408,7 +1406,7 @@ exit: if (a_dst.buf) { size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); a_dst.buf->wi += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1424,8 +1422,8 @@ exit: static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks( wuffs_deflate__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src) { + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src) { wuffs_deflate__status status = WUFFS_DEFLATE__STATUS_OK; uint32_t v_final; @@ -1438,7 +1436,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks( b_rptr_src = a_src.buf->ptr + a_src.buf->ri; b_rstart_src = b_rptr_src; uint64_t len = a_src.buf->wi - a_src.buf->ri; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -1481,7 +1479,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks( if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1508,7 +1506,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks( if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1531,7 +1529,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks( if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1552,7 +1550,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks( if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1591,7 +1589,7 @@ exit: if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1614,8 +1612,8 @@ short_read_src: static wuffs_deflate__status wuffs_deflate__decoder__decode_uncompressed( wuffs_deflate__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src) { + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src) { wuffs_deflate__status status = WUFFS_DEFLATE__STATUS_OK; uint32_t v_length; @@ -1630,7 +1628,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_uncompressed( b_wend_dst = b_wptr_dst; if (!a_dst.buf->closed) { uint64_t len = a_dst.buf->len - a_dst.buf->wi; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -1646,7 +1644,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_uncompressed( b_rptr_src = a_src.buf->ptr + a_src.buf->ri; b_rstart_src = b_rptr_src; uint64_t len = a_src.buf->wi - a_src.buf->ri; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -1709,7 +1707,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_uncompressed( } v_length = ((v_length) & ((1 << (16)) - 1)); while (true) { - v_n_copied = wuffs_base__writer1__copy_from_reader32( + v_n_copied = wuffs_base__io_writer__copy_from_reader32( &b_wptr_dst, b_wend_dst, &b_rptr_src, b_rend_src, v_length); if (v_length <= v_n_copied) { v_length = 0; @@ -1743,7 +1741,7 @@ exit: if (a_dst.buf) { size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); a_dst.buf->wi += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1755,7 +1753,7 @@ exit: if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1841,7 +1839,7 @@ exit: static wuffs_deflate__status wuffs_deflate__decoder__init_dynamic_huffman( wuffs_deflate__decoder* self, - wuffs_base__reader1 a_src) { + wuffs_base__io_reader a_src) { wuffs_deflate__status status = WUFFS_DEFLATE__STATUS_OK; uint32_t v_bits; @@ -1864,7 +1862,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__init_dynamic_huffman( b_rptr_src = a_src.buf->ptr + a_src.buf->ri; b_rstart_src = b_rptr_src; uint64_t len = a_src.buf->wi - a_src.buf->ri; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -2085,7 +2083,7 @@ exit: if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -2389,8 +2387,8 @@ exit: static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_fast( wuffs_deflate__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src) { + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src) { wuffs_deflate__status status = WUFFS_DEFLATE__STATUS_OK; uint32_t v_bits; @@ -2416,7 +2414,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_fast( b_wend_dst = b_wptr_dst; if (!a_dst.buf->closed) { uint64_t len = a_dst.buf->len - a_dst.buf->wi; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -2432,7 +2430,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_fast( b_rptr_src = a_src.buf->ptr + a_src.buf->ri; b_rstart_src = b_rptr_src; uint64_t len = a_src.buf->wi - a_src.buf->ri; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -2679,7 +2677,7 @@ label_0_continue:; } v_hdist = (self->private_impl.f_history_index - v_hdist); while (true) { - v_n_copied = wuffs_base__writer1__copy_from_slice32( + v_n_copied = wuffs_base__io_writer__copy_from_slice32( &b_wptr_dst, b_wend_dst, wuffs_base__slice_u8__subslice_i( ((wuffs_base__slice_u8){.ptr = self->private_impl.f_history, @@ -2690,7 +2688,7 @@ label_0_continue:; goto label_1_break; } v_hlen -= v_n_copied; - wuffs_base__writer1__copy_from_slice32( + wuffs_base__io_writer__copy_from_slice32( &b_wptr_dst, b_wend_dst, ((wuffs_base__slice_u8){.ptr = self->private_impl.f_history, .len = 32768}), @@ -2714,7 +2712,7 @@ label_0_continue:; goto exit; } } - wuffs_base__writer1__copy_from_history32__bco( + wuffs_base__io_writer__copy_from_history32__bco( &b_wptr_dst, a_dst.private_impl.mark, b_wend_dst, v_dist_minus_1 + 1, v_length); goto label_2_break; @@ -2742,7 +2740,7 @@ exit: if (a_dst.buf) { size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); a_dst.buf->wi += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -2754,7 +2752,7 @@ exit: if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -2769,8 +2767,8 @@ exit: static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_slow( wuffs_deflate__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src) { + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src) { wuffs_deflate__status status = WUFFS_DEFLATE__STATUS_OK; uint32_t v_bits; @@ -2796,7 +2794,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_slow( b_wend_dst = b_wptr_dst; if (!a_dst.buf->closed) { uint64_t len = a_dst.buf->len - a_dst.buf->wi; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -2812,7 +2810,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_slow( b_rptr_src = a_src.buf->ptr + a_src.buf->ri; b_rstart_src = b_rptr_src; uint64_t len = a_src.buf->wi - a_src.buf->ri; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -3081,7 +3079,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_slow( } v_hdist = (self->private_impl.f_history_index - v_hdist); while (true) { - v_n_copied = wuffs_base__writer1__copy_from_slice32( + v_n_copied = wuffs_base__io_writer__copy_from_slice32( &b_wptr_dst, b_wend_dst, wuffs_base__slice_u8__subslice_i( ((wuffs_base__slice_u8){.ptr = self->private_impl.f_history, @@ -3105,7 +3103,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_slow( label_5_break:; if (v_hlen > 0) { while (true) { - v_n_copied = wuffs_base__writer1__copy_from_slice32( + v_n_copied = wuffs_base__io_writer__copy_from_slice32( &b_wptr_dst, b_wend_dst, wuffs_base__slice_u8__subslice_i( ((wuffs_base__slice_u8){ @@ -3127,7 +3125,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_slow( goto label_0_continue; } } - v_n_copied = wuffs_base__writer1__copy_from_history32( + v_n_copied = wuffs_base__io_writer__copy_from_history32( &b_wptr_dst, a_dst.private_impl.mark, b_wend_dst, v_dist_minus_1 + 1, v_length); if (v_length <= v_n_copied) { @@ -3178,7 +3176,7 @@ exit: if (a_dst.buf) { size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); a_dst.buf->wi += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -3190,7 +3188,7 @@ exit: if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; diff --git a/gen/c/std/gif.c b/gen/c/std/gif.c index d9320835..d50d9288 100644 --- a/gen/c/std/gif.c +++ b/gen/c/std/gif.c @@ -99,9 +99,7 @@ typedef struct { // ---------------- I/O -// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc. - -// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus +// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length), plus // additional indexes into that buffer, plus an opened / closed flag. // // A value with all fields NULL or zero is a valid, empty buffer. @@ -111,44 +109,44 @@ typedef struct { size_t wi; // Write index. Invariant: wi <= len. size_t ri; // Read index. Invariant: ri <= wi. bool closed; // No further writes are expected. -} wuffs_base__buf1; +} wuffs_base__io_buffer; -// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream: +// wuffs_base__io_limit provides a limited view of a 1-dimensional byte stream: // its first N bytes. That N can be greater than a buffer's current read or // write capacity. N decreases naturally over time as bytes are read from or // written to the stream. // // A value with all fields NULL or zero is a valid, unlimited view. -typedef struct wuffs_base__limit1 { - uint64_t* ptr_to_len; // Pointer to N. - struct wuffs_base__limit1* next; // Linked list of limits. -} wuffs_base__limit1; +typedef struct wuffs_base__io_limit { + uint64_t* ptr_to_len; // Pointer to N. + struct wuffs_base__io_limit* next; // Linked list of limits. +} wuffs_base__io_limit; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__reader1; +} wuffs_base__io_reader; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__writer1; +} wuffs_base__io_writer; // ---------------- Images @@ -755,11 +753,11 @@ void wuffs_gif__decoder__initialize(wuffs_gif__decoder* self, wuffs_gif__status wuffs_gif__decoder__decode_config( wuffs_gif__decoder* self, wuffs_base__image_config* a_dst, - wuffs_base__reader1 a_src); + wuffs_base__io_reader a_src); wuffs_gif__status wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src); + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src); #ifdef __cplusplus } // extern "C" @@ -958,9 +956,9 @@ static inline uint64_t wuffs_base__slice_u8__copy_from_slice( return length; } -static inline uint32_t wuffs_base__writer1__copy_from_history32( +static inline uint32_t wuffs_base__io_writer__copy_from_history32( uint8_t** ptr_ptr, - uint8_t* start, // May be NULL, meaning an unmarked writer1. + uint8_t* start, // May be NULL, meaning an unmarked io_writer. uint8_t* end, uint32_t distance, uint32_t length) { @@ -984,7 +982,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32( // copy_from_history32 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__writer1__copy_from_history32__bco below. + // See also wuffs_base__io_writer__copy_from_history32__bco below. // // Alternatively, or additionally, have a sloppy_copy_from_history32 method // that copies 8 bytes at a time, possibly writing more than length bytes? @@ -1000,14 +998,14 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32( return length; } -// wuffs_base__writer1__copy_from_history32__bco is a Bounds Check Optimized -// version of the wuffs_base__writer1__copy_from_history32 function above. The -// caller needs to prove that: +// wuffs_base__io_writer__copy_from_history32__bco is a Bounds Check Optimized +// version of the wuffs_base__io_writer__copy_from_history32 function above. +// The caller needs to prove that: // - start != NULL // - distance > 0 // - distance <= (*ptr_ptr - start) // - length <= (end - *ptr_ptr) -static inline uint32_t wuffs_base__writer1__copy_from_history32__bco( +static inline uint32_t wuffs_base__io_writer__copy_from_history32__bco( uint8_t** ptr_ptr, uint8_t* start, uint8_t* end, @@ -1028,7 +1026,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32__bco( return length; } -static inline uint32_t wuffs_base__writer1__copy_from_reader32( +static inline uint32_t wuffs_base__io_writer__copy_from_reader32( uint8_t** ptr_wptr, uint8_t* wend, uint8_t** ptr_rptr, @@ -1051,7 +1049,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_reader32( return n; } -static inline uint64_t wuffs_base__writer1__copy_from_slice( +static inline uint64_t wuffs_base__io_writer__copy_from_slice( uint8_t** ptr_wptr, uint8_t* wend, wuffs_base__slice_u8 src) { @@ -1067,7 +1065,7 @@ static inline uint64_t wuffs_base__writer1__copy_from_slice( return n; } -static inline uint32_t wuffs_base__writer1__copy_from_slice32( +static inline uint32_t wuffs_base__io_writer__copy_from_slice32( uint8_t** ptr_wptr, uint8_t* wend, wuffs_base__slice_u8 src, @@ -1089,7 +1087,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32( // Note that the *__limit and *__mark methods are private (in base-impl.h) not // public (in base-header.h). We assume that, at the boundary between user code -// and Wuffs code, the reader1 and writer1's private_impl fields (including +// and Wuffs code, the io_reader and io_writer's private_impl fields (including // limit and mark) are NULL. Otherwise, some internal assumptions break down. // For example, limits could be represented as pointers, even though // conceptually they are counts, but that pointer-to-count correspondence @@ -1099,26 +1097,26 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32( // code is still Wuffs code, not user code. Other Wuffs test code modifies // private_impl fields directly. -static inline wuffs_base__reader1 wuffs_base__reader1__limit( - wuffs_base__reader1* o, +static inline wuffs_base__io_reader wuffs_base__io_reader__limit( + wuffs_base__io_reader* o, uint64_t* ptr_to_len) { - wuffs_base__reader1 ret = *o; + wuffs_base__io_reader ret = *o; ret.private_impl.limit.ptr_to_len = ptr_to_len; ret.private_impl.limit.next = &o->private_impl.limit; return ret; } -static inline wuffs_base__empty_struct wuffs_base__reader1__mark( - wuffs_base__reader1* o, +static inline wuffs_base__empty_struct wuffs_base__io_reader__mark( + wuffs_base__io_reader* o, uint8_t* mark) { o->private_impl.mark = mark; return ((wuffs_base__empty_struct){}); } -// TODO: static inline wuffs_base__writer1 wuffs_base__writer1__limit() +// TODO: static inline wuffs_base__io_writer wuffs_base__io_writer__limit() -static inline wuffs_base__empty_struct wuffs_base__writer1__mark( - wuffs_base__writer1* o, +static inline wuffs_base__empty_struct wuffs_base__io_writer__mark( + wuffs_base__io_writer* o, uint8_t* mark) { o->private_impl.mark = mark; return ((wuffs_base__empty_struct){}); @@ -1195,28 +1193,28 @@ void wuffs_gif__lzw_decoder__initialize(wuffs_gif__lzw_decoder* self, static wuffs_gif__status wuffs_gif__decoder__decode_header( wuffs_gif__decoder* self, - wuffs_base__reader1 a_src); + wuffs_base__io_reader a_src); static wuffs_gif__status wuffs_gif__decoder__decode_lsd( wuffs_gif__decoder* self, - wuffs_base__reader1 a_src); + wuffs_base__io_reader a_src); static wuffs_gif__status wuffs_gif__decoder__decode_extension( wuffs_gif__decoder* self, - wuffs_base__reader1 a_src); + wuffs_base__io_reader a_src); static wuffs_gif__status wuffs_gif__decoder__skip_blocks( wuffs_gif__decoder* self, - wuffs_base__reader1 a_src); + wuffs_base__io_reader a_src); static wuffs_gif__status wuffs_gif__decoder__decode_ae( wuffs_gif__decoder* self, - wuffs_base__reader1 a_src); + wuffs_base__io_reader a_src); static wuffs_gif__status wuffs_gif__decoder__decode_id( wuffs_gif__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src); + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src); static void wuffs_gif__lzw_decoder__set_literal_width( wuffs_gif__lzw_decoder* self, @@ -1224,8 +1222,8 @@ static void wuffs_gif__lzw_decoder__set_literal_width( static wuffs_gif__status wuffs_gif__lzw_decoder__decode( wuffs_gif__lzw_decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src); + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src); // ---------------- Initializer Implementations @@ -1270,7 +1268,7 @@ void wuffs_gif__decoder__initialize(wuffs_gif__decoder* self, wuffs_gif__status wuffs_gif__decoder__decode_config( wuffs_gif__decoder* self, wuffs_base__image_config* a_dst, - wuffs_base__reader1 a_src) { + wuffs_base__io_reader a_src) { if (!self) { return WUFFS_GIF__ERROR_BAD_RECEIVER; } @@ -1293,7 +1291,7 @@ wuffs_gif__status wuffs_gif__decoder__decode_config( b_rptr_src = a_src.buf->ptr + a_src.buf->ri; b_rstart_src = b_rptr_src; uint64_t len = a_src.buf->wi - a_src.buf->ri; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -1318,7 +1316,7 @@ wuffs_gif__status wuffs_gif__decoder__decode_config( if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1336,7 +1334,7 @@ wuffs_gif__status wuffs_gif__decoder__decode_config( if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1368,7 +1366,7 @@ wuffs_gif__status wuffs_gif__decoder__decode_config( if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1404,7 +1402,7 @@ exit: if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1426,9 +1424,10 @@ short_read_src: goto suspend; } -wuffs_gif__status wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src) { +wuffs_gif__status wuffs_gif__decoder__decode_frame( + wuffs_gif__decoder* self, + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src) { if (!self) { return WUFFS_GIF__ERROR_BAD_RECEIVER; } @@ -1447,7 +1446,7 @@ wuffs_gif__status wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self, b_rptr_src = a_src.buf->ptr + a_src.buf->ri; b_rstart_src = b_rptr_src; uint64_t len = a_src.buf->wi - a_src.buf->ri; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -1486,7 +1485,7 @@ wuffs_gif__status wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self, if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1505,7 +1504,7 @@ wuffs_gif__status wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self, if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1549,7 +1548,7 @@ exit: if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1573,7 +1572,7 @@ short_read_src: static wuffs_gif__status wuffs_gif__decoder__decode_header( wuffs_gif__decoder* self, - wuffs_base__reader1 a_src) { + wuffs_base__io_reader a_src) { wuffs_gif__status status = WUFFS_GIF__STATUS_OK; uint8_t v_c[6]; @@ -1586,7 +1585,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_header( b_rptr_src = a_src.buf->ptr + a_src.buf->ri; b_rstart_src = b_rptr_src; uint64_t len = a_src.buf->wi - a_src.buf->ri; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -1641,7 +1640,7 @@ exit: if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1664,7 +1663,7 @@ short_read_src: static wuffs_gif__status wuffs_gif__decoder__decode_lsd( wuffs_gif__decoder* self, - wuffs_base__reader1 a_src) { + wuffs_base__io_reader a_src) { wuffs_gif__status status = WUFFS_GIF__STATUS_OK; uint8_t v_c[7]; @@ -1678,7 +1677,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_lsd( b_rptr_src = a_src.buf->ptr + a_src.buf->ri; b_rstart_src = b_rptr_src; uint64_t len = a_src.buf->wi - a_src.buf->ri; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -1766,7 +1765,7 @@ exit: if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1789,7 +1788,7 @@ short_read_src: static wuffs_gif__status wuffs_gif__decoder__decode_extension( wuffs_gif__decoder* self, - wuffs_base__reader1 a_src) { + wuffs_base__io_reader a_src) { wuffs_gif__status status = WUFFS_GIF__STATUS_OK; uint8_t v_label; @@ -1801,7 +1800,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_extension( b_rptr_src = a_src.buf->ptr + a_src.buf->ri; b_rstart_src = b_rptr_src; uint64_t len = a_src.buf->wi - a_src.buf->ri; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -1833,7 +1832,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_extension( if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1854,7 +1853,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_extension( if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1885,7 +1884,7 @@ exit: if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1908,7 +1907,7 @@ short_read_src: static wuffs_gif__status wuffs_gif__decoder__skip_blocks( wuffs_gif__decoder* self, - wuffs_base__reader1 a_src) { + wuffs_base__io_reader a_src) { wuffs_gif__status status = WUFFS_GIF__STATUS_OK; uint8_t v_block_size; @@ -1920,7 +1919,7 @@ static wuffs_gif__status wuffs_gif__decoder__skip_blocks( b_rptr_src = a_src.buf->ptr + a_src.buf->ri; b_rstart_src = b_rptr_src; uint64_t len = a_src.buf->wi - a_src.buf->ri; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -1979,7 +1978,7 @@ exit: if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -2002,7 +2001,7 @@ short_read_src: static wuffs_gif__status wuffs_gif__decoder__decode_ae( wuffs_gif__decoder* self, - wuffs_base__reader1 a_src) { + wuffs_base__io_reader a_src) { wuffs_gif__status status = WUFFS_GIF__STATUS_OK; uint8_t v_c; @@ -2017,7 +2016,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_ae( b_rptr_src = a_src.buf->ptr + a_src.buf->ri; b_rstart_src = b_rptr_src; uint64_t len = a_src.buf->wi - a_src.buf->ri; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -2170,7 +2169,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_ae( if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -2204,7 +2203,7 @@ exit: if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -2227,8 +2226,8 @@ short_read_src: static wuffs_gif__status wuffs_gif__decoder__decode_id( wuffs_gif__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src) { + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src) { wuffs_gif__status status = WUFFS_GIF__STATUS_OK; uint8_t v_flags; @@ -2236,7 +2235,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_id( uint32_t v_i; uint8_t v_lw; uint64_t v_block_size; - wuffs_base__reader1 v_r; + wuffs_base__io_reader v_r; wuffs_gif__status v_z; uint8_t* b_rptr_src = NULL; @@ -2246,7 +2245,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_id( b_rptr_src = a_src.buf->ptr + a_src.buf->ri; b_rstart_src = b_rptr_src; uint64_t len = a_src.buf->wi - a_src.buf->ri; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -2262,7 +2261,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_id( v_i = self->private_impl.c_decode_id[0].v_i; v_lw = self->private_impl.c_decode_id[0].v_lw; v_block_size = self->private_impl.c_decode_id[0].v_block_size; - v_r = ((wuffs_base__reader1){}); + v_r = ((wuffs_base__io_reader){}); v_z = self->private_impl.c_decode_id[0].v_z; } else { } @@ -2450,13 +2449,13 @@ static wuffs_gif__status wuffs_gif__decoder__decode_id( } while (true) { v_r = a_src; - wuffs_base__reader1__mark(&v_r, b_rptr_src); + wuffs_base__io_reader__mark(&v_r, b_rptr_src); { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15); if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -2466,7 +2465,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_id( uint64_t l_rlimit0 = v_block_size; wuffs_gif__status t_14 = wuffs_gif__lzw_decoder__decode( &self->private_impl.f_lzw, a_dst, - wuffs_base__reader1__limit(&v_r, &l_rlimit0)); + wuffs_base__io_reader__limit(&v_r, &l_rlimit0)); if (a_src.buf) { b_rptr_src = a_src.buf->ptr + a_src.buf->ri; } @@ -2526,7 +2525,7 @@ exit: if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -2555,8 +2554,8 @@ static void wuffs_gif__lzw_decoder__set_literal_width( static wuffs_gif__status wuffs_gif__lzw_decoder__decode( wuffs_gif__lzw_decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src) { + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src) { wuffs_gif__status status = WUFFS_GIF__STATUS_OK; uint32_t v_clear_code; @@ -2581,7 +2580,7 @@ static wuffs_gif__status wuffs_gif__lzw_decoder__decode( b_wend_dst = b_wptr_dst; if (!a_dst.buf->closed) { uint64_t len = a_dst.buf->len - a_dst.buf->wi; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -2597,7 +2596,7 @@ static wuffs_gif__status wuffs_gif__lzw_decoder__decode( b_rptr_src = a_src.buf->ptr + a_src.buf->ri; b_rstart_src = b_rptr_src; uint64_t len = a_src.buf->wi - a_src.buf->ri; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -2693,7 +2692,7 @@ static wuffs_gif__status wuffs_gif__lzw_decoder__decode( ((wuffs_base__slice_u8){.ptr = self->private_impl.f_stack, .len = 4096}), v_s); - v_n_copied = wuffs_base__writer1__copy_from_slice( + v_n_copied = wuffs_base__io_writer__copy_from_slice( &b_wptr_dst, b_wend_dst, v_expansion); if (v_n_copied == ((uint64_t)(v_expansion.len))) { goto label_1_break; @@ -2747,7 +2746,7 @@ exit: if (a_dst.buf) { size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); a_dst.buf->wi += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -2759,7 +2758,7 @@ exit: if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; diff --git a/gen/c/std/gzip.c b/gen/c/std/gzip.c index 0a814d42..c1795007 100644 --- a/gen/c/std/gzip.c +++ b/gen/c/std/gzip.c @@ -99,9 +99,7 @@ typedef struct { // ---------------- I/O -// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc. - -// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus +// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length), plus // additional indexes into that buffer, plus an opened / closed flag. // // A value with all fields NULL or zero is a valid, empty buffer. @@ -111,44 +109,44 @@ typedef struct { size_t wi; // Write index. Invariant: wi <= len. size_t ri; // Read index. Invariant: ri <= wi. bool closed; // No further writes are expected. -} wuffs_base__buf1; +} wuffs_base__io_buffer; -// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream: +// wuffs_base__io_limit provides a limited view of a 1-dimensional byte stream: // its first N bytes. That N can be greater than a buffer's current read or // write capacity. N decreases naturally over time as bytes are read from or // written to the stream. // // A value with all fields NULL or zero is a valid, unlimited view. -typedef struct wuffs_base__limit1 { - uint64_t* ptr_to_len; // Pointer to N. - struct wuffs_base__limit1* next; // Linked list of limits. -} wuffs_base__limit1; +typedef struct wuffs_base__io_limit { + uint64_t* ptr_to_len; // Pointer to N. + struct wuffs_base__io_limit* next; // Linked list of limits. +} wuffs_base__io_limit; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__reader1; +} wuffs_base__io_reader; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__writer1; +} wuffs_base__io_writer; // ---------------- Images @@ -839,8 +837,8 @@ void wuffs_deflate__decoder__initialize(wuffs_deflate__decoder* self, wuffs_deflate__status wuffs_deflate__decoder__decode( wuffs_deflate__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src); + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src); #ifdef __cplusplus } // extern "C" @@ -944,8 +942,8 @@ void wuffs_gzip__decoder__set_ignore_checksum(wuffs_gzip__decoder* self, bool a_ic); wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src); + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src); #ifdef __cplusplus } // extern "C" @@ -1144,9 +1142,9 @@ static inline uint64_t wuffs_base__slice_u8__copy_from_slice( return length; } -static inline uint32_t wuffs_base__writer1__copy_from_history32( +static inline uint32_t wuffs_base__io_writer__copy_from_history32( uint8_t** ptr_ptr, - uint8_t* start, // May be NULL, meaning an unmarked writer1. + uint8_t* start, // May be NULL, meaning an unmarked io_writer. uint8_t* end, uint32_t distance, uint32_t length) { @@ -1170,7 +1168,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32( // copy_from_history32 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__writer1__copy_from_history32__bco below. + // See also wuffs_base__io_writer__copy_from_history32__bco below. // // Alternatively, or additionally, have a sloppy_copy_from_history32 method // that copies 8 bytes at a time, possibly writing more than length bytes? @@ -1186,14 +1184,14 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32( return length; } -// wuffs_base__writer1__copy_from_history32__bco is a Bounds Check Optimized -// version of the wuffs_base__writer1__copy_from_history32 function above. The -// caller needs to prove that: +// wuffs_base__io_writer__copy_from_history32__bco is a Bounds Check Optimized +// version of the wuffs_base__io_writer__copy_from_history32 function above. +// The caller needs to prove that: // - start != NULL // - distance > 0 // - distance <= (*ptr_ptr - start) // - length <= (end - *ptr_ptr) -static inline uint32_t wuffs_base__writer1__copy_from_history32__bco( +static inline uint32_t wuffs_base__io_writer__copy_from_history32__bco( uint8_t** ptr_ptr, uint8_t* start, uint8_t* end, @@ -1214,7 +1212,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32__bco( return length; } -static inline uint32_t wuffs_base__writer1__copy_from_reader32( +static inline uint32_t wuffs_base__io_writer__copy_from_reader32( uint8_t** ptr_wptr, uint8_t* wend, uint8_t** ptr_rptr, @@ -1237,7 +1235,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_reader32( return n; } -static inline uint64_t wuffs_base__writer1__copy_from_slice( +static inline uint64_t wuffs_base__io_writer__copy_from_slice( uint8_t** ptr_wptr, uint8_t* wend, wuffs_base__slice_u8 src) { @@ -1253,7 +1251,7 @@ static inline uint64_t wuffs_base__writer1__copy_from_slice( return n; } -static inline uint32_t wuffs_base__writer1__copy_from_slice32( +static inline uint32_t wuffs_base__io_writer__copy_from_slice32( uint8_t** ptr_wptr, uint8_t* wend, wuffs_base__slice_u8 src, @@ -1275,7 +1273,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32( // Note that the *__limit and *__mark methods are private (in base-impl.h) not // public (in base-header.h). We assume that, at the boundary between user code -// and Wuffs code, the reader1 and writer1's private_impl fields (including +// and Wuffs code, the io_reader and io_writer's private_impl fields (including // limit and mark) are NULL. Otherwise, some internal assumptions break down. // For example, limits could be represented as pointers, even though // conceptually they are counts, but that pointer-to-count correspondence @@ -1285,26 +1283,26 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32( // code is still Wuffs code, not user code. Other Wuffs test code modifies // private_impl fields directly. -static inline wuffs_base__reader1 wuffs_base__reader1__limit( - wuffs_base__reader1* o, +static inline wuffs_base__io_reader wuffs_base__io_reader__limit( + wuffs_base__io_reader* o, uint64_t* ptr_to_len) { - wuffs_base__reader1 ret = *o; + wuffs_base__io_reader ret = *o; ret.private_impl.limit.ptr_to_len = ptr_to_len; ret.private_impl.limit.next = &o->private_impl.limit; return ret; } -static inline wuffs_base__empty_struct wuffs_base__reader1__mark( - wuffs_base__reader1* o, +static inline wuffs_base__empty_struct wuffs_base__io_reader__mark( + wuffs_base__io_reader* o, uint8_t* mark) { o->private_impl.mark = mark; return ((wuffs_base__empty_struct){}); } -// TODO: static inline wuffs_base__writer1 wuffs_base__writer1__limit() +// TODO: static inline wuffs_base__io_writer wuffs_base__io_writer__limit() -static inline wuffs_base__empty_struct wuffs_base__writer1__mark( - wuffs_base__writer1* o, +static inline wuffs_base__empty_struct wuffs_base__io_writer__mark( + wuffs_base__io_writer* o, uint8_t* mark) { o->private_impl.mark = mark; return ((wuffs_base__empty_struct){}); @@ -1408,8 +1406,8 @@ void wuffs_gzip__decoder__set_ignore_checksum(wuffs_gzip__decoder* self, } wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src) { + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src) { if (!self) { return WUFFS_GZIP__ERROR_BAD_RECEIVER; } @@ -1439,7 +1437,7 @@ wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, b_wend_dst = b_wptr_dst; if (!a_dst.buf->closed) { uint64_t len = a_dst.buf->len - a_dst.buf->wi; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -1455,7 +1453,7 @@ wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, b_rptr_src = a_src.buf->ptr + a_src.buf->ri; b_rstart_src = b_rptr_src; uint64_t len = a_src.buf->wi - a_src.buf->ri; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -1614,13 +1612,13 @@ wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, v_checksum_got = 0; v_decoded_length_got = 0; while (true) { - wuffs_base__writer1__mark(&a_dst, b_wptr_dst); + wuffs_base__io_writer__mark(&a_dst, b_wptr_dst); { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15); if (a_dst.buf) { size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); a_dst.buf->wi += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1630,7 +1628,7 @@ wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1762,7 +1760,7 @@ exit: if (a_dst.buf) { size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); a_dst.buf->wi += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1774,7 +1772,7 @@ exit: if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; diff --git a/gen/c/std/zlib.c b/gen/c/std/zlib.c index 183c1ba9..5bd60c45 100644 --- a/gen/c/std/zlib.c +++ b/gen/c/std/zlib.c @@ -99,9 +99,7 @@ typedef struct { // ---------------- I/O -// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc. - -// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus +// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length), plus // additional indexes into that buffer, plus an opened / closed flag. // // A value with all fields NULL or zero is a valid, empty buffer. @@ -111,44 +109,44 @@ typedef struct { size_t wi; // Write index. Invariant: wi <= len. size_t ri; // Read index. Invariant: ri <= wi. bool closed; // No further writes are expected. -} wuffs_base__buf1; +} wuffs_base__io_buffer; -// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream: +// wuffs_base__io_limit provides a limited view of a 1-dimensional byte stream: // its first N bytes. That N can be greater than a buffer's current read or // write capacity. N decreases naturally over time as bytes are read from or // written to the stream. // // A value with all fields NULL or zero is a valid, unlimited view. -typedef struct wuffs_base__limit1 { - uint64_t* ptr_to_len; // Pointer to N. - struct wuffs_base__limit1* next; // Linked list of limits. -} wuffs_base__limit1; +typedef struct wuffs_base__io_limit { + uint64_t* ptr_to_len; // Pointer to N. + struct wuffs_base__io_limit* next; // Linked list of limits. +} wuffs_base__io_limit; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__reader1; +} wuffs_base__io_reader; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__writer1; +} wuffs_base__io_writer; // ---------------- Images @@ -749,8 +747,8 @@ void wuffs_deflate__decoder__initialize(wuffs_deflate__decoder* self, wuffs_deflate__status wuffs_deflate__decoder__decode( wuffs_deflate__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src); + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src); #ifdef __cplusplus } // extern "C" @@ -870,8 +868,8 @@ void wuffs_zlib__decoder__set_ignore_checksum(wuffs_zlib__decoder* self, bool a_ic); wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src); + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src); #ifdef __cplusplus } // extern "C" @@ -1070,9 +1068,9 @@ static inline uint64_t wuffs_base__slice_u8__copy_from_slice( return length; } -static inline uint32_t wuffs_base__writer1__copy_from_history32( +static inline uint32_t wuffs_base__io_writer__copy_from_history32( uint8_t** ptr_ptr, - uint8_t* start, // May be NULL, meaning an unmarked writer1. + uint8_t* start, // May be NULL, meaning an unmarked io_writer. uint8_t* end, uint32_t distance, uint32_t length) { @@ -1096,7 +1094,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32( // copy_from_history32 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__writer1__copy_from_history32__bco below. + // See also wuffs_base__io_writer__copy_from_history32__bco below. // // Alternatively, or additionally, have a sloppy_copy_from_history32 method // that copies 8 bytes at a time, possibly writing more than length bytes? @@ -1112,14 +1110,14 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32( return length; } -// wuffs_base__writer1__copy_from_history32__bco is a Bounds Check Optimized -// version of the wuffs_base__writer1__copy_from_history32 function above. The -// caller needs to prove that: +// wuffs_base__io_writer__copy_from_history32__bco is a Bounds Check Optimized +// version of the wuffs_base__io_writer__copy_from_history32 function above. +// The caller needs to prove that: // - start != NULL // - distance > 0 // - distance <= (*ptr_ptr - start) // - length <= (end - *ptr_ptr) -static inline uint32_t wuffs_base__writer1__copy_from_history32__bco( +static inline uint32_t wuffs_base__io_writer__copy_from_history32__bco( uint8_t** ptr_ptr, uint8_t* start, uint8_t* end, @@ -1140,7 +1138,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32__bco( return length; } -static inline uint32_t wuffs_base__writer1__copy_from_reader32( +static inline uint32_t wuffs_base__io_writer__copy_from_reader32( uint8_t** ptr_wptr, uint8_t* wend, uint8_t** ptr_rptr, @@ -1163,7 +1161,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_reader32( return n; } -static inline uint64_t wuffs_base__writer1__copy_from_slice( +static inline uint64_t wuffs_base__io_writer__copy_from_slice( uint8_t** ptr_wptr, uint8_t* wend, wuffs_base__slice_u8 src) { @@ -1179,7 +1177,7 @@ static inline uint64_t wuffs_base__writer1__copy_from_slice( return n; } -static inline uint32_t wuffs_base__writer1__copy_from_slice32( +static inline uint32_t wuffs_base__io_writer__copy_from_slice32( uint8_t** ptr_wptr, uint8_t* wend, wuffs_base__slice_u8 src, @@ -1201,7 +1199,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32( // Note that the *__limit and *__mark methods are private (in base-impl.h) not // public (in base-header.h). We assume that, at the boundary between user code -// and Wuffs code, the reader1 and writer1's private_impl fields (including +// and Wuffs code, the io_reader and io_writer's private_impl fields (including // limit and mark) are NULL. Otherwise, some internal assumptions break down. // For example, limits could be represented as pointers, even though // conceptually they are counts, but that pointer-to-count correspondence @@ -1211,26 +1209,26 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32( // code is still Wuffs code, not user code. Other Wuffs test code modifies // private_impl fields directly. -static inline wuffs_base__reader1 wuffs_base__reader1__limit( - wuffs_base__reader1* o, +static inline wuffs_base__io_reader wuffs_base__io_reader__limit( + wuffs_base__io_reader* o, uint64_t* ptr_to_len) { - wuffs_base__reader1 ret = *o; + wuffs_base__io_reader ret = *o; ret.private_impl.limit.ptr_to_len = ptr_to_len; ret.private_impl.limit.next = &o->private_impl.limit; return ret; } -static inline wuffs_base__empty_struct wuffs_base__reader1__mark( - wuffs_base__reader1* o, +static inline wuffs_base__empty_struct wuffs_base__io_reader__mark( + wuffs_base__io_reader* o, uint8_t* mark) { o->private_impl.mark = mark; return ((wuffs_base__empty_struct){}); } -// TODO: static inline wuffs_base__writer1 wuffs_base__writer1__limit() +// TODO: static inline wuffs_base__io_writer wuffs_base__io_writer__limit() -static inline wuffs_base__empty_struct wuffs_base__writer1__mark( - wuffs_base__writer1* o, +static inline wuffs_base__empty_struct wuffs_base__io_writer__mark( + wuffs_base__io_writer* o, uint8_t* mark) { o->private_impl.mark = mark; return ((wuffs_base__empty_struct){}); @@ -1357,8 +1355,8 @@ void wuffs_zlib__decoder__set_ignore_checksum(wuffs_zlib__decoder* self, } wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src) { + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src) { if (!self) { return WUFFS_ZLIB__ERROR_BAD_RECEIVER; } @@ -1384,7 +1382,7 @@ wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, b_wend_dst = b_wptr_dst; if (!a_dst.buf->closed) { uint64_t len = a_dst.buf->len - a_dst.buf->wi; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -1400,7 +1398,7 @@ wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, b_rptr_src = a_src.buf->ptr + a_src.buf->ri; b_rstart_src = b_rptr_src; uint64_t len = a_src.buf->wi - a_src.buf->ri; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; @@ -1466,13 +1464,13 @@ wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, } v_checksum_got = 0; while (true) { - wuffs_base__writer1__mark(&a_dst, b_wptr_dst); + wuffs_base__io_writer__mark(&a_dst, b_wptr_dst); { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); if (a_dst.buf) { size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); a_dst.buf->wi += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1482,7 +1480,7 @@ wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1569,7 +1567,7 @@ exit: if (a_dst.buf) { size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); a_dst.buf->wi += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; @@ -1581,7 +1579,7 @@ exit: if (a_src.buf) { size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); a_src.buf->ri += n; - wuffs_base__limit1* lim; + wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { *lim->ptr_to_len -= n; diff --git a/gen/h/std/crc32.h b/gen/h/std/crc32.h index 6a4359ae..b081e0a3 100644 --- a/gen/h/std/crc32.h +++ b/gen/h/std/crc32.h @@ -99,9 +99,7 @@ typedef struct { // ---------------- I/O -// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc. - -// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus +// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length), plus // additional indexes into that buffer, plus an opened / closed flag. // // A value with all fields NULL or zero is a valid, empty buffer. @@ -111,44 +109,44 @@ typedef struct { size_t wi; // Write index. Invariant: wi <= len. size_t ri; // Read index. Invariant: ri <= wi. bool closed; // No further writes are expected. -} wuffs_base__buf1; +} wuffs_base__io_buffer; -// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream: +// wuffs_base__io_limit provides a limited view of a 1-dimensional byte stream: // its first N bytes. That N can be greater than a buffer's current read or // write capacity. N decreases naturally over time as bytes are read from or // written to the stream. // // A value with all fields NULL or zero is a valid, unlimited view. -typedef struct wuffs_base__limit1 { - uint64_t* ptr_to_len; // Pointer to N. - struct wuffs_base__limit1* next; // Linked list of limits. -} wuffs_base__limit1; +typedef struct wuffs_base__io_limit { + uint64_t* ptr_to_len; // Pointer to N. + struct wuffs_base__io_limit* next; // Linked list of limits. +} wuffs_base__io_limit; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__reader1; +} wuffs_base__io_reader; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__writer1; +} wuffs_base__io_writer; // ---------------- Images diff --git a/gen/h/std/deflate.h b/gen/h/std/deflate.h index a4e5fc98..283aa5d0 100644 --- a/gen/h/std/deflate.h +++ b/gen/h/std/deflate.h @@ -99,9 +99,7 @@ typedef struct { // ---------------- I/O -// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc. - -// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus +// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length), plus // additional indexes into that buffer, plus an opened / closed flag. // // A value with all fields NULL or zero is a valid, empty buffer. @@ -111,44 +109,44 @@ typedef struct { size_t wi; // Write index. Invariant: wi <= len. size_t ri; // Read index. Invariant: ri <= wi. bool closed; // No further writes are expected. -} wuffs_base__buf1; +} wuffs_base__io_buffer; -// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream: +// wuffs_base__io_limit provides a limited view of a 1-dimensional byte stream: // its first N bytes. That N can be greater than a buffer's current read or // write capacity. N decreases naturally over time as bytes are read from or // written to the stream. // // A value with all fields NULL or zero is a valid, unlimited view. -typedef struct wuffs_base__limit1 { - uint64_t* ptr_to_len; // Pointer to N. - struct wuffs_base__limit1* next; // Linked list of limits. -} wuffs_base__limit1; +typedef struct wuffs_base__io_limit { + uint64_t* ptr_to_len; // Pointer to N. + struct wuffs_base__io_limit* next; // Linked list of limits. +} wuffs_base__io_limit; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__reader1; +} wuffs_base__io_reader; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__writer1; +} wuffs_base__io_writer; // ---------------- Images @@ -740,8 +738,8 @@ void wuffs_deflate__decoder__initialize(wuffs_deflate__decoder* self, wuffs_deflate__status wuffs_deflate__decoder__decode( wuffs_deflate__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src); + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src); #ifdef __cplusplus } // extern "C" diff --git a/gen/h/std/gif.h b/gen/h/std/gif.h index 4a6d89af..0b50b702 100644 --- a/gen/h/std/gif.h +++ b/gen/h/std/gif.h @@ -99,9 +99,7 @@ typedef struct { // ---------------- I/O -// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc. - -// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus +// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length), plus // additional indexes into that buffer, plus an opened / closed flag. // // A value with all fields NULL or zero is a valid, empty buffer. @@ -111,44 +109,44 @@ typedef struct { size_t wi; // Write index. Invariant: wi <= len. size_t ri; // Read index. Invariant: ri <= wi. bool closed; // No further writes are expected. -} wuffs_base__buf1; +} wuffs_base__io_buffer; -// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream: +// wuffs_base__io_limit provides a limited view of a 1-dimensional byte stream: // its first N bytes. That N can be greater than a buffer's current read or // write capacity. N decreases naturally over time as bytes are read from or // written to the stream. // // A value with all fields NULL or zero is a valid, unlimited view. -typedef struct wuffs_base__limit1 { - uint64_t* ptr_to_len; // Pointer to N. - struct wuffs_base__limit1* next; // Linked list of limits. -} wuffs_base__limit1; +typedef struct wuffs_base__io_limit { + uint64_t* ptr_to_len; // Pointer to N. + struct wuffs_base__io_limit* next; // Linked list of limits. +} wuffs_base__io_limit; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__reader1; +} wuffs_base__io_reader; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__writer1; +} wuffs_base__io_writer; // ---------------- Images @@ -755,11 +753,11 @@ void wuffs_gif__decoder__initialize(wuffs_gif__decoder* self, wuffs_gif__status wuffs_gif__decoder__decode_config( wuffs_gif__decoder* self, wuffs_base__image_config* a_dst, - wuffs_base__reader1 a_src); + wuffs_base__io_reader a_src); wuffs_gif__status wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src); + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src); #ifdef __cplusplus } // extern "C" diff --git a/gen/h/std/gzip.h b/gen/h/std/gzip.h index 9efbabbd..4e3ff7fc 100644 --- a/gen/h/std/gzip.h +++ b/gen/h/std/gzip.h @@ -99,9 +99,7 @@ typedef struct { // ---------------- I/O -// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc. - -// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus +// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length), plus // additional indexes into that buffer, plus an opened / closed flag. // // A value with all fields NULL or zero is a valid, empty buffer. @@ -111,44 +109,44 @@ typedef struct { size_t wi; // Write index. Invariant: wi <= len. size_t ri; // Read index. Invariant: ri <= wi. bool closed; // No further writes are expected. -} wuffs_base__buf1; +} wuffs_base__io_buffer; -// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream: +// wuffs_base__io_limit provides a limited view of a 1-dimensional byte stream: // its first N bytes. That N can be greater than a buffer's current read or // write capacity. N decreases naturally over time as bytes are read from or // written to the stream. // // A value with all fields NULL or zero is a valid, unlimited view. -typedef struct wuffs_base__limit1 { - uint64_t* ptr_to_len; // Pointer to N. - struct wuffs_base__limit1* next; // Linked list of limits. -} wuffs_base__limit1; +typedef struct wuffs_base__io_limit { + uint64_t* ptr_to_len; // Pointer to N. + struct wuffs_base__io_limit* next; // Linked list of limits. +} wuffs_base__io_limit; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__reader1; +} wuffs_base__io_reader; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__writer1; +} wuffs_base__io_writer; // ---------------- Images @@ -839,8 +837,8 @@ void wuffs_deflate__decoder__initialize(wuffs_deflate__decoder* self, wuffs_deflate__status wuffs_deflate__decoder__decode( wuffs_deflate__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src); + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src); #ifdef __cplusplus } // extern "C" @@ -944,8 +942,8 @@ void wuffs_gzip__decoder__set_ignore_checksum(wuffs_gzip__decoder* self, bool a_ic); wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src); + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src); #ifdef __cplusplus } // extern "C" diff --git a/gen/h/std/zlib.h b/gen/h/std/zlib.h index 8ff097f4..0d827da3 100644 --- a/gen/h/std/zlib.h +++ b/gen/h/std/zlib.h @@ -99,9 +99,7 @@ typedef struct { // ---------------- I/O -// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc. - -// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus +// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length), plus // additional indexes into that buffer, plus an opened / closed flag. // // A value with all fields NULL or zero is a valid, empty buffer. @@ -111,44 +109,44 @@ typedef struct { size_t wi; // Write index. Invariant: wi <= len. size_t ri; // Read index. Invariant: ri <= wi. bool closed; // No further writes are expected. -} wuffs_base__buf1; +} wuffs_base__io_buffer; -// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream: +// wuffs_base__io_limit provides a limited view of a 1-dimensional byte stream: // its first N bytes. That N can be greater than a buffer's current read or // write capacity. N decreases naturally over time as bytes are read from or // written to the stream. // // A value with all fields NULL or zero is a valid, unlimited view. -typedef struct wuffs_base__limit1 { - uint64_t* ptr_to_len; // Pointer to N. - struct wuffs_base__limit1* next; // Linked list of limits. -} wuffs_base__limit1; +typedef struct wuffs_base__io_limit { + uint64_t* ptr_to_len; // Pointer to N. + struct wuffs_base__io_limit* next; // Linked list of limits. +} wuffs_base__io_limit; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__reader1; +} wuffs_base__io_reader; typedef struct { // TODO: move buf into private_impl? As it is, it looks like users can modify // the buf field to point to a different buffer, which can turn the limit and // mark fields into dangling pointers. - wuffs_base__buf1* buf; + wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { - wuffs_base__limit1 limit; + wuffs_base__io_limit limit; uint8_t* mark; } private_impl; -} wuffs_base__writer1; +} wuffs_base__io_writer; // ---------------- Images @@ -749,8 +747,8 @@ void wuffs_deflate__decoder__initialize(wuffs_deflate__decoder* self, wuffs_deflate__status wuffs_deflate__decoder__decode( wuffs_deflate__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src); + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src); #ifdef __cplusplus } // extern "C" @@ -870,8 +868,8 @@ void wuffs_zlib__decoder__set_ignore_checksum(wuffs_zlib__decoder* self, bool a_ic); wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, - wuffs_base__writer1 a_dst, - wuffs_base__reader1 a_src); + wuffs_base__io_writer a_dst, + wuffs_base__io_reader a_src); #ifdef __cplusplus } // extern "C" diff --git a/lang/ast/ast.go b/lang/ast/ast.go index 93e59053..7ab512b8 100644 --- a/lang/ast/ast.go +++ b/lang/ast/ast.go @@ -277,9 +277,9 @@ func (n *Raw) SetPackage(tm *t.Map, pkg t.ID) error { // TODO: Add signed integer types, as per the builtin.Types var? // // Or, don't hard code these, and instead require built-in types to - // have qualified names, such as "builtin.u8" or "base.reader1"? + // have qualified names, such as "builtin.u8" or "base.io_reader"? switch o.id2.Key() { - case t.KeyU8, t.KeyU16, t.KeyU32, t.KeyU64, t.KeyBool, t.KeyStatus, t.KeyReader1, t.KeyWriter1: + case t.KeyU8, t.KeyU16, t.KeyU32, t.KeyU64, t.KeyBool, t.KeyStatus, t.KeyIOReader, t.KeyIOWriter: return nil } } @@ -700,7 +700,7 @@ func (n *TypeExpr) IsSliceType() bool { func (n *TypeExpr) IsUnsignedInteger() bool { return n.id0 == 0 && (n.id2.Key() == t.KeyU8 || n.id2.Key() == t.KeyU16 || - n.id2.Key() == t.KeyU32 || n.id2.Key() == t.KeyU64) // TODO: t.KeyUsize? + n.id2.Key() == t.KeyU32 || n.id2.Key() == t.KeyU64) } func (n *TypeExpr) HasPointers() bool { @@ -708,7 +708,7 @@ func (n *TypeExpr) HasPointers() bool { switch n.id0.Key() { case 0: switch n.id2.Key() { - case t.KeyBuf1, t.KeyReader1, t.KeyWriter1, t.KeyBuf2: + case t.KeyIOReader, t.KeyIOWriter: return true } case t.KeyPtr, t.KeyNptr, t.KeyColon: diff --git a/lang/builtin/builtin.go b/lang/builtin/builtin.go index 5bf201a6..034e2d8e 100644 --- a/lang/builtin/builtin.go +++ b/lang/builtin/builtin.go @@ -71,8 +71,8 @@ var Types = []string{ "u64", "bool", "status", - "reader1", - "writer1", + "io_reader", + "io_writer", "image_config", } @@ -92,40 +92,40 @@ var Funcs = []string{ "status.is_ok()(ret bool)", "status.is_suspension()(ret bool)", - "reader1.read_u8?()(ret u8)", - "reader1.read_u16be?()(ret u16)", - "reader1.read_u16le?()(ret u16)", - "reader1.read_u32be?()(ret u32)", - "reader1.read_u32le?()(ret u32)", - "reader1.read_u64be?()(ret u64)", - "reader1.read_u64le?()(ret u64)", + "io_reader.read_u8?()(ret u8)", + "io_reader.read_u16be?()(ret u16)", + "io_reader.read_u16le?()(ret u16)", + "io_reader.read_u32be?()(ret u32)", + "io_reader.read_u32le?()(ret u32)", + "io_reader.read_u64be?()(ret u64)", + "io_reader.read_u64le?()(ret u64)", - "reader1.available()(ret u64)", - "reader1.is_marked()(ret bool)", - "reader1.limit(l u64)(ret reader1)", - "reader1.mark()()", - "reader1.since_mark()(ret[] u8)", - "reader1.skip32?(n u32)()", - "reader1.skip64?(n u64)()", - "reader1.unread_u8?()()", + "io_reader.available()(ret u64)", + "io_reader.is_marked()(ret bool)", + "io_reader.limit(l u64)(ret io_reader)", + "io_reader.mark()()", + "io_reader.since_mark()(ret[] u8)", + "io_reader.skip32?(n u32)()", + "io_reader.skip64?(n u64)()", + "io_reader.unread_u8?()()", - "writer1.write_u8?(x u8)()", - "writer1.write_u16be?(x u16)()", - "writer1.write_u16le?(x u16)()", - "writer1.write_u32be?(x u32)()", - "writer1.write_u32le?(x u32)()", - "writer1.write_u64be?(x u64)()", - "writer1.write_u64le?(x u64)()", + "io_writer.write_u8?(x u8)()", + "io_writer.write_u16be?(x u16)()", + "io_writer.write_u16le?(x u16)()", + "io_writer.write_u32be?(x u32)()", + "io_writer.write_u32le?(x u32)()", + "io_writer.write_u64be?(x u64)()", + "io_writer.write_u64le?(x u64)()", - "writer1.available()(ret u64)", - "writer1.copy_from_history32(distance u32, length u32)(ret u32)", - "writer1.copy_from_reader32(r reader1, length u32)(ret u32)", - "writer1.copy_from_slice(s[] u8)(ret u64)", - "writer1.copy_from_slice32(s[] u8, length u32)(ret u32)", - "writer1.is_marked()(ret bool)", - "writer1.limit(l u64)(ret writer1)", - "writer1.mark()()", - "writer1.since_mark()(ret[] u8)", + "io_writer.available()(ret u64)", + "io_writer.copy_from_history32(distance u32, length u32)(ret u32)", + "io_writer.copy_from_reader32(r io_reader, length u32)(ret u32)", + "io_writer.copy_from_slice(s[] u8)(ret u64)", + "io_writer.copy_from_slice32(s[] u8, length u32)(ret u32)", + "io_writer.is_marked()(ret bool)", + "io_writer.limit(l u64)(ret io_writer)", + "io_writer.mark()()", + "io_writer.since_mark()(ret[] u8)", "image_config.initialize!(pixfmt u32, pixsub u32, width u32, height u32, num_loops u32)()", } diff --git a/lang/check/bounds.go b/lang/check/bounds.go index cde3fbc1..f8af8612 100644 --- a/lang/check/bounds.go +++ b/lang/check/bounds.go @@ -23,16 +23,15 @@ import ( ) var numTypeBounds = [256][2]*big.Int{ - t.KeyI8: {big.NewInt(-1 << 7), big.NewInt(1<<7 - 1)}, - t.KeyI16: {big.NewInt(-1 << 15), big.NewInt(1<<15 - 1)}, - t.KeyI32: {big.NewInt(-1 << 31), big.NewInt(1<<31 - 1)}, - t.KeyI64: {big.NewInt(-1 << 63), big.NewInt(1<<63 - 1)}, - t.KeyU8: {zero, big.NewInt(0).SetUint64(1<<8 - 1)}, - t.KeyU16: {zero, big.NewInt(0).SetUint64(1<<16 - 1)}, - t.KeyU32: {zero, big.NewInt(0).SetUint64(1<<32 - 1)}, - t.KeyU64: {zero, big.NewInt(0).SetUint64(1<<64 - 1)}, - t.KeyUsize: {zero, zero}, - t.KeyBool: {zero, one}, + t.KeyI8: {big.NewInt(-1 << 7), big.NewInt(1<<7 - 1)}, + t.KeyI16: {big.NewInt(-1 << 15), big.NewInt(1<<15 - 1)}, + t.KeyI32: {big.NewInt(-1 << 31), big.NewInt(1<<31 - 1)}, + t.KeyI64: {big.NewInt(-1 << 63), big.NewInt(1<<63 - 1)}, + t.KeyU8: {zero, big.NewInt(0).SetUint64(1<<8 - 1)}, + t.KeyU16: {zero, big.NewInt(0).SetUint64(1<<16 - 1)}, + t.KeyU32: {zero, big.NewInt(0).SetUint64(1<<32 - 1)}, + t.KeyU64: {zero, big.NewInt(0).SetUint64(1<<64 - 1)}, + t.KeyBool: {zero, one}, } var ( @@ -1192,11 +1191,11 @@ func (q *checker) bcheckTypeExpr(typ *a.TypeExpr) (*big.Int, *big.Int, error) { return nil, nil, nil } - // TODO: is the special cases for reader1 and writer1 superfluous with the - // general purpose code for built-ins below? + // TODO: is the special cases for io_reader and io_writer superfluous with + // the general purpose code for built-ins below? if qid := typ.QID(); qid[0] == 0 { switch qid[1].Key() { - case t.KeyReader1, t.KeyWriter1: + case t.KeyIOReader, t.KeyIOWriter: return nil, nil, nil } } diff --git a/lang/check/optimize.go b/lang/check/optimize.go index 70a56aec..a0c3133b 100644 --- a/lang/check/optimize.go +++ b/lang/check/optimize.go @@ -60,7 +60,7 @@ func (q *checker) optimizeNonSuspendible(n *a.Expr) error { return nil } - // TODO: check that nReceiver's type is actually a reader1 or writer1. + // TODO: check that nReceiver's type is actually a io_reader or io_writer. switch nMethod { case t.KeyCopyFromHistory32: @@ -225,7 +225,7 @@ func (q *checker) optimizeSuspendible(n *a.Expr, depth uint32) error { return nil } - // TODO: check that nReceiver's type is actually a reader1 or writer1. + // TODO: check that nReceiver's type is actually a io_reader or io_writer. if nMethod == t.KeyUnreadU8 { // unread_u8 can never suspend, only succeed or fail. diff --git a/lang/check/resolve.go b/lang/check/resolve.go index 15055a24..b9d34c96 100644 --- a/lang/check/resolve.go +++ b/lang/check/resolve.go @@ -44,8 +44,8 @@ var ( typeExprU64 = a.NewTypeExpr(0, 0, t.IDU64, nil, nil, nil) typeExprBool = a.NewTypeExpr(0, 0, t.IDBool, nil, nil, nil) typeExprStatus = a.NewTypeExpr(0, 0, t.IDStatus, nil, nil, nil) - typeExprReader1 = a.NewTypeExpr(0, 0, t.IDReader1, nil, nil, nil) - typeExprWriter1 = a.NewTypeExpr(0, 0, t.IDWriter1, nil, nil, nil) + typeExprIOReader = a.NewTypeExpr(0, 0, t.IDIOReader, nil, nil, nil) + typeExprIOWriter = a.NewTypeExpr(0, 0, t.IDIOWriter, nil, nil, nil) typeExprImageConfig = a.NewTypeExpr(0, 0, t.IDImageConfig, nil, nil, nil) typeExprSliceU8 = a.NewTypeExpr(t.IDColon, 0, 0, nil, nil, typeExprU8) @@ -66,8 +66,8 @@ var builtInTypeMap = typeMap{ t.IDU64: typeExprU64, t.IDBool: typeExprBool, t.IDStatus: typeExprStatus, - t.IDReader1: typeExprReader1, - t.IDWriter1: typeExprWriter1, + t.IDIOReader: typeExprIOReader, + t.IDIOWriter: typeExprIOWriter, t.IDImageConfig: typeExprImageConfig, } diff --git a/lang/token/list.go b/lang/token/list.go index 1eecacef..c0f158b0 100644 --- a/lang/token/list.go +++ b/lang/token/list.go @@ -282,12 +282,9 @@ const ( KeyU16 = Key(IDU16 >> KeyShift) KeyU32 = Key(IDU32 >> KeyShift) KeyU64 = Key(IDU64 >> KeyShift) - KeyUsize = Key(IDUsize >> KeyShift) // TODO: unused? KeyBool = Key(IDBool >> KeyShift) - KeyBuf1 = Key(IDBuf1 >> KeyShift) // TODO: unused? - KeyReader1 = Key(IDReader1 >> KeyShift) - KeyWriter1 = Key(IDWriter1 >> KeyShift) - KeyBuf2 = Key(IDBuf2 >> KeyShift) // TODO: unused? + KeyIOReader = Key(IDIOReader >> KeyShift) + KeyIOWriter = Key(IDIOWriter >> KeyShift) KeyStatus = Key(IDStatus >> KeyShift) KeyImageConfig = Key(IDImageConfig >> KeyShift) @@ -474,14 +471,11 @@ const ( IDU16 = ID(0x85<= 1 { return error "invalid call sequence" } @@ -85,7 +85,7 @@ pub func decoder.decode_config?(dst ptr image_config, src reader1)() { this.call_sequence = 1 } -pub func decoder.decode_frame?(dst writer1, src reader1)() { +pub func decoder.decode_frame?(dst io_writer, src io_reader)() { if this.call_sequence < 1 { return error "invalid call sequence" } @@ -121,7 +121,7 @@ pub func decoder.decode_frame?(dst writer1, src reader1)() { // decode_header reads either "GIF87a" or "GIF89a". // // See the spec section 17 "Header" on page 7. -pri func decoder.decode_header?(src reader1)() { +pri func decoder.decode_header?(src io_reader)() { var c[6] u8 var i u32 while i < 6 { @@ -137,7 +137,7 @@ pri func decoder.decode_header?(src reader1)() { // decode_lsd reads the Logical Screen Descriptor. // // See the spec section 18 "Logical Screen Descriptor" on page 8. -pri func decoder.decode_lsd?(src reader1)() { +pri func decoder.decode_lsd?(src io_reader)() { var c[7] u8 var i u32 while i < 7 { @@ -172,7 +172,7 @@ pri func decoder.decode_lsd?(src reader1)() { // - section 24 "Comment Extension" on page 17. // - section 25 "Plain Text Extension" on page 18. // - section 26 "Application Extension" on page 21. -pri func decoder.decode_extension?(src reader1)() { +pri func decoder.decode_extension?(src io_reader)() { var label u8 = in.src.read_u8?() if label == 0xF9 { // The spec calls 0xF9 the "Graphic Control Label". // TODO. @@ -185,7 +185,7 @@ pri func decoder.decode_extension?(src reader1)() { this.skip_blocks?(src:in.src) } -pri func decoder.skip_blocks?(src reader1)() { +pri func decoder.skip_blocks?(src io_reader)() { while true { var block_size u8 = in.src.read_u8?() if block_size == 0 { @@ -206,7 +206,7 @@ pri const netscape2dot0[11] u8 = $( ) // decode_ae reads an Application Extension. -pri func decoder.decode_ae?(src reader1)() { +pri func decoder.decode_ae?(src io_reader)() { // This "while true" always executes exactly once, as it ends with a // "break", but using "break"s throughout simplifies the control flow. while true { @@ -275,7 +275,7 @@ pri func decoder.decode_ae?(src reader1)() { // been read. // // See the spec section 20 "Image Descriptor" on page 11. -pri func decoder.decode_id?(dst writer1, src reader1)() { +pri func decoder.decode_id?(dst io_writer, src io_reader)() { // TODO: check that the frame rect is inside the image rect?? this.frame_left = in.src.read_u16le?() as u32 this.frame_top = in.src.read_u16le?() as u32 @@ -312,9 +312,9 @@ pri func decoder.decode_id?(dst writer1, src reader1)() { break } while true { - var r reader1 = in.src + var r io_reader = in.src // TODO: should "mark" be "set_mark"? Unlike "limit", "mark" does - // not return a different reader1. + // not return a different io_reader. r.mark() // TODO: remove the dummy param. It's needed for now so that // writeSaveExprDerivedVars updates e.g. the b_rptr_src derived diff --git a/std/gif/decode_lzw.wuffs b/std/gif/decode_lzw.wuffs index 05a42b9b..7569d41d 100644 --- a/std/gif/decode_lzw.wuffs +++ b/std/gif/decode_lzw.wuffs @@ -28,7 +28,7 @@ pri func lzw_decoder.set_literal_width!(lw u32[2..8] = 8)() { this.literal_width = in.lw } -pri func lzw_decoder.decode?(dst writer1, src reader1)() { +pri func lzw_decoder.decode?(dst io_writer, src io_reader)() { // These variables don't change over the lifetime of this func. var clear_code u32[4..256] = (1 as u32) << this.literal_width var end_code u32[5..257] = clear_code + 1 diff --git a/std/gzip/decode_gzip.wuffs b/std/gzip/decode_gzip.wuffs index 5bc02d47..bb937248 100644 --- a/std/gzip/decode_gzip.wuffs +++ b/std/gzip/decode_gzip.wuffs @@ -32,7 +32,7 @@ pub func decoder.set_ignore_checksum!(ic bool)() { this.ignore_checksum = in.ic } -pub func decoder.decode?(dst writer1, src reader1)() { +pub func decoder.decode?(dst io_writer, src io_reader)() { // Read the header. if in.src.read_u8?() != 0x1F { return error "bad gzip header" diff --git a/std/zlib/decode_zlib.wuffs b/std/zlib/decode_zlib.wuffs index c2e234ae..f7e7c0fe 100644 --- a/std/zlib/decode_zlib.wuffs +++ b/std/zlib/decode_zlib.wuffs @@ -33,7 +33,7 @@ pub func decoder.set_ignore_checksum!(ic bool)() { this.ignore_checksum = in.ic } -pub func decoder.decode?(dst writer1, src reader1)() { +pub func decoder.decode?(dst io_writer, src io_reader)() { var x u16 = in.src.read_u16be?() if ((x >> 8) & 0x0F) != 0x08 { return error "invalid zlib compression method" diff --git a/test/c/mimiclib/deflate-gzip-zlib.c b/test/c/mimiclib/deflate-gzip-zlib.c index fbdf0cef..c84e24c2 100644 --- a/test/c/mimiclib/deflate-gzip-zlib.c +++ b/test/c/mimiclib/deflate-gzip-zlib.c @@ -18,22 +18,22 @@ #ifdef WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB #include "/path/to/your/copy/of/github.com/richgel999/miniz/miniz_tinfl.c" -const char* mimic_bench_adler32(wuffs_base__buf1* dst, - wuffs_base__buf1* src, +const char* mimic_bench_adler32(wuffs_base__io_buffer* dst, + wuffs_base__io_buffer* src, uint64_t wlimit, uint64_t rlimit) { return "miniz does not independently compute Adler32"; } -const char* mimic_bench_crc32_ieee(wuffs_base__buf1* dst, - wuffs_base__buf1* src, +const char* mimic_bench_crc32_ieee(wuffs_base__io_buffer* dst, + wuffs_base__io_buffer* src, uint64_t wlimit, uint64_t rlimit) { return "miniz does not implement CRC32/IEEE"; } -const char* mimic_deflate_zlib_decode(wuffs_base__buf1* dst, - wuffs_base__buf1* src, +const char* mimic_deflate_zlib_decode(wuffs_base__io_buffer* dst, + wuffs_base__io_buffer* src, uint64_t wlimit, uint64_t rlimit, bool deflate_instead_of_zlib) { @@ -53,22 +53,22 @@ const char* mimic_deflate_zlib_decode(wuffs_base__buf1* dst, return NULL; } -const char* mimic_deflate_decode(wuffs_base__buf1* dst, - wuffs_base__buf1* src, +const char* mimic_deflate_decode(wuffs_base__io_buffer* dst, + wuffs_base__io_buffer* src, uint64_t wlimit, uint64_t rlimit) { return mimic_deflate_zlib_decode(dst, src, wlimit, rlimit, true); } -const char* mimic_gzip_decode(wuffs_base__buf1* dst, - wuffs_base__buf1* src, +const char* mimic_gzip_decode(wuffs_base__io_buffer* dst, + wuffs_base__io_buffer* src, uint64_t wlimit, uint64_t rlimit) { return "miniz does not implement gzip"; } -const char* mimic_zlib_decode(wuffs_base__buf1* dst, - wuffs_base__buf1* src, +const char* mimic_zlib_decode(wuffs_base__io_buffer* dst, + wuffs_base__io_buffer* src, uint64_t wlimit, uint64_t rlimit) { return mimic_deflate_zlib_decode(dst, src, wlimit, rlimit, false); @@ -79,8 +79,8 @@ const char* mimic_zlib_decode(wuffs_base__buf1* dst, uint32_t global_mimiclib_deflate_unused_u32; -const char* mimic_bench_adler32(wuffs_base__buf1* dst, - wuffs_base__buf1* src, +const char* mimic_bench_adler32(wuffs_base__io_buffer* dst, + wuffs_base__io_buffer* src, uint64_t wlimit, uint64_t rlimit) { // TODO: don't ignore wlimit and rlimit. @@ -94,8 +94,8 @@ const char* mimic_bench_adler32(wuffs_base__buf1* dst, return NULL; } -const char* mimic_bench_crc32_ieee(wuffs_base__buf1* dst, - wuffs_base__buf1* src, +const char* mimic_bench_crc32_ieee(wuffs_base__io_buffer* dst, + wuffs_base__io_buffer* src, uint64_t wlimit, uint64_t rlimit) { // TODO: don't ignore wlimit and rlimit. @@ -115,8 +115,8 @@ typedef enum { zlib_flavor_zlib, } zlib_flavor; -const char* mimic_deflate_gzip_zlib_decode(wuffs_base__buf1* dst, - wuffs_base__buf1* src, +const char* mimic_deflate_gzip_zlib_decode(wuffs_base__io_buffer* dst, + wuffs_base__io_buffer* src, uint64_t wlimit, uint64_t rlimit, zlib_flavor flavor) { @@ -184,24 +184,24 @@ cleanup0:; return ret; } -const char* mimic_deflate_decode(wuffs_base__buf1* dst, - wuffs_base__buf1* src, +const char* mimic_deflate_decode(wuffs_base__io_buffer* dst, + wuffs_base__io_buffer* src, uint64_t wlimit, uint64_t rlimit) { return mimic_deflate_gzip_zlib_decode(dst, src, wlimit, rlimit, zlib_flavor_raw); } -const char* mimic_gzip_decode(wuffs_base__buf1* dst, - wuffs_base__buf1* src, +const char* mimic_gzip_decode(wuffs_base__io_buffer* dst, + wuffs_base__io_buffer* src, uint64_t wlimit, uint64_t rlimit) { return mimic_deflate_gzip_zlib_decode(dst, src, wlimit, rlimit, zlib_flavor_gzip); } -const char* mimic_zlib_decode(wuffs_base__buf1* dst, - wuffs_base__buf1* src, +const char* mimic_zlib_decode(wuffs_base__io_buffer* dst, + wuffs_base__io_buffer* src, uint64_t wlimit, uint64_t rlimit) { return mimic_deflate_gzip_zlib_decode(dst, src, wlimit, rlimit, diff --git a/test/c/mimiclib/gif.c b/test/c/mimiclib/gif.c index 9da6e170..ed3b7f52 100644 --- a/test/c/mimiclib/gif.c +++ b/test/c/mimiclib/gif.c @@ -15,7 +15,7 @@ #include "gif_lib.h" int mimic_gif_read_func(GifFileType* f, GifByteType* ptr, int len) { - wuffs_base__buf1* src = (wuffs_base__buf1*)(f->UserData); + wuffs_base__io_buffer* src = (wuffs_base__io_buffer*)(f->UserData); if (len < 0) { return 0; } @@ -29,7 +29,8 @@ int mimic_gif_read_func(GifFileType* f, GifByteType* ptr, int len) { return n; } -const char* mimic_gif_decode(wuffs_base__buf1* dst, wuffs_base__buf1* src) { +const char* mimic_gif_decode(wuffs_base__io_buffer* dst, + wuffs_base__io_buffer* src) { const char* ret = NULL; // http://giflib.sourceforge.net/gif_lib.html#compatibility says that "A few diff --git a/test/c/std/crc32.c b/test/c/std/crc32.c index 86f9ac29..c33ab688 100644 --- a/test/c/std/crc32.c +++ b/test/c/std/crc32.c @@ -98,7 +98,7 @@ void test_wuffs_crc32_ieee_golden() { int i; for (i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); i++) { - wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; if (!read_file(&src, test_cases[i].filename)) { return; } @@ -165,8 +165,8 @@ void test_wuffs_crc32_ieee_pi() { uint32_t global_wuffs_crc32_unused_u32; -const char* wuffs_bench_crc32_ieee(wuffs_base__buf1* dst, - wuffs_base__buf1* src, +const char* wuffs_bench_crc32_ieee(wuffs_base__io_buffer* dst, + wuffs_base__io_buffer* src, uint64_t wlimit, uint64_t rlimit) { // TODO: don't ignore wlimit and rlimit. @@ -183,13 +183,14 @@ const char* wuffs_bench_crc32_ieee(wuffs_base__buf1* dst, void bench_wuffs_crc32_ieee_10k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(wuffs_bench_crc32_ieee, tc_src, &crc32_midsummer_gt, 0, 0, - 150000); + do_bench_io_buffers(wuffs_bench_crc32_ieee, tc_src, &crc32_midsummer_gt, 0, 0, + 150000); } void bench_wuffs_crc32_ieee_100k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(wuffs_bench_crc32_ieee, tc_src, &crc32_pi_gt, 0, 0, 15000); + do_bench_io_buffers(wuffs_bench_crc32_ieee, tc_src, &crc32_pi_gt, 0, 0, + 15000); } // ---------------- Mimic Benches @@ -198,13 +199,14 @@ void bench_wuffs_crc32_ieee_100k() { void bench_mimic_crc32_ieee_10k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(mimic_bench_crc32_ieee, tc_src, &crc32_midsummer_gt, 0, 0, - 150000); + do_bench_io_buffers(mimic_bench_crc32_ieee, tc_src, &crc32_midsummer_gt, 0, 0, + 150000); } void bench_mimic_crc32_ieee_100k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(mimic_bench_crc32_ieee, tc_src, &crc32_pi_gt, 0, 0, 15000); + do_bench_io_buffers(mimic_bench_crc32_ieee, tc_src, &crc32_pi_gt, 0, 0, + 15000); } #endif // WUFFS_MIMIC diff --git a/test/c/std/deflate.c b/test/c/std/deflate.c index f4963abd..2197b694 100644 --- a/test/c/std/deflate.c +++ b/test/c/std/deflate.c @@ -107,8 +107,8 @@ golden_test deflate_romeo_fixed_gt = { // ---------------- Deflate Tests -const char* wuffs_deflate_decode(wuffs_base__buf1* dst, - wuffs_base__buf1* src, +const char* wuffs_deflate_decode(wuffs_base__io_buffer* dst, + wuffs_base__io_buffer* src, uint64_t wlimit, uint64_t rlimit) { wuffs_deflate__decoder dec; @@ -116,12 +116,12 @@ const char* wuffs_deflate_decode(wuffs_base__buf1* dst, uint64_t wlim = 0; uint64_t rlim = 0; while (true) { - wuffs_base__writer1 dst_writer = {.buf = dst}; + wuffs_base__io_writer dst_writer = {.buf = dst}; if (wlimit) { wlim = wlimit; dst_writer.private_impl.limit.ptr_to_len = &wlim; } - wuffs_base__reader1 src_reader = {.buf = src}; + wuffs_base__io_reader src_reader = {.buf = src}; if (rlimit) { rlim = rlimit; src_reader.private_impl.limit.ptr_to_len = &rlim; @@ -143,62 +143,62 @@ const char* wuffs_deflate_decode(wuffs_base__buf1* dst, void test_wuffs_deflate_decode_256_bytes() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_deflate_decode, &deflate_256_bytes_gt, 0, 0); + do_test_io_buffers(wuffs_deflate_decode, &deflate_256_bytes_gt, 0, 0); } void test_wuffs_deflate_decode_deflate_backref_crosses_blocks() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_deflate_decode, - &deflate_deflate_backref_crosses_blocks_gt, 0, 0); + do_test_io_buffers(wuffs_deflate_decode, + &deflate_deflate_backref_crosses_blocks_gt, 0, 0); } void test_wuffs_deflate_decode_deflate_distance_32768() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_deflate_decode, &deflate_deflate_distance_32768_gt, 0, - 0); + do_test_io_buffers(wuffs_deflate_decode, &deflate_deflate_distance_32768_gt, + 0, 0); } void test_wuffs_deflate_decode_midsummer() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_deflate_decode, &deflate_midsummer_gt, 0, 0); + do_test_io_buffers(wuffs_deflate_decode, &deflate_midsummer_gt, 0, 0); } void test_wuffs_deflate_decode_pi() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_deflate_decode, &deflate_pi_gt, 0, 0); + do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 0, 0); } void test_wuffs_deflate_decode_pi_many_big_reads() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_deflate_decode, &deflate_pi_gt, 0, 4096); + do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 0, 4096); } void test_wuffs_deflate_decode_pi_many_medium_reads() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_deflate_decode, &deflate_pi_gt, 0, 599); + do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 0, 599); } void test_wuffs_deflate_decode_pi_many_small_writes_reads() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_deflate_decode, &deflate_pi_gt, 59, 61); + do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 59, 61); } void test_wuffs_deflate_decode_romeo() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_deflate_decode, &deflate_romeo_gt, 0, 0); + do_test_io_buffers(wuffs_deflate_decode, &deflate_romeo_gt, 0, 0); } void test_wuffs_deflate_decode_romeo_fixed() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_deflate_decode, &deflate_romeo_fixed_gt, 0, 0); + do_test_io_buffers(wuffs_deflate_decode, &deflate_romeo_fixed_gt, 0, 0); } void test_wuffs_deflate_decode_split_src() { CHECK_FOCUS(__func__); - wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; - wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; - wuffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer want = {.ptr = global_want_buffer, .len = BUFFER_SIZE}; golden_test* gt = &deflate_256_bytes_gt; if (!read_file(&src, gt->src_filename)) { @@ -209,8 +209,8 @@ void test_wuffs_deflate_decode_split_src() { } wuffs_deflate__decoder dec; - wuffs_base__writer1 dst_writer = {.buf = &got}; - wuffs_base__reader1 src_reader = {.buf = &src}; + wuffs_base__io_writer dst_writer = {.buf = &got}; + wuffs_base__io_reader src_reader = {.buf = &src}; int i; for (i = 1; i < 32; i++) { @@ -252,7 +252,7 @@ void test_wuffs_deflate_decode_split_src() { char prefix[64]; snprintf(prefix, 64, "i=%d: ", i); - if (!buf1s_equal(prefix, &got, &want)) { + if (!io_buffers_equal(prefix, &got, &want)) { return; } } @@ -260,8 +260,8 @@ void test_wuffs_deflate_decode_split_src() { bool do_test_wuffs_deflate_history(int i, golden_test* gt, - wuffs_base__buf1* src, - wuffs_base__buf1* got, + wuffs_base__io_buffer* src, + wuffs_base__io_buffer* got, wuffs_deflate__decoder* dec, uint32_t starting_history_index, uint64_t limit, @@ -272,8 +272,8 @@ bool do_test_wuffs_deflate_history(int i, got->wi = 0; wuffs_deflate__decoder__initialize(dec, WUFFS_VERSION, 0); - wuffs_base__writer1 dst_writer = {.buf = got}; - wuffs_base__reader1 src_reader = {.buf = src}; + wuffs_base__io_writer dst_writer = {.buf = got}; + wuffs_base__io_reader src_reader = {.buf = src}; dec->private_impl.f_history_index = starting_history_index; @@ -294,9 +294,9 @@ bool do_test_wuffs_deflate_history(int i, void test_wuffs_deflate_history_full() { CHECK_FOCUS(__func__); - wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; - wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; - wuffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer want = {.ptr = global_want_buffer, .len = BUFFER_SIZE}; golden_test* gt = &deflate_pi_gt; if (!read_file(&src, gt->src_filename)) { @@ -327,7 +327,7 @@ void test_wuffs_deflate_history_full() { continue; } - wuffs_base__buf1 history_got = { + wuffs_base__io_buffer history_got = { .ptr = dec.private_impl.f_history, .len = full_history_size, .wi = full_history_size, @@ -336,12 +336,12 @@ void test_wuffs_deflate_history_full() { FAIL("i=%d: want file is too short", i); return; } - wuffs_base__buf1 history_want = { + wuffs_base__io_buffer history_want = { .ptr = global_want_buffer + want.wi - (full_history_size - i), .len = full_history_size, .wi = full_history_size, }; - if (!buf1s_equal("", &history_got, &history_want)) { + if (!io_buffers_equal("", &history_got, &history_want)) { return; } } @@ -350,8 +350,8 @@ void test_wuffs_deflate_history_full() { void test_wuffs_deflate_history_partial() { CHECK_FOCUS(__func__); - wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; - wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; golden_test* gt = &deflate_pi_gt; if (!read_file(&src, gt->src_filename)) { @@ -544,39 +544,39 @@ void test_wuffs_deflate_table_redirect() { void test_mimic_deflate_decode_256_bytes() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(mimic_deflate_decode, &deflate_256_bytes_gt, 0, 0); + do_test_io_buffers(mimic_deflate_decode, &deflate_256_bytes_gt, 0, 0); } void test_mimic_deflate_decode_deflate_backref_crosses_blocks() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(mimic_deflate_decode, - &deflate_deflate_backref_crosses_blocks_gt, 0, 0); + do_test_io_buffers(mimic_deflate_decode, + &deflate_deflate_backref_crosses_blocks_gt, 0, 0); } void test_mimic_deflate_decode_deflate_distance_32768() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(mimic_deflate_decode, &deflate_deflate_distance_32768_gt, 0, - 0); + do_test_io_buffers(mimic_deflate_decode, &deflate_deflate_distance_32768_gt, + 0, 0); } void test_mimic_deflate_decode_midsummer() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(mimic_deflate_decode, &deflate_midsummer_gt, 0, 0); + do_test_io_buffers(mimic_deflate_decode, &deflate_midsummer_gt, 0, 0); } void test_mimic_deflate_decode_pi() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(mimic_deflate_decode, &deflate_pi_gt, 0, 0); + do_test_io_buffers(mimic_deflate_decode, &deflate_pi_gt, 0, 0); } void test_mimic_deflate_decode_romeo() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(mimic_deflate_decode, &deflate_romeo_gt, 0, 0); + do_test_io_buffers(mimic_deflate_decode, &deflate_romeo_gt, 0, 0); } void test_mimic_deflate_decode_romeo_fixed() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(mimic_deflate_decode, &deflate_romeo_fixed_gt, 0, 0); + do_test_io_buffers(mimic_deflate_decode, &deflate_romeo_fixed_gt, 0, 0); } #endif // WUFFS_MIMIC @@ -585,19 +585,19 @@ void test_mimic_deflate_decode_romeo_fixed() { void bench_wuffs_deflate_decode_1k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(wuffs_deflate_decode, tc_dst, &deflate_romeo_gt, 0, 0, - 200000); + do_bench_io_buffers(wuffs_deflate_decode, tc_dst, &deflate_romeo_gt, 0, 0, + 200000); } void bench_wuffs_deflate_decode_10k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(wuffs_deflate_decode, tc_dst, &deflate_midsummer_gt, 0, 0, - 30000); + do_bench_io_buffers(wuffs_deflate_decode, tc_dst, &deflate_midsummer_gt, 0, 0, + 30000); } void bench_wuffs_deflate_decode_100k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(wuffs_deflate_decode, tc_dst, &deflate_pi_gt, 0, 0, 3000); + do_bench_io_buffers(wuffs_deflate_decode, tc_dst, &deflate_pi_gt, 0, 0, 3000); } // ---------------- Mimic Benches @@ -606,19 +606,19 @@ void bench_wuffs_deflate_decode_100k() { void bench_mimic_deflate_decode_1k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(mimic_deflate_decode, tc_dst, &deflate_romeo_gt, 0, 0, - 200000); + do_bench_io_buffers(mimic_deflate_decode, tc_dst, &deflate_romeo_gt, 0, 0, + 200000); } void bench_mimic_deflate_decode_10k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(mimic_deflate_decode, tc_dst, &deflate_midsummer_gt, 0, 0, - 30000); + do_bench_io_buffers(mimic_deflate_decode, tc_dst, &deflate_midsummer_gt, 0, 0, + 30000); } void bench_mimic_deflate_decode_100k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(mimic_deflate_decode, tc_dst, &deflate_pi_gt, 0, 0, 3000); + do_bench_io_buffers(mimic_deflate_decode, tc_dst, &deflate_pi_gt, 0, 0, 3000); } #endif // WUFFS_MIMIC diff --git a/test/c/std/gif.c b/test/c/std/gif.c index f9a5ae71..5185096c 100644 --- a/test/c/std/gif.c +++ b/test/c/std/gif.c @@ -51,7 +51,7 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the void test_basic_bad_receiver() { CHECK_FOCUS(__func__); wuffs_base__image_config ic = {{0}}; - wuffs_base__reader1 src = {0}; + wuffs_base__io_reader src = {0}; wuffs_gif__status status = wuffs_gif__decoder__decode_config(NULL, &ic, src); if (status != WUFFS_GIF__ERROR_BAD_RECEIVER) { FAIL("decode_config: got %d, want %d", status, @@ -63,7 +63,7 @@ void test_basic_initializer_not_called() { CHECK_FOCUS(__func__); wuffs_gif__decoder dec = {{0}}; wuffs_base__image_config ic = {{0}}; - wuffs_base__reader1 src = {0}; + wuffs_base__io_reader src = {0}; wuffs_gif__status status = wuffs_gif__decoder__decode_config(&dec, &ic, src); if (status != WUFFS_GIF__ERROR_INITIALIZER_NOT_CALLED) { FAIL("decode_config: got %d, want %d", status, @@ -177,9 +177,9 @@ bool do_test_wuffs_lzw_decode(const char* src_filename, uint64_t want_size, uint64_t wlimit, uint64_t rlimit) { - wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; - wuffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE}; - wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer want = {.ptr = global_want_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; if (!read_file(&src, src_filename)) { return false; @@ -212,12 +212,12 @@ bool do_test_wuffs_lzw_decode(const char* src_filename, uint64_t rlim = 0; while (true) { num_iters++; - wuffs_base__writer1 got_writer = {.buf = &got}; + wuffs_base__io_writer got_writer = {.buf = &got}; if (wlimit) { wlim = wlimit; got_writer.private_impl.limit.ptr_to_len = &wlim; } - wuffs_base__reader1 src_reader = {.buf = &src}; + wuffs_base__io_reader src_reader = {.buf = &src}; if (rlimit) { rlim = rlimit; src_reader.private_impl.limit.ptr_to_len = &rlim; @@ -272,7 +272,7 @@ bool do_test_wuffs_lzw_decode(const char* src_filename, } } - return buf1s_equal("", &got, &want); + return io_buffers_equal("", &got, &want); } void test_wuffs_lzw_decode_many_big_reads() { @@ -308,10 +308,10 @@ void test_wuffs_lzw_decode_pi() { // ---------------- LZW Benches bool do_bench_wuffs_lzw_decode(const char* filename, uint64_t reps) { - wuffs_base__buf1 dst = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; - wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; - wuffs_base__writer1 dst_writer = {.buf = &dst}; - wuffs_base__reader1 src_reader = {.buf = &src}; + wuffs_base__io_buffer dst = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_writer dst_writer = {.buf = &dst}; + wuffs_base__io_reader src_reader = {.buf = &src}; if (!read_file(&src, filename)) { return false; @@ -358,12 +358,13 @@ void bench_wuffs_lzw_decode_100k() { // ---------------- GIF Tests -const char* wuffs_gif_decode(wuffs_base__buf1* dst, wuffs_base__buf1* src) { +const char* wuffs_gif_decode(wuffs_base__io_buffer* dst, + wuffs_base__io_buffer* src) { wuffs_gif__decoder dec; wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0); wuffs_base__image_config ic = {{0}}; - wuffs_base__writer1 dst_writer = {.buf = dst}; - wuffs_base__reader1 src_reader = {.buf = src}; + wuffs_base__io_writer dst_writer = {.buf = dst}; + wuffs_base__io_reader src_reader = {.buf = src}; wuffs_gif__status s = wuffs_gif__decoder__decode_config(&dec, &ic, src_reader); if (s) { @@ -381,8 +382,8 @@ bool do_test_wuffs_gif_decode(const char* filename, const char* indexes_filename, uint64_t wlimit, uint64_t rlimit) { - wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; - wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; if (!read_file(&src, filename)) { return false; @@ -393,7 +394,7 @@ bool do_test_wuffs_gif_decode(const char* filename, { wuffs_base__image_config ic = {{0}}; - wuffs_base__reader1 src_reader = {.buf = &src}; + wuffs_base__io_reader src_reader = {.buf = &src}; wuffs_gif__status status = wuffs_gif__decoder__decode_config(&dec, &ic, src_reader); if (status != WUFFS_GIF__STATUS_OK) { @@ -432,12 +433,12 @@ bool do_test_wuffs_gif_decode(const char* filename, uint64_t rlim = 0; while (true) { num_iters++; - wuffs_base__writer1 got_writer = {.buf = &got}; + wuffs_base__io_writer got_writer = {.buf = &got}; if (wlimit) { wlim = wlimit; got_writer.private_impl.limit.ptr_to_len = &wlim; } - wuffs_base__reader1 src_reader = {.buf = &src}; + wuffs_base__io_reader src_reader = {.buf = &src}; if (rlimit) { rlim = rlimit; src_reader.private_impl.limit.ptr_to_len = &rlim; @@ -489,21 +490,24 @@ bool do_test_wuffs_gif_decode(const char* filename, } // TODO: provide a public API for getting the palette. - wuffs_base__buf1 pal_got = {.ptr = dec.private_impl.f_gct, .len = 3 * 256}; - wuffs_base__buf1 pal_want = {.ptr = global_palette_buffer, .len = 3 * 256}; + wuffs_base__io_buffer pal_got = {.ptr = dec.private_impl.f_gct, + .len = 3 * 256}; + wuffs_base__io_buffer pal_want = {.ptr = global_palette_buffer, + .len = 3 * 256}; pal_got.wi = 3 * 256; if (!read_file(&pal_want, palette_filename)) { return false; } - if (!buf1s_equal("palette ", &pal_got, &pal_want)) { + if (!io_buffers_equal("palette ", &pal_got, &pal_want)) { return false; } - wuffs_base__buf1 ind_want = {.ptr = global_want_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer ind_want = {.ptr = global_want_buffer, + .len = BUFFER_SIZE}; if (!read_file(&ind_want, indexes_filename)) { return false; } - if (!buf1s_equal("indexes ", &got, &ind_want)) { + if (!io_buffers_equal("indexes ", &got, &ind_want)) { return false; } @@ -512,8 +516,8 @@ bool do_test_wuffs_gif_decode(const char* filename, FAIL("decode_frame returned \"ok\" but src was exhausted"); return false; } - wuffs_base__writer1 got_writer = {.buf = &got}; - wuffs_base__reader1 src_reader = {.buf = &src}; + wuffs_base__io_writer got_writer = {.buf = &got}; + wuffs_base__io_reader src_reader = {.buf = &src}; wuffs_gif__status status = wuffs_gif__decoder__decode_frame(&dec, got_writer, src_reader); if (status != WUFFS_GIF__SUSPENSION_END_OF_DATA) { @@ -534,8 +538,8 @@ bool do_test_wuffs_gif_decode(const char* filename, void test_wuffs_gif_call_sequence() { CHECK_FOCUS(__func__); - wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; - wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; if (!read_file(&src, "../../data/bricks-dither.gif")) { return; @@ -544,8 +548,8 @@ void test_wuffs_gif_call_sequence() { wuffs_gif__decoder dec; wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0); - wuffs_base__writer1 got_writer = {.buf = &got}; - wuffs_base__reader1 src_reader = {.buf = &src}; + wuffs_base__io_writer got_writer = {.buf = &got}; + wuffs_base__io_reader src_reader = {.buf = &src}; wuffs_gif__status status = wuffs_gif__decoder__decode_frame(&dec, got_writer, src_reader); @@ -561,8 +565,8 @@ void test_wuffs_gif_call_sequence() { void test_wuffs_gif_decode_animated() { CHECK_FOCUS(__func__); - wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; - wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; if (!read_file(&src, "../../data/animated-red-blue.gif")) { return; @@ -572,8 +576,8 @@ void test_wuffs_gif_decode_animated() { wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0); wuffs_base__image_config ic = {{0}}; - wuffs_base__writer1 got_writer = {.buf = &got}; - wuffs_base__reader1 src_reader = {.buf = &src}; + wuffs_base__io_writer got_writer = {.buf = &got}; + wuffs_base__io_reader src_reader = {.buf = &src}; wuffs_gif__status status = wuffs_gif__decoder__decode_config(&dec, &ic, src_reader); @@ -657,7 +661,7 @@ void test_wuffs_gif_decode_input_is_a_gif_many_small_writes_reads() { void test_wuffs_gif_decode_input_is_a_png() { CHECK_FOCUS(__func__); - wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; if (!read_file(&src, "../../data/bricks-dither.png")) { return; @@ -666,7 +670,7 @@ void test_wuffs_gif_decode_input_is_a_png() { wuffs_gif__decoder dec; wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0); wuffs_base__image_config ic = {{0}}; - wuffs_base__reader1 src_reader = {.buf = &src}; + wuffs_base__io_reader src_reader = {.buf = &src}; wuffs_gif__status status = wuffs_gif__decoder__decode_config(&dec, &ic, src_reader); @@ -683,13 +687,13 @@ void test_wuffs_gif_decode_input_is_a_png() { #ifdef WUFFS_MIMIC bool do_test_mimic_gif_decode(const char* filename) { - wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; if (!read_file(&src, filename)) { return false; } src.ri = 0; - wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; const char* got_msg = wuffs_gif_decode(&got, &src); if (got_msg) { FAIL("%s", got_msg); @@ -697,14 +701,14 @@ bool do_test_mimic_gif_decode(const char* filename) { } src.ri = 0; - wuffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer want = {.ptr = global_want_buffer, .len = BUFFER_SIZE}; const char* want_msg = mimic_gif_decode(&want, &src); if (want_msg) { FAIL("%s", want_msg); return false; } - if (!buf1s_equal("", &got, &want)) { + if (!io_buffers_equal("", &got, &want)) { return false; } @@ -752,12 +756,12 @@ void test_mimic_gif_decode_pjw_thumbnail() { // ---------------- GIF Benches -bool do_bench_gif_decode(const char* (*decode_func)(wuffs_base__buf1*, - wuffs_base__buf1*), +bool do_bench_gif_decode(const char* (*decode_func)(wuffs_base__io_buffer*, + wuffs_base__io_buffer*), const char* filename, uint64_t reps) { - wuffs_base__buf1 dst = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; - wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer dst = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; if (!read_file(&src, filename)) { return false; diff --git a/test/c/std/gzip.c b/test/c/std/gzip.c index 20942c4b..6129fc72 100644 --- a/test/c/std/gzip.c +++ b/test/c/std/gzip.c @@ -62,8 +62,8 @@ golden_test gzip_pi_gt = { // ---------------- Gzip Tests -const char* wuffs_gzip_decode(wuffs_base__buf1* dst, - wuffs_base__buf1* src, +const char* wuffs_gzip_decode(wuffs_base__io_buffer* dst, + wuffs_base__io_buffer* src, uint64_t wlimit, uint64_t rlimit) { wuffs_gzip__decoder dec; @@ -72,12 +72,12 @@ const char* wuffs_gzip_decode(wuffs_base__buf1* dst, uint64_t wlim = 0; uint64_t rlim = 0; while (true) { - wuffs_base__writer1 dst_writer = {.buf = dst}; + wuffs_base__io_writer dst_writer = {.buf = dst}; if (wlimit) { wlim = wlimit; dst_writer.private_impl.limit.ptr_to_len = &wlim; } - wuffs_base__reader1 src_reader = {.buf = src}; + wuffs_base__io_reader src_reader = {.buf = src}; if (rlimit) { rlim = rlimit; src_reader.private_impl.limit.ptr_to_len = &rlim; @@ -98,8 +98,8 @@ const char* wuffs_gzip_decode(wuffs_base__buf1* dst, } bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) { - wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; - wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; if (!read_file(&src, gzip_midsummer_gt.src_filename)) { return false; @@ -120,9 +120,9 @@ bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) { wuffs_gzip__decoder__initialize(&dec, WUFFS_VERSION, 0); wuffs_gzip__decoder__set_ignore_checksum(&dec, ignore_checksum); got.wi = 0; - wuffs_base__writer1 got_writer = {.buf = &got}; + wuffs_base__io_writer got_writer = {.buf = &got}; src.ri = 0; - wuffs_base__reader1 src_reader = {.buf = &src}; + wuffs_base__io_reader src_reader = {.buf = &src}; // Decode the src data in 1 or 2 chunks, depending on whether end_limit is // or isn't zero. @@ -182,12 +182,12 @@ void test_wuffs_gzip_checksum_verify_good() { void test_wuffs_gzip_decode_midsummer() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_gzip_decode, &gzip_midsummer_gt, 0, 0); + do_test_io_buffers(wuffs_gzip_decode, &gzip_midsummer_gt, 0, 0); } void test_wuffs_gzip_decode_pi() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_gzip_decode, &gzip_pi_gt, 0, 0); + do_test_io_buffers(wuffs_gzip_decode, &gzip_pi_gt, 0, 0); } // ---------------- Mimic Tests @@ -196,12 +196,12 @@ void test_wuffs_gzip_decode_pi() { void test_mimic_gzip_decode_midsummer() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(mimic_gzip_decode, &gzip_midsummer_gt, 0, 0); + do_test_io_buffers(mimic_gzip_decode, &gzip_midsummer_gt, 0, 0); } void test_mimic_gzip_decode_pi() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(mimic_gzip_decode, &gzip_pi_gt, 0, 0); + do_test_io_buffers(mimic_gzip_decode, &gzip_pi_gt, 0, 0); } #endif // WUFFS_MIMIC @@ -210,13 +210,13 @@ void test_mimic_gzip_decode_pi() { void bench_wuffs_gzip_decode_10k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(wuffs_gzip_decode, tc_dst, &gzip_midsummer_gt, 0, 0, - 30000); + do_bench_io_buffers(wuffs_gzip_decode, tc_dst, &gzip_midsummer_gt, 0, 0, + 30000); } void bench_wuffs_gzip_decode_100k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(wuffs_gzip_decode, tc_dst, &gzip_pi_gt, 0, 0, 3000); + do_bench_io_buffers(wuffs_gzip_decode, tc_dst, &gzip_pi_gt, 0, 0, 3000); } // ---------------- Mimic Benches @@ -225,13 +225,13 @@ void bench_wuffs_gzip_decode_100k() { void bench_mimic_gzip_decode_10k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(mimic_gzip_decode, tc_dst, &gzip_midsummer_gt, 0, 0, - 30000); + do_bench_io_buffers(mimic_gzip_decode, tc_dst, &gzip_midsummer_gt, 0, 0, + 30000); } void bench_mimic_gzip_decode_100k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(mimic_gzip_decode, tc_dst, &gzip_pi_gt, 0, 0, 3000); + do_bench_io_buffers(mimic_gzip_decode, tc_dst, &gzip_pi_gt, 0, 0, 3000); } #endif // WUFFS_MIMIC diff --git a/test/c/std/zlib.c b/test/c/std/zlib.c index 04ffa9a2..bb56668e 100644 --- a/test/c/std/zlib.c +++ b/test/c/std/zlib.c @@ -124,7 +124,7 @@ void test_wuffs_adler32_golden() { int i; for (i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); i++) { - wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; if (!read_file(&src, test_cases[i].filename)) { return; } @@ -189,8 +189,8 @@ void test_wuffs_adler32_pi() { // ---------------- Zlib Tests -const char* wuffs_zlib_decode(wuffs_base__buf1* dst, - wuffs_base__buf1* src, +const char* wuffs_zlib_decode(wuffs_base__io_buffer* dst, + wuffs_base__io_buffer* src, uint64_t wlimit, uint64_t rlimit) { wuffs_zlib__decoder dec; @@ -199,12 +199,12 @@ const char* wuffs_zlib_decode(wuffs_base__buf1* dst, uint64_t wlim = 0; uint64_t rlim = 0; while (true) { - wuffs_base__writer1 dst_writer = {.buf = dst}; + wuffs_base__io_writer dst_writer = {.buf = dst}; if (wlimit) { wlim = wlimit; dst_writer.private_impl.limit.ptr_to_len = &wlim; } - wuffs_base__reader1 src_reader = {.buf = src}; + wuffs_base__io_reader src_reader = {.buf = src}; if (rlimit) { rlim = rlimit; src_reader.private_impl.limit.ptr_to_len = &rlim; @@ -225,8 +225,8 @@ const char* wuffs_zlib_decode(wuffs_base__buf1* dst, } bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) { - wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; - wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; if (!read_file(&src, zlib_midsummer_gt.src_filename)) { return false; @@ -246,9 +246,9 @@ bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) { wuffs_zlib__decoder__initialize(&dec, WUFFS_VERSION, 0); wuffs_zlib__decoder__set_ignore_checksum(&dec, ignore_checksum); got.wi = 0; - wuffs_base__writer1 got_writer = {.buf = &got}; + wuffs_base__io_writer got_writer = {.buf = &got}; src.ri = 0; - wuffs_base__reader1 src_reader = {.buf = &src}; + wuffs_base__io_reader src_reader = {.buf = &src}; // Decode the src data in 1 or 2 chunks, depending on whether end_limit is // or isn't zero. @@ -303,12 +303,12 @@ void test_wuffs_zlib_checksum_verify_good() { void test_wuffs_zlib_decode_midsummer() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_zlib_decode, &zlib_midsummer_gt, 0, 0); + do_test_io_buffers(wuffs_zlib_decode, &zlib_midsummer_gt, 0, 0); } void test_wuffs_zlib_decode_pi() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_zlib_decode, &zlib_pi_gt, 0, 0); + do_test_io_buffers(wuffs_zlib_decode, &zlib_pi_gt, 0, 0); } // ---------------- Mimic Tests @@ -317,12 +317,12 @@ void test_wuffs_zlib_decode_pi() { void test_mimic_zlib_decode_midsummer() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(mimic_zlib_decode, &zlib_midsummer_gt, 0, 0); + do_test_io_buffers(mimic_zlib_decode, &zlib_midsummer_gt, 0, 0); } void test_mimic_zlib_decode_pi() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(mimic_zlib_decode, &zlib_pi_gt, 0, 0); + do_test_io_buffers(mimic_zlib_decode, &zlib_pi_gt, 0, 0); } #endif // WUFFS_MIMIC @@ -331,8 +331,8 @@ void test_mimic_zlib_decode_pi() { uint32_t global_wuffs_zlib_unused_u32; -const char* wuffs_bench_adler32(wuffs_base__buf1* dst, - wuffs_base__buf1* src, +const char* wuffs_bench_adler32(wuffs_base__io_buffer* dst, + wuffs_base__io_buffer* src, uint64_t wlimit, uint64_t rlimit) { // TODO: don't ignore wlimit and rlimit. @@ -349,26 +349,26 @@ const char* wuffs_bench_adler32(wuffs_base__buf1* dst, void bench_wuffs_adler32_10k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(wuffs_bench_adler32, tc_src, &adler32_midsummer_gt, 0, 0, - 150000); + do_bench_io_buffers(wuffs_bench_adler32, tc_src, &adler32_midsummer_gt, 0, 0, + 150000); } void bench_wuffs_adler32_100k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(wuffs_bench_adler32, tc_src, &adler32_pi_gt, 0, 0, 15000); + do_bench_io_buffers(wuffs_bench_adler32, tc_src, &adler32_pi_gt, 0, 0, 15000); } // ---------------- Zlib Benches void bench_wuffs_zlib_decode_10k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(wuffs_zlib_decode, tc_dst, &zlib_midsummer_gt, 0, 0, - 30000); + do_bench_io_buffers(wuffs_zlib_decode, tc_dst, &zlib_midsummer_gt, 0, 0, + 30000); } void bench_wuffs_zlib_decode_100k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(wuffs_zlib_decode, tc_dst, &zlib_pi_gt, 0, 0, 3000); + do_bench_io_buffers(wuffs_zlib_decode, tc_dst, &zlib_pi_gt, 0, 0, 3000); } // ---------------- Mimic Benches @@ -377,24 +377,24 @@ void bench_wuffs_zlib_decode_100k() { void bench_mimic_adler32_10k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(mimic_bench_adler32, tc_src, &adler32_midsummer_gt, 0, 0, - 150000); + do_bench_io_buffers(mimic_bench_adler32, tc_src, &adler32_midsummer_gt, 0, 0, + 150000); } void bench_mimic_adler32_100k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(mimic_bench_adler32, tc_src, &adler32_pi_gt, 0, 0, 15000); + do_bench_io_buffers(mimic_bench_adler32, tc_src, &adler32_pi_gt, 0, 0, 15000); } void bench_mimic_zlib_decode_10k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(mimic_zlib_decode, tc_dst, &zlib_midsummer_gt, 0, 0, - 30000); + do_bench_io_buffers(mimic_zlib_decode, tc_dst, &zlib_midsummer_gt, 0, 0, + 30000); } void bench_mimic_zlib_decode_100k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(mimic_zlib_decode, tc_dst, &zlib_pi_gt, 0, 0, 3000); + do_bench_io_buffers(mimic_zlib_decode, tc_dst, &zlib_pi_gt, 0, 0, 3000); } #endif // WUFFS_MIMIC diff --git a/test/c/testlib/testlib.c b/test/c/testlib/testlib.c index 4219cd0f..9baad468 100644 --- a/test/c/testlib/testlib.c +++ b/test/c/testlib/testlib.c @@ -264,10 +264,10 @@ int test_main(int argc, char** argv, proc* tests, proc* benches) { return 0; } -// WUFFS_BASE_HEADER_H is where wuffs_base__buf1 is defined. +// WUFFS_BASE_HEADER_H is where wuffs_base__io_buffer is defined. #ifdef WUFFS_BASE_HEADER_H -bool read_file(wuffs_base__buf1* dst, const char* path) { +bool read_file(wuffs_base__io_buffer* dst, const char* path) { if (!dst || !path) { FAIL("read_file: NULL argument"); return false; @@ -322,7 +322,7 @@ bool read_file(wuffs_base__buf1* dst, const char* path) { return true; } -char* hex_dump(char* msg, wuffs_base__buf1* buf, size_t i) { +char* hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) { if (!msg || !buf) { FAIL("hex_dump: NULL argument"); return NULL; @@ -372,11 +372,11 @@ char* hex_dump(char* msg, wuffs_base__buf1* buf, size_t i) { return msg; } -bool buf1s_equal(const char* prefix, - wuffs_base__buf1* got, - wuffs_base__buf1* want) { +bool io_buffers_equal(const char* prefix, + wuffs_base__io_buffer* got, + wuffs_base__io_buffer* want) { if (!got || !want) { - FAIL("%sbuf1s_equal: NULL argument", prefix); + FAIL("%sio_buffers_equal: NULL argument", prefix); return false; } char* msg = fail_msg; @@ -387,10 +387,10 @@ bool buf1s_equal(const char* prefix, } } if (got->wi != want->wi) { - INCR_FAIL(msg, "%sbuf1s_equal: wi: got %zu, want %zu.\n", prefix, got->wi, - want->wi); + INCR_FAIL(msg, "%sio_buffers_equal: wi: got %zu, want %zu.\n", prefix, + got->wi, want->wi); } else if (i < got->wi) { - INCR_FAIL(msg, "%sbuf1s_equal:\n", prefix); + INCR_FAIL(msg, "%sio_buffers_equal:\n", prefix); } else { return true; } @@ -411,16 +411,16 @@ typedef enum { tc_src = 2, } throughput_counter; -bool proc_buf1_buf1(const char* (*codec_func)(wuffs_base__buf1*, - wuffs_base__buf1*, - uint64_t, - uint64_t), - throughput_counter tc, - golden_test* gt, - uint64_t wlimit, - uint64_t rlimit, - uint64_t reps, - bool bench) { +bool proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*, + wuffs_base__io_buffer*, + uint64_t, + uint64_t), + throughput_counter tc, + golden_test* gt, + uint64_t wlimit, + uint64_t rlimit, + uint64_t reps, + bool bench) { if (!codec_func) { FAIL("NULL codec_func"); return false; @@ -430,9 +430,9 @@ bool proc_buf1_buf1(const char* (*codec_func)(wuffs_base__buf1*, return false; } - wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; - wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; - wuffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer want = {.ptr = global_want_buffer, .len = BUFFER_SIZE}; if (!gt->src_filename) { src.closed = true; @@ -486,32 +486,32 @@ bool proc_buf1_buf1(const char* (*codec_func)(wuffs_base__buf1*, } else if (!read_file(&want, gt->want_filename)) { return false; } - if (!buf1s_equal("", &got, &want)) { + if (!io_buffers_equal("", &got, &want)) { return false; } return true; } -bool do_bench_buf1_buf1(const char* (*codec_func)(wuffs_base__buf1*, - wuffs_base__buf1*, - uint64_t, - uint64_t), - throughput_counter tc, - golden_test* gt, - uint64_t wlimit, - uint64_t rlimit, - uint64_t reps) { - return proc_buf1_buf1(codec_func, tc, gt, wlimit, rlimit, reps, true); +bool do_bench_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*, + wuffs_base__io_buffer*, + uint64_t, + uint64_t), + throughput_counter tc, + golden_test* gt, + uint64_t wlimit, + uint64_t rlimit, + uint64_t reps) { + return proc_io_buffers(codec_func, tc, gt, wlimit, rlimit, reps, true); } -bool do_test_buf1_buf1(const char* (*codec_func)(wuffs_base__buf1*, - wuffs_base__buf1*, - uint64_t, - uint64_t), - golden_test* gt, - uint64_t wlimit, - uint64_t rlimit) { - return proc_buf1_buf1(codec_func, tc_neither, gt, wlimit, rlimit, 1, false); +bool do_test_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*, + wuffs_base__io_buffer*, + uint64_t, + uint64_t), + golden_test* gt, + uint64_t wlimit, + uint64_t rlimit) { + return proc_io_buffers(codec_func, tc_neither, gt, wlimit, rlimit, 1, false); } #endif // WUFFS_BASE_HEADER_H