diff --git a/cmd/wuffs-c/internal/cgen/base/base-private.h b/cmd/wuffs-c/internal/cgen/base/base-private.h index c10f97c5..a72f18f1 100644 --- a/cmd/wuffs-c/internal/cgen/base/base-private.h +++ b/cmd/wuffs-c/internal/cgen/base/base-private.h @@ -494,8 +494,8 @@ wuffs_base__utility__make_rect_ie_u32(wuffs_base__utility* ignored, static inline bool // wuffs_base__io_buffer__is_valid(wuffs_base__io_buffer buf) { - return (buf.ptr || (buf.len == 0)) && (buf.len >= buf.wi) && - (buf.wi >= buf.ri); + return (buf.data.ptr || (buf.data.len == 0)) && + (buf.data.len >= buf.meta.wi) && (buf.meta.wi >= buf.meta.ri); } // TODO: wuffs_base__io_reader__is_eof is no longer used by Wuffs per se, but @@ -508,7 +508,8 @@ wuffs_base__io_buffer__is_valid(wuffs_base__io_buffer buf) { static inline bool // wuffs_base__io_reader__is_eof(wuffs_base__io_reader o) { wuffs_base__io_buffer* buf = o.private_impl.buf; - return buf && buf->closed && (buf->ptr + buf->wi == o.private_impl.limit); + return buf && buf->meta.closed && + (buf->data.ptr + buf->meta.wi == o.private_impl.limit); } static inline bool // @@ -516,9 +517,9 @@ wuffs_base__io_reader__is_valid(wuffs_base__io_reader o) { wuffs_base__io_buffer* buf = o.private_impl.buf; // Note: if making this function public (i.e. moving it to base-header.h), it // also needs to allow NULL (i.e. implicit, callee-calculated) mark/limit. - return buf ? ((buf->ptr <= o.private_impl.mark) && + return buf ? ((buf->data.ptr <= o.private_impl.mark) && (o.private_impl.mark <= o.private_impl.limit) && - (o.private_impl.limit <= buf->ptr + buf->len)) + (o.private_impl.limit <= buf->data.ptr + buf->data.len)) : ((o.private_impl.mark == NULL) && (o.private_impl.limit == NULL)); } @@ -528,9 +529,9 @@ wuffs_base__io_writer__is_valid(wuffs_base__io_writer o) { wuffs_base__io_buffer* buf = o.private_impl.buf; // Note: if making this function public (i.e. moving it to base-header.h), it // also needs to allow NULL (i.e. implicit, callee-calculated) mark/limit. - return buf ? ((buf->ptr <= o.private_impl.mark) && + return buf ? ((buf->data.ptr <= o.private_impl.mark) && (o.private_impl.mark <= o.private_impl.limit) && - (o.private_impl.limit <= buf->ptr + buf->len)) + (o.private_impl.limit <= buf->data.ptr + buf->data.len)) : ((o.private_impl.mark == NULL) && (o.private_impl.limit == NULL)); } @@ -685,11 +686,12 @@ wuffs_base__io_writer__set(wuffs_base__io_writer* o, uint8_t** ioptr1_ptr, uint8_t** ioptr2_ptr, wuffs_base__slice_u8 s) { - b->ptr = s.ptr; - b->len = s.len; - b->wi = 0; - b->ri = 0; - b->closed = false; + b->data.ptr = s.ptr; + b->data.len = s.len; + b->meta.wi = 0; + b->meta.ri = 0; + // TODO: set b->meta.pos. + b->meta.closed = false; o->private_impl.buf = b; o->private_impl.mark = s.ptr; o->private_impl.limit = s.ptr + s.len; diff --git a/cmd/wuffs-c/internal/cgen/base/base-public.h b/cmd/wuffs-c/internal/cgen/base/base-public.h index 1c2fbc92..71646461 100644 --- a/cmd/wuffs-c/internal/cgen/base/base-public.h +++ b/cmd/wuffs-c/internal/cgen/base/base-public.h @@ -1043,18 +1043,22 @@ typedef struct { } private_impl; } wuffs_base__io_writer; -// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length), plus -// additional indexes into that buffer, plus a buffer position and an opened / -// closed flag. -// -// A value with all fields NULL or zero is a valid, empty buffer. -typedef struct wuffs_base__io_buffer__struct { - uint8_t* ptr; // Pointer. - size_t len; // Length. +// wuffs_base__io_buffer_meta is the metadata for a wuffs_base__io_buffer's +// data. +typedef struct { size_t wi; // Write index. Invariant: wi <= len. size_t ri; // Read index. Invariant: ri <= wi. uint64_t pos; // Position of the buffer start relative to the stream start. bool closed; // No further writes are expected. +} wuffs_base__io_buffer_meta; + +// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length) plus +// additional metadata. +// +// A value with all fields zero is a valid, empty buffer. +typedef struct wuffs_base__io_buffer__struct { + wuffs_base__slice_u8 data; + wuffs_base__io_buffer_meta meta; #ifdef __cplusplus inline void compact(); @@ -1070,26 +1074,26 @@ typedef struct wuffs_base__io_buffer__struct { // start of the buffer. static inline void // wuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) { - if (!buf || (buf->ri == 0)) { + if (!buf || (buf->meta.ri == 0)) { return; } - buf->pos = wuffs_base__u64__sat_add(buf->pos, buf->ri); - size_t n = buf->wi - buf->ri; + buf->meta.pos = wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri); + size_t n = buf->meta.wi - buf->meta.ri; if (n != 0) { - memmove(buf->ptr, buf->ptr + buf->ri, n); + memmove(buf->data.ptr, buf->data.ptr + buf->meta.ri, n); } - buf->wi = n; - buf->ri = 0; + buf->meta.wi = n; + buf->meta.ri = 0; } static inline uint64_t // wuffs_base__io_buffer__io_position_reader(wuffs_base__io_buffer* buf) { - return buf ? wuffs_base__u64__sat_add(buf->pos, buf->ri) : 0; + return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri) : 0; } static inline uint64_t // wuffs_base__io_buffer__io_position_writer(wuffs_base__io_buffer* buf) { - return buf ? wuffs_base__u64__sat_add(buf->pos, buf->wi) : 0; + return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.wi) : 0; } static inline wuffs_base__io_reader // @@ -1156,7 +1160,7 @@ wuffs_base__malloc_slice_u8(void* (*malloc_func)(size_t), uint64_t num_u8) { void* p = (*malloc_func)(num_u8 * sizeof(uint8_t)); if (p) { return ((wuffs_base__slice_u8){ - .ptr = p, + .ptr = (uint8_t*)(p), .len = num_u8, }); } @@ -1170,7 +1174,7 @@ wuffs_base__malloc_slice_u16(void* (*malloc_func)(size_t), uint64_t num_u16) { void* p = (*malloc_func)(num_u16 * sizeof(uint16_t)); if (p) { return ((wuffs_base__slice_u16){ - .ptr = p, + .ptr = (uint16_t*)(p), .len = num_u16, }); } @@ -1184,7 +1188,7 @@ wuffs_base__malloc_slice_u32(void* (*malloc_func)(size_t), uint64_t num_u32) { void* p = (*malloc_func)(num_u32 * sizeof(uint32_t)); if (p) { return ((wuffs_base__slice_u32){ - .ptr = p, + .ptr = (uint32_t*)(p), .len = num_u32, }); } @@ -1198,7 +1202,7 @@ wuffs_base__malloc_slice_u64(void* (*malloc_func)(size_t), uint64_t num_u64) { void* p = (*malloc_func)(num_u64 * sizeof(uint64_t)); if (p) { return ((wuffs_base__slice_u64){ - .ptr = p, + .ptr = (uint64_t*)(p), .len = num_u64, }); } diff --git a/cmd/wuffs-c/internal/cgen/builtin.go b/cmd/wuffs-c/internal/cgen/builtin.go index 9617fce0..59ea5fd6 100644 --- a/cmd/wuffs-c/internal/cgen/builtin.go +++ b/cmd/wuffs-c/internal/cgen/builtin.go @@ -124,7 +124,7 @@ func (g *gen) writeBuiltinIOReader(b *buffer, recv *a.Expr, method t.ID, args [] case t.IDPosition: b.printf("(a_src.private_impl.buf ? wuffs_base__u64__sat_add(" + - "a_src.private_impl.buf->pos, iop_a_src - a_src.private_impl.buf->ptr) : 0)") + "a_src.private_impl.buf->meta.pos, iop_a_src - a_src.private_impl.buf->data.ptr) : 0)") return nil case t.IDSetLimit: @@ -207,7 +207,7 @@ func (g *gen) writeBuiltinIOWriter(b *buffer, recv *a.Expr, method t.ID, args [] case t.IDPosition: b.printf("(a_dst.private_impl.buf ? wuffs_base__u64__sat_add(" + - "a_dst.private_impl.buf->pos, iop_a_dst - a_dst.private_impl.buf->ptr) : 0)") + "a_dst.private_impl.buf->meta.pos, iop_a_dst - a_dst.private_impl.buf->data.ptr) : 0)") return nil case t.IDSetMark: diff --git a/cmd/wuffs-c/internal/cgen/data.go b/cmd/wuffs-c/internal/cgen/data.go index 8ab57c2e..ce7bd559 100644 --- a/cmd/wuffs-c/internal/cgen/data.go +++ b/cmd/wuffs-c/internal/cgen/data.go @@ -66,14 +66,14 @@ const baseBasePublicH = "" + "e uint32_t //\nwuffs_base__rect_ie_u32__width(wuffs_base__rect_ie_u32* r) {\n return wuffs_base__u32__sat_sub(r->max_excl_x, r->min_incl_x);\n}\n\nstatic inline uint32_t //\nwuffs_base__rect_ie_u32__height(wuffs_base__rect_ie_u32* r) {\n return wuffs_base__u32__sat_sub(r->max_excl_y, r->min_incl_y);\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__rect_ie_u32::is_empty() {\n return wuffs_base__rect_ie_u32__is_empty(this);\n}\n\ninline bool //\nwuffs_base__rect_ie_u32::equals(wuffs_base__rect_ie_u32 s) {\n return wuffs_base__rect_ie_u32__equals(this, s);\n}\n\ninline bool //\nwuffs_base__rect_ie_u32::contains(uint32_t x, uint32_t y) {\n return wuffs_base__rect_ie_u32__contains(this, x, y);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__rect_ie_u32::intersect(wuffs_base__rect_ie_u32 s) {\n return wuffs_base__rect_ie_u32__intersect(this, s);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__rect_ie_u32::unite(wuffs_base__rect_ie_u32 s) {\n return wuffs_base__rect_ie_u32__unite(this, s);\n}\n\ninline uint32_t //\nwuffs_" + "base__rect_ie_u32::width() {\n return wuffs_base__rect_ie_u32__width(this);\n}\n\ninline uint32_t //\nwuffs_base__rect_ie_u32::height() {\n return wuffs_base__rect_ie_u32__height(this);\n}\n\n#endif // __cplusplus\n\n" + "" + - "// ---------------- I/O\n\nstruct wuffs_base__io_buffer__struct;\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 struct wuffs_base__io_buffer__struct* buf;\n // The bounds values are typically NULL, when created by the Wuffs public\n // API. NULL means that the callee substitutes the implicit bounds derived\n // from buf.\n uint8_t* mark;\n uint8_t* limit;\n } private_impl;\n} wuffs_base__io_reader;\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 struct wuffs_base__io_buffer__struct* buf;\n // The bounds values are typically NULL, when created by the Wuffs public\n // API. NULL means that the callee substitutes the implicit bounds derived\n // from buf.\n uint8_t* mark;\n uint8_t* limit;\n } private_impl;\n} wuffs_base__io_writer;\n\n// wuffs_base__io_buffer is a 1-dimensio" + - "nal buffer (a pointer and length), plus\n// additional indexes into that buffer, plus a buffer position and an opened /\n// closed flag.\n//\n// A value with all fields NULL or zero is a valid, empty buffer.\ntypedef struct wuffs_base__io_buffer__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 uint64_t pos; // Position of the buffer start relative to the stream start.\n bool closed; // No further writes are expected.\n\n#ifdef __cplusplus\n inline void compact();\n inline uint64_t io_position_reader();\n inline uint64_t io_position_writer();\n inline wuffs_base__io_reader reader();\n inline wuffs_base__io_writer writer();\n#endif // __cplusplus\n\n} wuffs_base__io_buffer;\n\n// wuffs_base__io_buffer__compact moves any written but unread bytes to the\n// start of the buffer.\nstatic inline void //\nwuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) {\n if (!buf || (buf->ri == 0)) {\n " + - " return;\n }\n buf->pos = wuffs_base__u64__sat_add(buf->pos, buf->ri);\n size_t n = buf->wi - buf->ri;\n if (n != 0) {\n memmove(buf->ptr, buf->ptr + buf->ri, n);\n }\n buf->wi = n;\n buf->ri = 0;\n}\n\nstatic inline uint64_t //\nwuffs_base__io_buffer__io_position_reader(wuffs_base__io_buffer* buf) {\n return buf ? wuffs_base__u64__sat_add(buf->pos, buf->ri) : 0;\n}\n\nstatic inline uint64_t //\nwuffs_base__io_buffer__io_position_writer(wuffs_base__io_buffer* buf) {\n return buf ? wuffs_base__u64__sat_add(buf->pos, buf->wi) : 0;\n}\n\nstatic inline wuffs_base__io_reader //\nwuffs_base__io_buffer__reader(wuffs_base__io_buffer* buf) {\n wuffs_base__io_reader ret = ((wuffs_base__io_reader){});\n ret.private_impl.buf = buf;\n return ret;\n}\n\nstatic inline wuffs_base__io_writer //\nwuffs_base__io_buffer__writer(wuffs_base__io_buffer* buf) {\n wuffs_base__io_writer ret = ((wuffs_base__io_writer){});\n ret.private_impl.buf = buf;\n return ret;\n}\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__io_buffer__struct::compact() {" + - "\n wuffs_base__io_buffer__compact(this);\n}\n\ninline uint64_t //\nwuffs_base__io_buffer__struct::io_position_reader() {\n return wuffs_base__io_buffer__io_position_reader(this);\n}\n\ninline uint64_t //\nwuffs_base__io_buffer__struct::io_position_writer() {\n return wuffs_base__io_buffer__io_position_writer(this);\n}\n\ninline wuffs_base__io_reader //\nwuffs_base__io_buffer__struct::reader() {\n return wuffs_base__io_buffer__reader(this);\n}\n\ninline wuffs_base__io_writer //\nwuffs_base__io_buffer__struct::writer() {\n return wuffs_base__io_buffer__writer(this);\n}\n\n#endif // __cplusplus\n\n" + + "// ---------------- I/O\n\nstruct wuffs_base__io_buffer__struct;\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 struct wuffs_base__io_buffer__struct* buf;\n // The bounds values are typically NULL, when created by the Wuffs public\n // API. NULL means that the callee substitutes the implicit bounds derived\n // from buf.\n uint8_t* mark;\n uint8_t* limit;\n } private_impl;\n} wuffs_base__io_reader;\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 struct wuffs_base__io_buffer__struct* buf;\n // The bounds values are typically NULL, when created by the Wuffs public\n // API. NULL means that the callee substitutes the implicit bounds derived\n // from buf.\n uint8_t* mark;\n uint8_t* limit;\n } private_impl;\n} wuffs_base__io_writer;\n\n// wuffs_base__io_buffer_meta is the met" + + "adata for a wuffs_base__io_buffer's\n// data.\ntypedef struct {\n size_t wi; // Write index. Invariant: wi <= len.\n size_t ri; // Read index. Invariant: ri <= wi.\n uint64_t pos; // Position of the buffer start relative to the stream start.\n bool closed; // No further writes are expected.\n} wuffs_base__io_buffer_meta;\n\n// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length) plus\n// additional metadata.\n//\n// A value with all fields zero is a valid, empty buffer.\ntypedef struct wuffs_base__io_buffer__struct {\n wuffs_base__slice_u8 data;\n wuffs_base__io_buffer_meta meta;\n\n#ifdef __cplusplus\n inline void compact();\n inline uint64_t io_position_reader();\n inline uint64_t io_position_writer();\n inline wuffs_base__io_reader reader();\n inline wuffs_base__io_writer writer();\n#endif // __cplusplus\n\n} wuffs_base__io_buffer;\n\n// wuffs_base__io_buffer__compact moves any written but unread bytes to the\n// start of the buffer.\nstatic inline void //\nwuffs_base__io_buffer__compact(wuffs" + + "_base__io_buffer* buf) {\n if (!buf || (buf->meta.ri == 0)) {\n return;\n }\n buf->meta.pos = wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri);\n size_t n = buf->meta.wi - buf->meta.ri;\n if (n != 0) {\n memmove(buf->data.ptr, buf->data.ptr + buf->meta.ri, n);\n }\n buf->meta.wi = n;\n buf->meta.ri = 0;\n}\n\nstatic inline uint64_t //\nwuffs_base__io_buffer__io_position_reader(wuffs_base__io_buffer* buf) {\n return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri) : 0;\n}\n\nstatic inline uint64_t //\nwuffs_base__io_buffer__io_position_writer(wuffs_base__io_buffer* buf) {\n return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.wi) : 0;\n}\n\nstatic inline wuffs_base__io_reader //\nwuffs_base__io_buffer__reader(wuffs_base__io_buffer* buf) {\n wuffs_base__io_reader ret = ((wuffs_base__io_reader){});\n ret.private_impl.buf = buf;\n return ret;\n}\n\nstatic inline wuffs_base__io_writer //\nwuffs_base__io_buffer__writer(wuffs_base__io_buffer* buf) {\n wuffs_base__io_writer ret = ((wuffs_base__io_wr" + + "iter){});\n ret.private_impl.buf = buf;\n return ret;\n}\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__io_buffer__struct::compact() {\n wuffs_base__io_buffer__compact(this);\n}\n\ninline uint64_t //\nwuffs_base__io_buffer__struct::io_position_reader() {\n return wuffs_base__io_buffer__io_position_reader(this);\n}\n\ninline uint64_t //\nwuffs_base__io_buffer__struct::io_position_writer() {\n return wuffs_base__io_buffer__io_position_writer(this);\n}\n\ninline wuffs_base__io_reader //\nwuffs_base__io_buffer__struct::reader() {\n return wuffs_base__io_buffer__reader(this);\n}\n\ninline wuffs_base__io_writer //\nwuffs_base__io_buffer__struct::writer() {\n return wuffs_base__io_buffer__writer(this);\n}\n\n#endif // __cplusplus\n\n" + "" + - "// ---------------- Memory Allocation\n\n// The memory allocation related functions in this section aren't used by Wuffs\n// per se, but they may be helpful to the code that uses Wuffs.\n\n// wuffs_base__malloc_slice_uxx wraps calling a malloc-like function, except\n// that it takes a uint64_t number of elements instead of a size_t size in\n// bytes, and it returns a slice (a pointer and a length) instead of just a\n// pointer.\n//\n// You can pass the C stdlib's malloc as the malloc_func.\n//\n// It returns an empty slice (containing a NULL ptr field) if (num_uxx *\n// sizeof(uintxx_t)) would overflow SIZE_MAX.\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__malloc_slice_u8(void* (*malloc_func)(size_t), uint64_t num_u8) {\n if (malloc_func && (num_u8 <= (SIZE_MAX / sizeof(uint8_t)))) {\n void* p = (*malloc_func)(num_u8 * sizeof(uint8_t));\n if (p) {\n return ((wuffs_base__slice_u8){\n .ptr = p,\n .len = num_u8,\n });\n }\n }\n return ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_bas" + - "e__slice_u16 //\nwuffs_base__malloc_slice_u16(void* (*malloc_func)(size_t), uint64_t num_u16) {\n if (malloc_func && (num_u16 <= (SIZE_MAX / sizeof(uint16_t)))) {\n void* p = (*malloc_func)(num_u16 * sizeof(uint16_t));\n if (p) {\n return ((wuffs_base__slice_u16){\n .ptr = p,\n .len = num_u16,\n });\n }\n }\n return ((wuffs_base__slice_u16){});\n}\n\nstatic inline wuffs_base__slice_u32 //\nwuffs_base__malloc_slice_u32(void* (*malloc_func)(size_t), uint64_t num_u32) {\n if (malloc_func && (num_u32 <= (SIZE_MAX / sizeof(uint32_t)))) {\n void* p = (*malloc_func)(num_u32 * sizeof(uint32_t));\n if (p) {\n return ((wuffs_base__slice_u32){\n .ptr = p,\n .len = num_u32,\n });\n }\n }\n return ((wuffs_base__slice_u32){});\n}\n\nstatic inline wuffs_base__slice_u64 //\nwuffs_base__malloc_slice_u64(void* (*malloc_func)(size_t), uint64_t num_u64) {\n if (malloc_func && (num_u64 <= (SIZE_MAX / sizeof(uint64_t)))) {\n void* p = (*malloc_func)(num_u64 * sizeof(uint64_t)" + - ");\n if (p) {\n return ((wuffs_base__slice_u64){\n .ptr = p,\n .len = num_u64,\n });\n }\n }\n return ((wuffs_base__slice_u64){});\n}\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n" + + "// ---------------- Memory Allocation\n\n// The memory allocation related functions in this section aren't used by Wuffs\n// per se, but they may be helpful to the code that uses Wuffs.\n\n// wuffs_base__malloc_slice_uxx wraps calling a malloc-like function, except\n// that it takes a uint64_t number of elements instead of a size_t size in\n// bytes, and it returns a slice (a pointer and a length) instead of just a\n// pointer.\n//\n// You can pass the C stdlib's malloc as the malloc_func.\n//\n// It returns an empty slice (containing a NULL ptr field) if (num_uxx *\n// sizeof(uintxx_t)) would overflow SIZE_MAX.\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__malloc_slice_u8(void* (*malloc_func)(size_t), uint64_t num_u8) {\n if (malloc_func && (num_u8 <= (SIZE_MAX / sizeof(uint8_t)))) {\n void* p = (*malloc_func)(num_u8 * sizeof(uint8_t));\n if (p) {\n return ((wuffs_base__slice_u8){\n .ptr = (uint8_t*)(p),\n .len = num_u8,\n });\n }\n }\n return ((wuffs_base__slice_u8){});\n}\n\nstatic inli" + + "ne wuffs_base__slice_u16 //\nwuffs_base__malloc_slice_u16(void* (*malloc_func)(size_t), uint64_t num_u16) {\n if (malloc_func && (num_u16 <= (SIZE_MAX / sizeof(uint16_t)))) {\n void* p = (*malloc_func)(num_u16 * sizeof(uint16_t));\n if (p) {\n return ((wuffs_base__slice_u16){\n .ptr = (uint16_t*)(p),\n .len = num_u16,\n });\n }\n }\n return ((wuffs_base__slice_u16){});\n}\n\nstatic inline wuffs_base__slice_u32 //\nwuffs_base__malloc_slice_u32(void* (*malloc_func)(size_t), uint64_t num_u32) {\n if (malloc_func && (num_u32 <= (SIZE_MAX / sizeof(uint32_t)))) {\n void* p = (*malloc_func)(num_u32 * sizeof(uint32_t));\n if (p) {\n return ((wuffs_base__slice_u32){\n .ptr = (uint32_t*)(p),\n .len = num_u32,\n });\n }\n }\n return ((wuffs_base__slice_u32){});\n}\n\nstatic inline wuffs_base__slice_u64 //\nwuffs_base__malloc_slice_u64(void* (*malloc_func)(size_t), uint64_t num_u64) {\n if (malloc_func && (num_u64 <= (SIZE_MAX / sizeof(uint64_t)))) {\n void* p = (*m" + + "alloc_func)(num_u64 * sizeof(uint64_t));\n if (p) {\n return ((wuffs_base__slice_u64){\n .ptr = (uint64_t*)(p),\n .len = num_u64,\n });\n }\n }\n return ((wuffs_base__slice_u64){});\n}\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n" + "" const baseBasePrivateH = "" + @@ -102,14 +102,14 @@ const baseBasePrivateH = "" + "\n}\n\nstatic inline wuffs_base__range_ie_u64 //\nwuffs_base__utility__make_range_ie_u64(wuffs_base__utility* ignored,\n uint64_t min_incl,\n uint64_t max_excl) {\n return ((wuffs_base__range_ie_u64){\n .min_incl = min_incl,\n .max_excl = max_excl,\n });\n}\n\nstatic inline wuffs_base__rect_ii_u32 //\nwuffs_base__utility__make_rect_ii_u32(wuffs_base__utility* ignored,\n uint32_t min_incl_x,\n uint32_t min_incl_y,\n uint32_t max_incl_x,\n uint32_t max_incl_y) {\n return ((wuffs_base__rect_ii_u32){\n .min_incl_x = min_incl_x,\n .min_incl_y = min_incl_y,\n .max_incl_x = max_incl_x,\n .max_incl_y = max_incl_y,\n });\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__utility__make_rect_ie_u32(wuffs_base__utility* ignored,\n uint32_t min_incl" + "_x,\n uint32_t min_incl_y,\n uint32_t max_excl_x,\n uint32_t max_excl_y) {\n return ((wuffs_base__rect_ie_u32){\n .min_incl_x = min_incl_x,\n .min_incl_y = min_incl_y,\n .max_excl_x = max_excl_x,\n .max_excl_y = max_excl_y,\n });\n}\n\n" + "" + - "// ---------------- I/O\n\nstatic inline bool //\nwuffs_base__io_buffer__is_valid(wuffs_base__io_buffer buf) {\n return (buf.ptr || (buf.len == 0)) && (buf.len >= buf.wi) &&\n (buf.wi >= buf.ri);\n}\n\n// TODO: wuffs_base__io_reader__is_eof is no longer used by Wuffs per se, but\n// it might be handy to programs that use Wuffs. Either delete it, or promote\n// it to the public API.\n//\n// If making this function public (i.e. moving it to base-header.h), it also\n// needs to allow NULL (i.e. implicit, callee-calculated) mark/limit.\n\nstatic inline bool //\nwuffs_base__io_reader__is_eof(wuffs_base__io_reader o) {\n wuffs_base__io_buffer* buf = o.private_impl.buf;\n return buf && buf->closed && (buf->ptr + buf->wi == o.private_impl.limit);\n}\n\nstatic inline bool //\nwuffs_base__io_reader__is_valid(wuffs_base__io_reader o) {\n wuffs_base__io_buffer* buf = o.private_impl.buf;\n // Note: if making this function public (i.e. moving it to base-header.h), it\n // also needs to allow NULL (i.e. implicit, callee-calculated)" + - " mark/limit.\n return buf ? ((buf->ptr <= o.private_impl.mark) &&\n (o.private_impl.mark <= o.private_impl.limit) &&\n (o.private_impl.limit <= buf->ptr + buf->len))\n : ((o.private_impl.mark == NULL) &&\n (o.private_impl.limit == NULL));\n}\n\nstatic inline bool //\nwuffs_base__io_writer__is_valid(wuffs_base__io_writer o) {\n wuffs_base__io_buffer* buf = o.private_impl.buf;\n // Note: if making this function public (i.e. moving it to base-header.h), it\n // also needs to allow NULL (i.e. implicit, callee-calculated) mark/limit.\n return buf ? ((buf->ptr <= o.private_impl.mark) &&\n (o.private_impl.mark <= o.private_impl.limit) &&\n (o.private_impl.limit <= buf->ptr + buf->len))\n : ((o.private_impl.mark == NULL) &&\n (o.private_impl.limit == NULL));\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__copy_n_from_history(uint8_t** ptr_ptr,\n uint8_t* start,\n " + - " uint8_t* end,\n uint32_t length,\n uint32_t distance) {\n if (!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_n_from_history 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_n_from_history_fast below.\n //\n // Alternatively, or additionally, have a sloppy_copy_n_from_history 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_n_from_history_fast is like the\n// wuffs_base__io_writer__copy_n_from_history function above, but has stronger\n// pre-conditions. The caller needs to prove that:\n// - distance > 0\n// - distance <= (*ptr_ptr - start)\n// - length <= (end - *ptr_ptr)\nstatic inline uint32_t //\nwuffs_base__io_writer__copy_n_from_history_fast(uint8_t** ptr_ptr,\n uint8_t* start,\n uint8_t* end,\n uint32_t length,\n uint32_t distance) {\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++ = *s" + - "tart++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__copy_n_from_reader(uint8_t** ptr_ioptr_w,\n uint8_t* iobounds1_w,\n uint32_t length,\n uint8_t** ptr_ioptr_r,\n uint8_t* iobounds1_r) {\n uint8_t* ioptr_w = *ptr_ioptr_w;\n size_t n = length;\n if (n > ((size_t)(iobounds1_w - ioptr_w))) {\n n = iobounds1_w - ioptr_w;\n }\n uint8_t* ioptr_r = *ptr_ioptr_r;\n if (n > ((size_t)(iobounds1_r - ioptr_r))) {\n n = iobounds1_r - ioptr_r;\n }\n if (n > 0) {\n memmove(ioptr_w, ioptr_r, n);\n *ptr_ioptr_w += n;\n *ptr_ioptr_r += n;\n }\n return n;\n}\n\nstatic inline uint64_t //\nwuffs_base__io_writer__copy_from_slice(uint8_t** ptr_ioptr_w,\n uint8_t* iobounds1_w,\n wuffs_base__slice_u8 src" + - ") {\n uint8_t* ioptr_w = *ptr_ioptr_w;\n size_t n = src.len;\n if (n > ((size_t)(iobounds1_w - ioptr_w))) {\n n = iobounds1_w - ioptr_w;\n }\n if (n > 0) {\n memmove(ioptr_w, src.ptr, n);\n *ptr_ioptr_w += n;\n }\n return n;\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__copy_n_from_slice(uint8_t** ptr_ioptr_w,\n uint8_t* iobounds1_w,\n uint32_t length,\n wuffs_base__slice_u8 src) {\n uint8_t* ioptr_w = *ptr_ioptr_w;\n size_t n = src.len;\n if (n > length) {\n n = length;\n }\n if (n > ((size_t)(iobounds1_w - ioptr_w))) {\n n = iobounds1_w - ioptr_w;\n }\n if (n > 0) {\n memmove(ioptr_w, src.ptr, n);\n *ptr_ioptr_w += n;\n }\n return n;\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_reader__set_limit(wuffs_base__io_reader* o,\n uint8_t* ioptr_r,\n uint64_t limit) {\n if (o && (((size_t)(o->private_im" + - "pl.limit - ioptr_r)) > limit)) {\n o->private_impl.limit = ioptr_r + limit;\n }\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_reader__set_mark(wuffs_base__io_reader* o, uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_writer__set(wuffs_base__io_writer* o,\n wuffs_base__io_buffer* b,\n uint8_t** ioptr1_ptr,\n uint8_t** ioptr2_ptr,\n wuffs_base__slice_u8 s) {\n b->ptr = s.ptr;\n b->len = s.len;\n b->wi = 0;\n b->ri = 0;\n b->closed = false;\n o->private_impl.buf = b;\n o->private_impl.mark = s.ptr;\n o->private_impl.limit = s.ptr + s.len;\n *ioptr1_ptr = s.ptr;\n *ioptr2_ptr = s.ptr + s.len;\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_writer__set_mark(wuffs_base__io_writer* o, uint8_t* mark) {\n o->p" + - "rivate_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n\n#endif // WUFFS_INCLUDE_GUARD__BASE_PRIVATE\n" + + "// ---------------- I/O\n\nstatic inline bool //\nwuffs_base__io_buffer__is_valid(wuffs_base__io_buffer buf) {\n return (buf.data.ptr || (buf.data.len == 0)) &&\n (buf.data.len >= buf.meta.wi) && (buf.meta.wi >= buf.meta.ri);\n}\n\n// TODO: wuffs_base__io_reader__is_eof is no longer used by Wuffs per se, but\n// it might be handy to programs that use Wuffs. Either delete it, or promote\n// it to the public API.\n//\n// If making this function public (i.e. moving it to base-header.h), it also\n// needs to allow NULL (i.e. implicit, callee-calculated) mark/limit.\n\nstatic inline bool //\nwuffs_base__io_reader__is_eof(wuffs_base__io_reader o) {\n wuffs_base__io_buffer* buf = o.private_impl.buf;\n return buf && buf->meta.closed &&\n (buf->data.ptr + buf->meta.wi == o.private_impl.limit);\n}\n\nstatic inline bool //\nwuffs_base__io_reader__is_valid(wuffs_base__io_reader o) {\n wuffs_base__io_buffer* buf = o.private_impl.buf;\n // Note: if making this function public (i.e. moving it to base-header.h), it\n // also " + + "needs to allow NULL (i.e. implicit, callee-calculated) mark/limit.\n return buf ? ((buf->data.ptr <= o.private_impl.mark) &&\n (o.private_impl.mark <= o.private_impl.limit) &&\n (o.private_impl.limit <= buf->data.ptr + buf->data.len))\n : ((o.private_impl.mark == NULL) &&\n (o.private_impl.limit == NULL));\n}\n\nstatic inline bool //\nwuffs_base__io_writer__is_valid(wuffs_base__io_writer o) {\n wuffs_base__io_buffer* buf = o.private_impl.buf;\n // Note: if making this function public (i.e. moving it to base-header.h), it\n // also needs to allow NULL (i.e. implicit, callee-calculated) mark/limit.\n return buf ? ((buf->data.ptr <= o.private_impl.mark) &&\n (o.private_impl.mark <= o.private_impl.limit) &&\n (o.private_impl.limit <= buf->data.ptr + buf->data.len))\n : ((o.private_impl.mark == NULL) &&\n (o.private_impl.limit == NULL));\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__copy_n_from_history(uin" + + "t8_t** ptr_ptr,\n uint8_t* start,\n uint8_t* end,\n uint32_t length,\n uint32_t distance) {\n if (!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_n_from_history 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_n_from_history_fast below.\n //\n // Alternatively, or additionally, ha" + + "ve a sloppy_copy_n_from_history 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_n_from_history_fast is like the\n// wuffs_base__io_writer__copy_n_from_history function above, but has stronger\n// pre-conditions. The caller needs to prove that:\n// - distance > 0\n// - distance <= (*ptr_ptr - start)\n// - length <= (end - *ptr_ptr)\nstatic inline uint32_t //\nwuffs_base__io_writer__copy_n_from_history_fast(uint8_t** ptr_ptr,\n uint8_t* start,\n uint8_t* end,\n uint32_t length,\n uint32_t distance) {\n uint8_t* ptr = *ptr_ptr;\n start = ptr - distance;\n uint32_t n = length;\n fo" + + "r (; 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 //\nwuffs_base__io_writer__copy_n_from_reader(uint8_t** ptr_ioptr_w,\n uint8_t* iobounds1_w,\n uint32_t length,\n uint8_t** ptr_ioptr_r,\n uint8_t* iobounds1_r) {\n uint8_t* ioptr_w = *ptr_ioptr_w;\n size_t n = length;\n if (n > ((size_t)(iobounds1_w - ioptr_w))) {\n n = iobounds1_w - ioptr_w;\n }\n uint8_t* ioptr_r = *ptr_ioptr_r;\n if (n > ((size_t)(iobounds1_r - ioptr_r))) {\n n = iobounds1_r - ioptr_r;\n }\n if (n > 0) {\n memmove(ioptr_w, ioptr_r, n);\n *ptr_ioptr_w += n;\n *ptr_ioptr_r += n;\n }\n return n;\n}\n\nstatic inline uint64_t //\nwuffs_base__io_writer__copy_from_slice(uint8_t** ptr_ioptr_w,\n u" + + "int8_t* iobounds1_w,\n wuffs_base__slice_u8 src) {\n uint8_t* ioptr_w = *ptr_ioptr_w;\n size_t n = src.len;\n if (n > ((size_t)(iobounds1_w - ioptr_w))) {\n n = iobounds1_w - ioptr_w;\n }\n if (n > 0) {\n memmove(ioptr_w, src.ptr, n);\n *ptr_ioptr_w += n;\n }\n return n;\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__copy_n_from_slice(uint8_t** ptr_ioptr_w,\n uint8_t* iobounds1_w,\n uint32_t length,\n wuffs_base__slice_u8 src) {\n uint8_t* ioptr_w = *ptr_ioptr_w;\n size_t n = src.len;\n if (n > length) {\n n = length;\n }\n if (n > ((size_t)(iobounds1_w - ioptr_w))) {\n n = iobounds1_w - ioptr_w;\n }\n if (n > 0) {\n memmove(ioptr_w, src.ptr, n);\n *ptr_ioptr_w += n;\n }\n return n;\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_reader__set_limit(wuffs_base__io_reader* o,\n uint8_t* ioptr_r,\n " + + " uint64_t limit) {\n if (o && (((size_t)(o->private_impl.limit - ioptr_r)) > limit)) {\n o->private_impl.limit = ioptr_r + limit;\n }\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_reader__set_mark(wuffs_base__io_reader* o, uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_writer__set(wuffs_base__io_writer* o,\n wuffs_base__io_buffer* b,\n uint8_t** ioptr1_ptr,\n uint8_t** ioptr2_ptr,\n wuffs_base__slice_u8 s) {\n b->data.ptr = s.ptr;\n b->data.len = s.len;\n b->meta.wi = 0;\n b->meta.ri = 0;\n // TODO: set b->meta.pos.\n b->meta.closed = false;\n o->private_impl.buf = b;\n o->private_impl.mark = s.ptr;\n o->private_impl.limit = s.ptr + s.len;\n *ioptr1_ptr = s.ptr;\n *ioptr2_ptr = s.ptr + s.len;\n return ((wuffs_base__empty_st" + + "ruct){});\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_writer__set_mark(wuffs_base__io_writer* o, uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n\n#endif // WUFFS_INCLUDE_GUARD__BASE_PRIVATE\n" + "" const baseBaseImplC = "" + diff --git a/cmd/wuffs-c/internal/cgen/var.go b/cmd/wuffs-c/internal/cgen/var.go index b6d8259f..01c3eba6 100644 --- a/cmd/wuffs-c/internal/cgen/var.go +++ b/cmd/wuffs-c/internal/cgen/var.go @@ -87,7 +87,7 @@ func (g *gen) writeLoadDerivedVar(b *buffer, hack string, prefix string, name t. } // TODO: also remove this hack. if hack == "w" { - b.printf("%s%sw = %sw.ptr + %sw.wi;\n", iopPrefix, vPrefix, uPrefix, uPrefix) + b.printf("%s%sw = %sw.data.ptr + %sw.meta.wi;\n", iopPrefix, vPrefix, uPrefix, uPrefix) return nil } @@ -102,9 +102,9 @@ func (g *gen) writeLoadDerivedVar(b *buffer, hack string, prefix string, name t. } preName := prefix + name.Str(g.tm) - i0, i1 := "ri", "wi" + i0, i1 := "meta.ri", "meta.wi" if typ.QID()[1] == t.IDIOWriter { - i0, i1 = "wi", "len" + i0, i1 = "meta.wi", "data.len" } if header { @@ -117,18 +117,18 @@ func (g *gen) writeLoadDerivedVar(b *buffer, hack string, prefix string, name t. b.printf("if (%s.private_impl.buf) {", preName) - b.printf("%s%s = %s.private_impl.buf->ptr + %s.private_impl.buf->%s;", + b.printf("%s%s = %s.private_impl.buf->data.ptr + %s.private_impl.buf->%s;", iopPrefix, preName, preName, preName, i0) if header { b.printf("if (!%s.private_impl.mark) {", preName) b.printf("%s.private_impl.mark = %s%s;", preName, iopPrefix, preName) - b.printf("%s.private_impl.limit = %s.private_impl.buf->ptr + %s.private_impl.buf->%s;", + b.printf("%s.private_impl.limit = %s.private_impl.buf->data.ptr + %s.private_impl.buf->%s;", preName, preName, preName, i1) b.printf("}\n") if typ.QID()[1] == t.IDIOWriter { - b.printf("if (%s.private_impl.buf->closed) {", preName) + b.printf("if (%s.private_impl.buf->meta.closed) {", preName) b.printf("%s.private_impl.limit = %s%s;", preName, iopPrefix, preName) b.printf("}\n") } @@ -149,7 +149,7 @@ func (g *gen) writeSaveDerivedVar(b *buffer, hack string, prefix string, name t. } // TODO: also remove this hack. if hack == "w" { - b.printf("%sw.wi = %s%sw - %sw.ptr;\n", uPrefix, iopPrefix, vPrefix, uPrefix) + b.printf("%sw.meta.wi = %s%sw - %sw.data.ptr;\n", uPrefix, iopPrefix, vPrefix, uPrefix) return nil } @@ -170,7 +170,7 @@ func (g *gen) writeSaveDerivedVar(b *buffer, hack string, prefix string, name t. } b.printf("if (%s.private_impl.buf) {", preName) - b.printf("%s.private_impl.buf->%s = %s%s - %s.private_impl.buf->ptr;", + b.printf("%s.private_impl.buf->meta.%s = %s%s - %s.private_impl.buf->data.ptr;", preName, i0, iopPrefix, preName, preName) b.printf("}\n") return nil diff --git a/example/gifplayer/gifplayer.c b/example/gifplayer/gifplayer.c index d5673573..239f9131 100644 --- a/example/gifplayer/gifplayer.c +++ b/example/gifplayer/gifplayer.c @@ -293,12 +293,16 @@ const char* play() { } wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ - .ptr = src_buffer, - .len = src_len, - .wi = src_len, - .ri = 0, - .pos = 0, - .closed = true, + .data = ((wuffs_base__slice_u8){ + .ptr = src_buffer, + .len = src_len, + }), + .meta = ((wuffs_base__io_buffer_meta){ + .wi = src_len, + .ri = 0, + .pos = 0, + .closed = true, + }), }); wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); diff --git a/example/library/library.c b/example/library/library.c index 310c15e7..6259c7a2 100644 --- a/example/library/library.c +++ b/example/library/library.c @@ -48,14 +48,23 @@ static void ignore_return_value(int ignored) {} static const char* decode() { uint8_t dst_buffer[DST_BUFFER_SIZE]; - wuffs_base__io_buffer dst = - ((wuffs_base__io_buffer){.ptr = dst_buffer, .len = DST_BUFFER_SIZE}); + wuffs_base__io_buffer dst = ((wuffs_base__io_buffer){ + .data = ((wuffs_base__slice_u8){ + .ptr = dst_buffer, + .len = DST_BUFFER_SIZE, + }), + }); wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ - .ptr = lgtm_ptr, - .len = lgtm_len, - .wi = lgtm_len, - .pos = 0, - .closed = true, + .data = ((wuffs_base__slice_u8){ + .ptr = lgtm_ptr, + .len = lgtm_len, + }), + .meta = ((wuffs_base__io_buffer_meta){ + .wi = lgtm_len, + .ri = 0, + .pos = 0, + .closed = true, + }), }); wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(&dst); wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); @@ -70,7 +79,7 @@ static const char* decode() { if (z) { return z; } - ignore_return_value(write(1, dst.ptr, dst.wi)); + ignore_return_value(write(1, dst.data.ptr, dst.meta.wi)); return NULL; } diff --git a/example/zcat/zcat.c b/example/zcat/zcat.c index badfe498..8af3069f 100644 --- a/example/zcat/zcat.c +++ b/example/zcat/zcat.c @@ -81,23 +81,32 @@ static const char* decode() { return z; } - wuffs_base__io_buffer dst = - ((wuffs_base__io_buffer){.ptr = dst_buffer, .len = DST_BUFFER_SIZE}); - wuffs_base__io_buffer src = - ((wuffs_base__io_buffer){.ptr = src_buffer, .len = SRC_BUFFER_SIZE}); + wuffs_base__io_buffer dst = ((wuffs_base__io_buffer){ + .data = ((wuffs_base__slice_u8){ + .ptr = dst_buffer, + .len = DST_BUFFER_SIZE, + }), + }); + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = ((wuffs_base__slice_u8){ + .ptr = src_buffer, + .len = SRC_BUFFER_SIZE, + }), + }); while (true) { const int stdin_fd = 0; - ssize_t n = read(stdin_fd, src.ptr + src.wi, src.len - src.wi); + ssize_t n = + read(stdin_fd, src.data.ptr + src.meta.wi, src.data.len - src.meta.wi); if (n < 0) { if (errno != EINTR) { return strerror(errno); } continue; } - src.wi += n; + src.meta.wi += n; if (n == 0) { - src.closed = true; + src.meta.closed = true; } while (true) { @@ -105,11 +114,11 @@ static const char* decode() { wuffs_gzip__decoder__decode(&dec, wuffs_base__io_buffer__writer(&dst), wuffs_base__io_buffer__reader(&src)); - if (dst.wi) { + if (dst.meta.wi) { // TODO: handle EINTR and other write errors; see "man 2 write". const int stdout_fd = 1; - ignore_return_value(write(stdout_fd, dst_buffer, dst.wi)); - dst.ri = dst.wi; + ignore_return_value(write(stdout_fd, dst_buffer, dst.meta.wi)); + dst.meta.ri = dst.meta.wi; wuffs_base__io_buffer__compact(&dst); } @@ -123,7 +132,7 @@ static const char* decode() { } wuffs_base__io_buffer__compact(&src); - if (src.wi == src.len) { + if (src.meta.wi == src.data.len) { return "internal error: no I/O progress possible"; } } diff --git a/fuzz/c/fuzzlib/fuzzlib.c b/fuzz/c/fuzzlib/fuzzlib.c index 761c289d..a74c55ce 100644 --- a/fuzz/c/fuzzlib/fuzzlib.c +++ b/fuzz/c/fuzzlib/fuzzlib.c @@ -41,11 +41,18 @@ static const char* llvmFuzzerTestOneInput(const uint8_t* data, size_t size) { hash ^= hash >> 11; hash += hash << 15; - wuffs_base__io_buffer src = {.ptr = (uint8_t*)(data), - .len = size, - .wi = size, - .ri = 0, - .closed = true}; + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = ((wuffs_base__slice_u8){ + .ptr = (uint8_t*)(data), + .len = size, + }), + .meta = ((wuffs_base__io_buffer_meta){ + .wi = size, + .ri = 0, + .pos = 0, + .closed = true, + }), + }); return fuzz(wuffs_base__io_buffer__reader(&src), hash); } diff --git a/fuzz/c/std/zlib_fuzzer.c b/fuzz/c/std/zlib_fuzzer.c index 2e34a166..bb8e8d40 100644 --- a/fuzz/c/std/zlib_fuzzer.c +++ b/fuzz/c/std/zlib_fuzzer.c @@ -61,16 +61,21 @@ const char* fuzz(wuffs_base__io_reader src_reader, uint32_t hash) { const size_t dstbuf_size = 65536; uint8_t dstbuf[dstbuf_size]; - wuffs_base__io_buffer dst = {.ptr = dstbuf, .len = dstbuf_size}; + wuffs_base__io_buffer dst = ((wuffs_base__io_buffer){ + .data = ((wuffs_base__slice_u8){ + .ptr = dstbuf, + .len = dstbuf_size, + }), + }); wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(&dst); while (true) { - dst.wi = 0; + dst.meta.wi = 0; z = wuffs_zlib__decoder__decode(&dec, dst_writer, src_reader); if (z != wuffs_base__suspension__short_write) { break; } - if (dst.wi == 0) { + if (dst.meta.wi == 0) { fprintf(stderr, "wuffs_zlib__decoder__decode made no progress\n"); intentional_segfault(); } diff --git a/release/c/wuffs-unsupported-snapshot.h b/release/c/wuffs-unsupported-snapshot.h index 4ba35be1..47b97e83 100644 --- a/release/c/wuffs-unsupported-snapshot.h +++ b/release/c/wuffs-unsupported-snapshot.h @@ -1081,18 +1081,22 @@ typedef struct { } private_impl; } wuffs_base__io_writer; -// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length), plus -// additional indexes into that buffer, plus a buffer position and an opened / -// closed flag. -// -// A value with all fields NULL or zero is a valid, empty buffer. -typedef struct wuffs_base__io_buffer__struct { - uint8_t* ptr; // Pointer. - size_t len; // Length. +// wuffs_base__io_buffer_meta is the metadata for a wuffs_base__io_buffer's +// data. +typedef struct { size_t wi; // Write index. Invariant: wi <= len. size_t ri; // Read index. Invariant: ri <= wi. uint64_t pos; // Position of the buffer start relative to the stream start. bool closed; // No further writes are expected. +} wuffs_base__io_buffer_meta; + +// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length) plus +// additional metadata. +// +// A value with all fields zero is a valid, empty buffer. +typedef struct wuffs_base__io_buffer__struct { + wuffs_base__slice_u8 data; + wuffs_base__io_buffer_meta meta; #ifdef __cplusplus inline void compact(); @@ -1108,26 +1112,26 @@ typedef struct wuffs_base__io_buffer__struct { // start of the buffer. static inline void // wuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) { - if (!buf || (buf->ri == 0)) { + if (!buf || (buf->meta.ri == 0)) { return; } - buf->pos = wuffs_base__u64__sat_add(buf->pos, buf->ri); - size_t n = buf->wi - buf->ri; + buf->meta.pos = wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri); + size_t n = buf->meta.wi - buf->meta.ri; if (n != 0) { - memmove(buf->ptr, buf->ptr + buf->ri, n); + memmove(buf->data.ptr, buf->data.ptr + buf->meta.ri, n); } - buf->wi = n; - buf->ri = 0; + buf->meta.wi = n; + buf->meta.ri = 0; } static inline uint64_t // wuffs_base__io_buffer__io_position_reader(wuffs_base__io_buffer* buf) { - return buf ? wuffs_base__u64__sat_add(buf->pos, buf->ri) : 0; + return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri) : 0; } static inline uint64_t // wuffs_base__io_buffer__io_position_writer(wuffs_base__io_buffer* buf) { - return buf ? wuffs_base__u64__sat_add(buf->pos, buf->wi) : 0; + return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.wi) : 0; } static inline wuffs_base__io_reader // @@ -1194,7 +1198,7 @@ wuffs_base__malloc_slice_u8(void* (*malloc_func)(size_t), uint64_t num_u8) { void* p = (*malloc_func)(num_u8 * sizeof(uint8_t)); if (p) { return ((wuffs_base__slice_u8){ - .ptr = p, + .ptr = (uint8_t*)(p), .len = num_u8, }); } @@ -1208,7 +1212,7 @@ wuffs_base__malloc_slice_u16(void* (*malloc_func)(size_t), uint64_t num_u16) { void* p = (*malloc_func)(num_u16 * sizeof(uint16_t)); if (p) { return ((wuffs_base__slice_u16){ - .ptr = p, + .ptr = (uint16_t*)(p), .len = num_u16, }); } @@ -1222,7 +1226,7 @@ wuffs_base__malloc_slice_u32(void* (*malloc_func)(size_t), uint64_t num_u32) { void* p = (*malloc_func)(num_u32 * sizeof(uint32_t)); if (p) { return ((wuffs_base__slice_u32){ - .ptr = p, + .ptr = (uint32_t*)(p), .len = num_u32, }); } @@ -1236,7 +1240,7 @@ wuffs_base__malloc_slice_u64(void* (*malloc_func)(size_t), uint64_t num_u64) { void* p = (*malloc_func)(num_u64 * sizeof(uint64_t)); if (p) { return ((wuffs_base__slice_u64){ - .ptr = p, + .ptr = (uint64_t*)(p), .len = num_u64, }); } @@ -3573,8 +3577,8 @@ wuffs_base__utility__make_rect_ie_u32(wuffs_base__utility* ignored, static inline bool // wuffs_base__io_buffer__is_valid(wuffs_base__io_buffer buf) { - return (buf.ptr || (buf.len == 0)) && (buf.len >= buf.wi) && - (buf.wi >= buf.ri); + return (buf.data.ptr || (buf.data.len == 0)) && + (buf.data.len >= buf.meta.wi) && (buf.meta.wi >= buf.meta.ri); } // TODO: wuffs_base__io_reader__is_eof is no longer used by Wuffs per se, but @@ -3587,7 +3591,8 @@ wuffs_base__io_buffer__is_valid(wuffs_base__io_buffer buf) { static inline bool // wuffs_base__io_reader__is_eof(wuffs_base__io_reader o) { wuffs_base__io_buffer* buf = o.private_impl.buf; - return buf && buf->closed && (buf->ptr + buf->wi == o.private_impl.limit); + return buf && buf->meta.closed && + (buf->data.ptr + buf->meta.wi == o.private_impl.limit); } static inline bool // @@ -3595,9 +3600,9 @@ wuffs_base__io_reader__is_valid(wuffs_base__io_reader o) { wuffs_base__io_buffer* buf = o.private_impl.buf; // Note: if making this function public (i.e. moving it to base-header.h), it // also needs to allow NULL (i.e. implicit, callee-calculated) mark/limit. - return buf ? ((buf->ptr <= o.private_impl.mark) && + return buf ? ((buf->data.ptr <= o.private_impl.mark) && (o.private_impl.mark <= o.private_impl.limit) && - (o.private_impl.limit <= buf->ptr + buf->len)) + (o.private_impl.limit <= buf->data.ptr + buf->data.len)) : ((o.private_impl.mark == NULL) && (o.private_impl.limit == NULL)); } @@ -3607,9 +3612,9 @@ wuffs_base__io_writer__is_valid(wuffs_base__io_writer o) { wuffs_base__io_buffer* buf = o.private_impl.buf; // Note: if making this function public (i.e. moving it to base-header.h), it // also needs to allow NULL (i.e. implicit, callee-calculated) mark/limit. - return buf ? ((buf->ptr <= o.private_impl.mark) && + return buf ? ((buf->data.ptr <= o.private_impl.mark) && (o.private_impl.mark <= o.private_impl.limit) && - (o.private_impl.limit <= buf->ptr + buf->len)) + (o.private_impl.limit <= buf->data.ptr + buf->data.len)) : ((o.private_impl.mark == NULL) && (o.private_impl.limit == NULL)); } @@ -3764,11 +3769,12 @@ wuffs_base__io_writer__set(wuffs_base__io_writer* o, uint8_t** ioptr1_ptr, uint8_t** ioptr2_ptr, wuffs_base__slice_u8 s) { - b->ptr = s.ptr; - b->len = s.len; - b->wi = 0; - b->ri = 0; - b->closed = false; + b->data.ptr = s.ptr; + b->data.len = s.len; + b->meta.wi = 0; + b->meta.ri = 0; + // TODO: set b->meta.pos. + b->meta.closed = false; o->private_impl.buf = b; o->private_impl.mark = s.ptr; o->private_impl.limit = s.ptr + s.len; @@ -4649,13 +4655,14 @@ wuffs_deflate__decoder__decode(wuffs_deflate__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_dst); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_dst); if (a_dst.private_impl.buf) { - iop_a_dst = a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi; + iop_a_dst = + a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->meta.wi; if (!a_dst.private_impl.mark) { a_dst.private_impl.mark = iop_a_dst; a_dst.private_impl.limit = - a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->len; + a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->data.len; } - if (a_dst.private_impl.buf->closed) { + if (a_dst.private_impl.buf->meta.closed) { a_dst.private_impl.limit = iop_a_dst; } io0_a_dst = a_dst.private_impl.mark; @@ -4678,12 +4685,14 @@ wuffs_deflate__decoder__decode(wuffs_deflate__decoder* self, wuffs_base__io_writer__set_mark(&a_dst, iop_a_dst); { if (a_dst.private_impl.buf) { - a_dst.private_impl.buf->wi = iop_a_dst - a_dst.private_impl.buf->ptr; + a_dst.private_impl.buf->meta.wi = + iop_a_dst - a_dst.private_impl.buf->data.ptr; } wuffs_base__status t_0 = wuffs_deflate__decoder__decode_blocks(self, a_dst, a_src); if (a_dst.private_impl.buf) { - iop_a_dst = a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi; + iop_a_dst = a_dst.private_impl.buf->data.ptr + + a_dst.private_impl.buf->meta.wi; } v_z = t_0; } @@ -4759,7 +4768,8 @@ suspend: goto exit; exit: if (a_dst.private_impl.buf) { - a_dst.private_impl.buf->wi = iop_a_dst - a_dst.private_impl.buf->ptr; + a_dst.private_impl.buf->meta.wi = + iop_a_dst - a_dst.private_impl.buf->data.ptr; } if (wuffs_base__status__is_error(status)) { @@ -4785,11 +4795,12 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_src); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; if (!a_src.private_impl.mark) { a_src.private_impl.mark = iop_a_src; a_src.private_impl.limit = - a_src.private_impl.buf->ptr + a_src.private_impl.buf->wi; + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.wi; } io0_a_src = a_src.private_impl.mark; io1_a_src = a_src.private_impl.limit; @@ -4828,12 +4839,14 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self, if (v_type == 0) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } status = wuffs_deflate__decoder__decode_uncompressed(self, a_dst, a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = a_src.private_impl.buf->data.ptr + + a_src.private_impl.buf->meta.ri; } if (status) { goto suspend; @@ -4848,11 +4861,13 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self, } else if (v_type == 2) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } status = wuffs_deflate__decoder__init_dynamic_huffman(self, a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = a_src.private_impl.buf->data.ptr + + a_src.private_impl.buf->meta.ri; } if (status) { goto suspend; @@ -4864,11 +4879,13 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self, self->private_impl.f_end_of_block = false; WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } status = wuffs_deflate__decoder__decode_huffman_fast(self, a_dst, a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; } if (status) { goto suspend; @@ -4878,11 +4895,13 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self, } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } status = wuffs_deflate__decoder__decode_huffman_slow(self, a_dst, a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; } if (status) { goto suspend; @@ -4910,7 +4929,8 @@ suspend: goto exit; exit: if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } return status; @@ -4933,13 +4953,14 @@ wuffs_deflate__decoder__decode_uncompressed(wuffs_deflate__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_dst); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_dst); if (a_dst.private_impl.buf) { - iop_a_dst = a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi; + iop_a_dst = + a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->meta.wi; if (!a_dst.private_impl.mark) { a_dst.private_impl.mark = iop_a_dst; a_dst.private_impl.limit = - a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->len; + a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->data.len; } - if (a_dst.private_impl.buf->closed) { + if (a_dst.private_impl.buf->meta.closed) { a_dst.private_impl.limit = iop_a_dst; } io0_a_dst = a_dst.private_impl.mark; @@ -4951,11 +4972,12 @@ wuffs_deflate__decoder__decode_uncompressed(wuffs_deflate__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_src); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; if (!a_src.private_impl.mark) { a_src.private_impl.mark = iop_a_src; a_src.private_impl.limit = - a_src.private_impl.buf->ptr + a_src.private_impl.buf->wi; + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.wi; } io0_a_src = a_src.private_impl.mark; io1_a_src = a_src.private_impl.limit; @@ -5046,10 +5068,12 @@ suspend: goto exit; exit: if (a_dst.private_impl.buf) { - a_dst.private_impl.buf->wi = iop_a_dst - a_dst.private_impl.buf->ptr; + a_dst.private_impl.buf->meta.wi = + iop_a_dst - a_dst.private_impl.buf->data.ptr; } if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } return status; @@ -5146,11 +5170,12 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_src); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; if (!a_src.private_impl.mark) { a_src.private_impl.mark = iop_a_src; a_src.private_impl.limit = - a_src.private_impl.buf->ptr + a_src.private_impl.buf->wi; + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.wi; } io0_a_src = a_src.private_impl.mark; io1_a_src = a_src.private_impl.limit; @@ -5370,7 +5395,8 @@ suspend: goto exit; exit: if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } return status; @@ -5685,13 +5711,14 @@ wuffs_deflate__decoder__decode_huffman_fast(wuffs_deflate__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_dst); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_dst); if (a_dst.private_impl.buf) { - iop_a_dst = a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi; + iop_a_dst = + a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->meta.wi; if (!a_dst.private_impl.mark) { a_dst.private_impl.mark = iop_a_dst; a_dst.private_impl.limit = - a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->len; + a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->data.len; } - if (a_dst.private_impl.buf->closed) { + if (a_dst.private_impl.buf->meta.closed) { a_dst.private_impl.limit = iop_a_dst; } io0_a_dst = a_dst.private_impl.mark; @@ -5703,11 +5730,12 @@ wuffs_deflate__decoder__decode_huffman_fast(wuffs_deflate__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_src); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; if (!a_src.private_impl.mark) { a_src.private_impl.mark = iop_a_src; a_src.private_impl.limit = - a_src.private_impl.buf->ptr + a_src.private_impl.buf->wi; + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.wi; } io0_a_src = a_src.private_impl.mark; io1_a_src = a_src.private_impl.limit; @@ -5984,10 +6012,12 @@ label_0_break:; goto exit; exit: if (a_dst.private_impl.buf) { - a_dst.private_impl.buf->wi = iop_a_dst - a_dst.private_impl.buf->ptr; + a_dst.private_impl.buf->meta.wi = + iop_a_dst - a_dst.private_impl.buf->data.ptr; } if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } return status; @@ -6021,13 +6051,14 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_dst); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_dst); if (a_dst.private_impl.buf) { - iop_a_dst = a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi; + iop_a_dst = + a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->meta.wi; if (!a_dst.private_impl.mark) { a_dst.private_impl.mark = iop_a_dst; a_dst.private_impl.limit = - a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->len; + a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->data.len; } - if (a_dst.private_impl.buf->closed) { + if (a_dst.private_impl.buf->meta.closed) { a_dst.private_impl.limit = iop_a_dst; } io0_a_dst = a_dst.private_impl.mark; @@ -6039,11 +6070,12 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_src); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; if (!a_src.private_impl.mark) { a_src.private_impl.mark = iop_a_src; a_src.private_impl.limit = - a_src.private_impl.buf->ptr + a_src.private_impl.buf->wi; + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.wi; } io0_a_src = a_src.private_impl.mark; io1_a_src = a_src.private_impl.limit; @@ -6408,10 +6440,12 @@ suspend: goto exit; exit: if (a_dst.private_impl.buf) { - a_dst.private_impl.buf->wi = iop_a_dst - a_dst.private_impl.buf->ptr; + a_dst.private_impl.buf->meta.wi = + iop_a_dst - a_dst.private_impl.buf->data.ptr; } if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } return status; @@ -6817,11 +6851,12 @@ wuffs_gif__decoder__skip_frame(wuffs_gif__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_src); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; if (!a_src.private_impl.mark) { a_src.private_impl.mark = iop_a_src; a_src.private_impl.limit = - a_src.private_impl.buf->ptr + a_src.private_impl.buf->wi; + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.wi; } io0_a_src = a_src.private_impl.mark; io1_a_src = a_src.private_impl.limit; @@ -6870,11 +6905,13 @@ wuffs_gif__decoder__skip_frame(wuffs_gif__decoder* self, } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } status = wuffs_gif__decoder__skip_blocks(self, a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; } if (status) { goto suspend; @@ -6898,7 +6935,8 @@ suspend: goto exit; exit: if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } return status; @@ -7000,11 +7038,12 @@ wuffs_gif__decoder__decode_up_to_id_part1(wuffs_gif__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_src); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; if (!a_src.private_impl.mark) { a_src.private_impl.mark = iop_a_src; a_src.private_impl.limit = - a_src.private_impl.buf->ptr + a_src.private_impl.buf->wi; + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.wi; } io0_a_src = a_src.private_impl.mark; io1_a_src = a_src.private_impl.limit; @@ -7021,15 +7060,16 @@ wuffs_gif__decoder__decode_up_to_id_part1(wuffs_gif__decoder* self, if (!self->private_impl.f_restarted) { self->private_impl.f_frame_config_io_position = - (a_src.private_impl.buf ? wuffs_base__u64__sat_add( - a_src.private_impl.buf->pos, - iop_a_src - a_src.private_impl.buf->ptr) - : 0); + (a_src.private_impl.buf + ? wuffs_base__u64__sat_add( + a_src.private_impl.buf->meta.pos, + iop_a_src - a_src.private_impl.buf->data.ptr) + : 0); } else if (self->private_impl.f_frame_config_io_position != (a_src.private_impl.buf ? wuffs_base__u64__sat_add( - a_src.private_impl.buf->pos, - iop_a_src - a_src.private_impl.buf->ptr) + a_src.private_impl.buf->meta.pos, + iop_a_src - a_src.private_impl.buf->data.ptr) : 0)) { status = wuffs_base__error__bad_restart; goto exit; @@ -7049,11 +7089,13 @@ wuffs_gif__decoder__decode_up_to_id_part1(wuffs_gif__decoder* self, if (v_block_type == 33) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } status = wuffs_gif__decoder__decode_extension(self, a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = a_src.private_impl.buf->data.ptr + + a_src.private_impl.buf->meta.ri; } if (status) { goto suspend; @@ -7061,11 +7103,13 @@ wuffs_gif__decoder__decode_up_to_id_part1(wuffs_gif__decoder* self, } else if (v_block_type == 44) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } status = wuffs_gif__decoder__decode_id_part0(self, a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = a_src.private_impl.buf->data.ptr + + a_src.private_impl.buf->meta.ri; } if (status) { goto suspend; @@ -7096,7 +7140,8 @@ suspend: goto exit; exit: if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } return status; @@ -7118,11 +7163,12 @@ wuffs_gif__decoder__decode_header(wuffs_gif__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_src); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; if (!a_src.private_impl.mark) { a_src.private_impl.mark = iop_a_src; a_src.private_impl.limit = - a_src.private_impl.buf->ptr + a_src.private_impl.buf->wi; + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.wi; } io0_a_src = a_src.private_impl.mark; io1_a_src = a_src.private_impl.limit; @@ -7173,7 +7219,8 @@ suspend: goto exit; exit: if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } return status; @@ -7197,11 +7244,12 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_src); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; if (!a_src.private_impl.mark) { a_src.private_impl.mark = iop_a_src; a_src.private_impl.limit = - a_src.private_impl.buf->ptr + a_src.private_impl.buf->wi; + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.wi; } io0_a_src = a_src.private_impl.mark; io1_a_src = a_src.private_impl.limit; @@ -7367,7 +7415,8 @@ suspend: goto exit; exit: if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } return status; @@ -7388,11 +7437,12 @@ wuffs_gif__decoder__decode_extension(wuffs_gif__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_src); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; if (!a_src.private_impl.mark) { a_src.private_impl.mark = iop_a_src; a_src.private_impl.limit = - a_src.private_impl.buf->ptr + a_src.private_impl.buf->wi; + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.wi; } io0_a_src = a_src.private_impl.mark; io1_a_src = a_src.private_impl.limit; @@ -7419,11 +7469,13 @@ wuffs_gif__decoder__decode_extension(wuffs_gif__decoder* self, if (v_label == 249) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } status = wuffs_gif__decoder__decode_gc(self, a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; } if (status) { goto suspend; @@ -7433,11 +7485,13 @@ wuffs_gif__decoder__decode_extension(wuffs_gif__decoder* self, } else if (v_label == 255) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } status = wuffs_gif__decoder__decode_ae(self, a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; } if (status) { goto suspend; @@ -7447,11 +7501,13 @@ wuffs_gif__decoder__decode_extension(wuffs_gif__decoder* self, } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } status = wuffs_gif__decoder__skip_blocks(self, a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; } if (status) { goto suspend; @@ -7471,7 +7527,8 @@ suspend: goto exit; exit: if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } return status; @@ -7492,11 +7549,12 @@ wuffs_gif__decoder__skip_blocks(wuffs_gif__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_src); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; if (!a_src.private_impl.mark) { a_src.private_impl.mark = iop_a_src; a_src.private_impl.limit = - a_src.private_impl.buf->ptr + a_src.private_impl.buf->wi; + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.wi; } io0_a_src = a_src.private_impl.mark; io1_a_src = a_src.private_impl.limit; @@ -7552,7 +7610,8 @@ suspend: goto exit; exit: if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } return status; @@ -7576,11 +7635,12 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_src); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; if (!a_src.private_impl.mark) { a_src.private_impl.mark = iop_a_src; a_src.private_impl.limit = - a_src.private_impl.buf->ptr + a_src.private_impl.buf->wi; + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.wi; } io0_a_src = a_src.private_impl.mark; io1_a_src = a_src.private_impl.limit; @@ -7735,11 +7795,13 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self, label_0_break:; WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13); if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } status = wuffs_gif__decoder__skip_blocks(self, a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; } if (status) { goto suspend; @@ -7762,7 +7824,8 @@ suspend: goto exit; exit: if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } return status; @@ -7784,11 +7847,12 @@ wuffs_gif__decoder__decode_gc(wuffs_gif__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_src); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; if (!a_src.private_impl.mark) { a_src.private_impl.mark = iop_a_src; a_src.private_impl.limit = - a_src.private_impl.buf->ptr + a_src.private_impl.buf->wi; + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.wi; } io0_a_src = a_src.private_impl.mark; io1_a_src = a_src.private_impl.limit; @@ -7906,7 +7970,8 @@ suspend: goto exit; exit: if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } return status; @@ -7925,11 +7990,12 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_src); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; if (!a_src.private_impl.mark) { a_src.private_impl.mark = iop_a_src; a_src.private_impl.limit = - a_src.private_impl.buf->ptr + a_src.private_impl.buf->wi; + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.wi; } io0_a_src = a_src.private_impl.mark; io1_a_src = a_src.private_impl.limit; @@ -8083,7 +8149,8 @@ suspend: goto exit; exit: if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } return status; @@ -8118,11 +8185,12 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_src); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; if (!a_src.private_impl.mark) { a_src.private_impl.mark = iop_a_src; a_src.private_impl.limit = - a_src.private_impl.buf->ptr + a_src.private_impl.buf->wi; + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.wi; } io0_a_src = a_src.private_impl.mark; io1_a_src = a_src.private_impl.limit; @@ -8303,17 +8371,17 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, wuffs_base__io_reader__set_limit(&a_src, iop_a_src, v_block_size); wuffs_base__io_reader__set_mark(&a_src, iop_a_src); { - u_w.wi = iop_v_w - u_w.ptr; + u_w.meta.wi = iop_v_w - u_w.data.ptr; if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = - iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } wuffs_base__status t_5 = wuffs_lzw__decoder__decode( &self->private_impl.f_lzw, v_w, a_src); - iop_v_w = u_w.ptr + u_w.wi; + iop_v_w = u_w.data.ptr + u_w.meta.wi; if (a_src.private_impl.buf) { - iop_a_src = - a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = a_src.private_impl.buf->data.ptr + + a_src.private_impl.buf->meta.ri; } v_z = t_5; } @@ -8386,7 +8454,8 @@ suspend: goto exit; exit: if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } return status; @@ -8611,13 +8680,14 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_dst); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_dst); if (a_dst.private_impl.buf) { - iop_a_dst = a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi; + iop_a_dst = + a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->meta.wi; if (!a_dst.private_impl.mark) { a_dst.private_impl.mark = iop_a_dst; a_dst.private_impl.limit = - a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->len; + a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->data.len; } - if (a_dst.private_impl.buf->closed) { + if (a_dst.private_impl.buf->meta.closed) { a_dst.private_impl.limit = iop_a_dst; } io0_a_dst = a_dst.private_impl.mark; @@ -8629,11 +8699,12 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_src); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; if (!a_src.private_impl.mark) { a_src.private_impl.mark = iop_a_src; a_src.private_impl.limit = - a_src.private_impl.buf->ptr + a_src.private_impl.buf->wi; + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.wi; } io0_a_src = a_src.private_impl.mark; io1_a_src = a_src.private_impl.limit; @@ -8813,18 +8884,22 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, wuffs_base__io_writer__set_mark(&a_dst, iop_a_dst); { if (a_dst.private_impl.buf) { - a_dst.private_impl.buf->wi = iop_a_dst - a_dst.private_impl.buf->ptr; + a_dst.private_impl.buf->meta.wi = + iop_a_dst - a_dst.private_impl.buf->data.ptr; } if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } wuffs_base__status t_8 = wuffs_deflate__decoder__decode( &self->private_impl.f_flate, a_dst, a_src); if (a_dst.private_impl.buf) { - iop_a_dst = a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi; + iop_a_dst = a_dst.private_impl.buf->data.ptr + + a_dst.private_impl.buf->meta.wi; } if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = a_src.private_impl.buf->data.ptr + + a_src.private_impl.buf->meta.ri; } v_z = t_8; } @@ -8937,10 +9012,12 @@ suspend: goto exit; exit: if (a_dst.private_impl.buf) { - a_dst.private_impl.buf->wi = iop_a_dst - a_dst.private_impl.buf->ptr; + a_dst.private_impl.buf->meta.wi = + iop_a_dst - a_dst.private_impl.buf->data.ptr; } if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } if (wuffs_base__status__is_error(status)) { @@ -9045,13 +9122,14 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_dst); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_dst); if (a_dst.private_impl.buf) { - iop_a_dst = a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi; + iop_a_dst = + a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->meta.wi; if (!a_dst.private_impl.mark) { a_dst.private_impl.mark = iop_a_dst; a_dst.private_impl.limit = - a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->len; + a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->data.len; } - if (a_dst.private_impl.buf->closed) { + if (a_dst.private_impl.buf->meta.closed) { a_dst.private_impl.limit = iop_a_dst; } io0_a_dst = a_dst.private_impl.mark; @@ -9063,11 +9141,12 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_src); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; if (!a_src.private_impl.mark) { a_src.private_impl.mark = iop_a_src; a_src.private_impl.limit = - a_src.private_impl.buf->ptr + a_src.private_impl.buf->wi; + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.wi; } io0_a_src = a_src.private_impl.mark; io1_a_src = a_src.private_impl.limit; @@ -9224,10 +9303,12 @@ suspend: goto exit; exit: if (a_dst.private_impl.buf) { - a_dst.private_impl.buf->wi = iop_a_dst - a_dst.private_impl.buf->ptr; + a_dst.private_impl.buf->meta.wi = + iop_a_dst - a_dst.private_impl.buf->data.ptr; } if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } if (wuffs_base__status__is_error(status)) { @@ -9339,13 +9420,14 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_dst); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_dst); if (a_dst.private_impl.buf) { - iop_a_dst = a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi; + iop_a_dst = + a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->meta.wi; if (!a_dst.private_impl.mark) { a_dst.private_impl.mark = iop_a_dst; a_dst.private_impl.limit = - a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->len; + a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->data.len; } - if (a_dst.private_impl.buf->closed) { + if (a_dst.private_impl.buf->meta.closed) { a_dst.private_impl.limit = iop_a_dst; } io0_a_dst = a_dst.private_impl.mark; @@ -9357,11 +9439,12 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_src); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_src); if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; if (!a_src.private_impl.mark) { a_src.private_impl.mark = iop_a_src; a_src.private_impl.limit = - a_src.private_impl.buf->ptr + a_src.private_impl.buf->wi; + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.wi; } io0_a_src = a_src.private_impl.mark; io1_a_src = a_src.private_impl.limit; @@ -9428,18 +9511,22 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, wuffs_base__io_writer__set_mark(&a_dst, iop_a_dst); { if (a_dst.private_impl.buf) { - a_dst.private_impl.buf->wi = iop_a_dst - a_dst.private_impl.buf->ptr; + a_dst.private_impl.buf->meta.wi = + iop_a_dst - a_dst.private_impl.buf->data.ptr; } if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } wuffs_base__status t_2 = wuffs_deflate__decoder__decode( &self->private_impl.f_flate, a_dst, a_src); if (a_dst.private_impl.buf) { - iop_a_dst = a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi; + iop_a_dst = a_dst.private_impl.buf->data.ptr + + a_dst.private_impl.buf->meta.wi; } if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; + iop_a_src = a_src.private_impl.buf->data.ptr + + a_src.private_impl.buf->meta.ri; } v_z = t_2; } @@ -9510,10 +9597,12 @@ suspend: goto exit; exit: if (a_dst.private_impl.buf) { - a_dst.private_impl.buf->wi = iop_a_dst - a_dst.private_impl.buf->ptr; + a_dst.private_impl.buf->meta.wi = + iop_a_dst - a_dst.private_impl.buf->data.ptr; } if (a_src.private_impl.buf) { - a_src.private_impl.buf->ri = iop_a_src - a_src.private_impl.buf->ptr; + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; } if (wuffs_base__status__is_error(status)) { diff --git a/test/c/mimiclib/deflate-gzip-zlib.c b/test/c/mimiclib/deflate-gzip-zlib.c index c84e24c2..1dbc5f47 100644 --- a/test/c/mimiclib/deflate-gzip-zlib.c +++ b/test/c/mimiclib/deflate-gzip-zlib.c @@ -42,14 +42,14 @@ const char* mimic_deflate_zlib_decode(wuffs_base__io_buffer* dst, if (!deflate_instead_of_zlib) { flags |= TINFL_FLAG_PARSE_ZLIB_HEADER; } - size_t n = - tinfl_decompress_mem_to_mem(dst->ptr + dst->wi, dst->len - dst->wi, - src->ptr + src->ri, src->wi - src->ri, flags); + size_t n = tinfl_decompress_mem_to_mem( + dst->data.ptr + dst->meta.wi, dst->data.len - dst->meta.wi, + src->data.ptr + src->meta.ri, src->meta.wi - src->meta.ri, flags); if (n == TINFL_DECOMPRESS_MEM_TO_MEM_FAILED) { return "TINFL_DECOMPRESS_MEM_TO_MEM_FAILED"; } - dst->wi += n; - src->ri = src->wi; + dst->meta.wi += n; + src->meta.ri = src->meta.wi; return NULL; } @@ -84,13 +84,13 @@ const char* mimic_bench_adler32(wuffs_base__io_buffer* dst, uint64_t wlimit, uint64_t rlimit) { // TODO: don't ignore wlimit and rlimit. - uint8_t* ptr = src->ptr + src->ri; - size_t len = src->wi - src->ri; + uint8_t* ptr = src->data.ptr + src->meta.ri; + size_t len = src->meta.wi - src->meta.ri; if (len > 0x7FFFFFFF) { return "src length is too large"; } global_mimiclib_deflate_unused_u32 = adler32(0L, ptr, len); - src->ri = src->wi; + src->meta.ri = src->meta.wi; return NULL; } @@ -99,13 +99,13 @@ const char* mimic_bench_crc32_ieee(wuffs_base__io_buffer* dst, uint64_t wlimit, uint64_t rlimit) { // TODO: don't ignore wlimit and rlimit. - uint8_t* ptr = src->ptr + src->ri; - size_t len = src->wi - src->ri; + uint8_t* ptr = src->data.ptr + src->meta.ri; + size_t len = src->meta.wi - src->meta.ri; if (len > 0x7FFFFFFF) { return "src length is too large"; } global_mimiclib_deflate_unused_u32 = crc32(0L, ptr, len); - src->ri = src->wi; + src->meta.ri = src->meta.wi; return NULL; } @@ -147,10 +147,10 @@ const char* mimic_deflate_gzip_zlib_decode(wuffs_base__io_buffer* dst, goto cleanup0; } - z.avail_in = src->wi - src->ri; - z.next_in = src->ptr + src->ri; - z.avail_out = dst->len - dst->wi; - z.next_out = dst->ptr + dst->wi; + z.avail_in = src->meta.wi - src->meta.ri; + z.next_in = src->data.ptr + src->meta.ri; + z.avail_out = dst->data.len - dst->meta.wi; + z.next_out = dst->data.ptr + dst->meta.wi; int i_err = inflate(&z, Z_NO_FLUSH); if (i_err != Z_STREAM_END) { @@ -158,21 +158,21 @@ const char* mimic_deflate_gzip_zlib_decode(wuffs_base__io_buffer* dst, goto cleanup1; } - size_t readable = src->wi - src->ri; + size_t readable = src->meta.wi - src->meta.ri; size_t r_remaining = z.avail_in; if (readable < r_remaining) { ret = "inconsistent avail_in"; goto cleanup1; } - src->ri += readable - r_remaining; + src->meta.ri += readable - r_remaining; - size_t writable = dst->len - dst->wi; + size_t writable = dst->data.len - dst->meta.wi; size_t w_remaining = z.avail_out; if (writable < w_remaining) { ret = "inconsistent avail_out"; goto cleanup1; } - dst->wi += writable - w_remaining; + dst->meta.wi += writable - w_remaining; cleanup1:; int ie_err = inflateEnd(&z); diff --git a/test/c/mimiclib/gif.c b/test/c/mimiclib/gif.c index f9768e8e..9adc9669 100644 --- a/test/c/mimiclib/gif.c +++ b/test/c/mimiclib/gif.c @@ -20,12 +20,12 @@ int mimic_gif_read_func(GifFileType* f, GifByteType* ptr, int len) { return 0; } size_t n = (size_t)(len); - size_t num_src = src->wi - src->ri; + size_t num_src = src->meta.wi - src->meta.ri; if (n > num_src) { n = num_src; } - memmove(ptr, src->ptr + src->ri, n); - src->ri += n; + memmove(ptr, src->data.ptr + src->meta.ri, n); + src->meta.ri += n; return n; } @@ -70,13 +70,13 @@ const char* mimic_gif_decode(wuffs_base__io_buffer* dst, struct SavedImage* si = &f->SavedImages[i]; size_t num_src = (size_t)(si->ImageDesc.Width) * (size_t)(si->ImageDesc.Height); - size_t num_dst = dst->len - dst->wi; + size_t num_dst = dst->data.len - dst->meta.wi; if (num_dst < num_src) { ret = "GIF image's pixel data won't fit in the dst buffer"; goto cleanup1; } - memmove(dst->ptr + dst->wi, si->RasterBits, num_src); - dst->wi += num_src; + memmove(dst->data.ptr + dst->meta.wi, si->RasterBits, num_src); + dst->meta.wi += num_src; } cleanup1:; diff --git a/test/c/std/adler32.c b/test/c/std/adler32.c index e8d5fda9..be47b6cc 100644 --- a/test/c/std/adler32.c +++ b/test/c/std/adler32.c @@ -117,8 +117,9 @@ void test_wuffs_adler32_golden() { int i; for (i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); i++) { - wuffs_base__io_buffer src = - ((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE}); + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = global_src_slice, + }); if (!read_file(&src, test_cases[i].filename)) { return; } @@ -138,8 +139,8 @@ void test_wuffs_adler32_golden() { size_t num_bytes = 0; do { wuffs_base__slice_u8 data = ((wuffs_base__slice_u8){ - .ptr = src.ptr + num_bytes, - .len = src.wi - num_bytes, + .ptr = src.data.ptr + num_bytes, + .len = src.meta.wi - num_bytes, }); size_t limit = 101 + 103 * num_fragments; if ((j > 0) && (data.len > limit)) { @@ -148,7 +149,7 @@ void test_wuffs_adler32_golden() { got = wuffs_adler32__hasher__update(&checksum, data); num_fragments++; num_bytes += data.len; - } while (num_bytes < src.wi); + } while (num_bytes < src.meta.wi); if (got != test_cases[i].want) { FAIL("i=%d, j=%d, filename=\"%s\": got 0x%08" PRIX32 @@ -217,7 +218,7 @@ const char* wuffs_bench_adler32(wuffs_base__io_buffer* dst, wuffs_base__io_buffer* src, uint64_t wlimit, uint64_t rlimit) { - uint64_t len = src->wi - src->ri; + uint64_t len = src->meta.wi - src->meta.ri; if (rlimit) { len = wuffs_base__u64__min(len, rlimit); } @@ -227,12 +228,12 @@ const char* wuffs_bench_adler32(wuffs_base__io_buffer* dst, if (z) { return z; } - global_wuffs_adler32_unused_u32 = - wuffs_adler32__hasher__update(&checksum, ((wuffs_base__slice_u8){ - .ptr = src->ptr + src->ri, - .len = len, - })); - src->ri += len; + global_wuffs_adler32_unused_u32 = wuffs_adler32__hasher__update( + &checksum, ((wuffs_base__slice_u8){ + .ptr = src->data.ptr + src->meta.ri, + .len = len, + })); + src->meta.ri += len; return NULL; } diff --git a/test/c/std/crc32.c b/test/c/std/crc32.c index fc6e4580..455d7280 100644 --- a/test/c/std/crc32.c +++ b/test/c/std/crc32.c @@ -117,8 +117,9 @@ void test_wuffs_crc32_ieee_golden() { int i; for (i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); i++) { - wuffs_base__io_buffer src = - ((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE}); + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = global_src_slice, + }); if (!read_file(&src, test_cases[i].filename)) { return; } @@ -138,8 +139,8 @@ void test_wuffs_crc32_ieee_golden() { size_t num_bytes = 0; do { wuffs_base__slice_u8 data = ((wuffs_base__slice_u8){ - .ptr = src.ptr + num_bytes, - .len = src.wi - num_bytes, + .ptr = src.data.ptr + num_bytes, + .len = src.meta.wi - num_bytes, }); size_t limit = 101 + 103 * num_fragments; if ((j > 0) && (data.len > limit)) { @@ -148,7 +149,7 @@ void test_wuffs_crc32_ieee_golden() { got = wuffs_crc32__ieee_hasher__update(&checksum, data); num_fragments++; num_bytes += data.len; - } while (num_bytes < src.wi); + } while (num_bytes < src.meta.wi); if (got != test_cases[i].want) { FAIL("i=%d, j=%d, filename=\"%s\": got 0x%08" PRIX32 @@ -217,7 +218,7 @@ const char* wuffs_bench_crc32_ieee(wuffs_base__io_buffer* dst, wuffs_base__io_buffer* src, uint64_t wlimit, uint64_t rlimit) { - uint64_t len = src->wi - src->ri; + uint64_t len = src->meta.wi - src->meta.ri; if (rlimit) { len = wuffs_base__u64__min(len, rlimit); } @@ -227,12 +228,12 @@ const char* wuffs_bench_crc32_ieee(wuffs_base__io_buffer* dst, if (z) { return z; } - global_wuffs_crc32_unused_u32 = - wuffs_crc32__ieee_hasher__update(&checksum, ((wuffs_base__slice_u8){ - .ptr = src->ptr + src->ri, - .len = len, - })); - src->ri += len; + global_wuffs_crc32_unused_u32 = wuffs_crc32__ieee_hasher__update( + &checksum, ((wuffs_base__slice_u8){ + .ptr = src->data.ptr + src->meta.ri, + .len = len, + })); + src->meta.ri += len; return NULL; } diff --git a/test/c/std/deflate.c b/test/c/std/deflate.c index afa98ef5..a0e9221a 100644 --- a/test/c/std/deflate.c +++ b/test/c/std/deflate.c @@ -214,12 +214,15 @@ void test_wuffs_deflate_decode_romeo_fixed() { void test_wuffs_deflate_decode_split_src() { CHECK_FOCUS(__func__); - wuffs_base__io_buffer src = - ((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE}); - wuffs_base__io_buffer got = - ((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE}); - wuffs_base__io_buffer want = - ((wuffs_base__io_buffer){.ptr = global_want_buffer, .len = BUFFER_SIZE}); + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = global_src_slice, + }); + wuffs_base__io_buffer got = ((wuffs_base__io_buffer){ + .data = global_got_slice, + }); + wuffs_base__io_buffer want = ((wuffs_base__io_buffer){ + .data = global_want_slice, + }); golden_test* gt = &deflate_256_bytes_gt; if (!read_file(&src, gt->src_filename)) { @@ -239,7 +242,7 @@ void test_wuffs_deflate_decode_split_src() { FAIL("i=%d: split was not an interior split", i); return; } - got.wi = 0; + got.meta.wi = 0; wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){}); wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version( @@ -249,15 +252,15 @@ void test_wuffs_deflate_decode_split_src() { return; } - src.closed = false; - src.ri = gt->src_offset0; - src.wi = split; + src.meta.closed = false; + src.meta.ri = gt->src_offset0; + src.meta.wi = split; wuffs_base__status z0 = wuffs_deflate__decoder__decode(&dec, dst_writer, src_reader); - src.closed = true; - src.ri = split; - src.wi = gt->src_offset1; + src.meta.closed = true; + src.meta.ri = split; + src.meta.wi = gt->src_offset1; wuffs_base__status z1 = wuffs_deflate__decoder__decode(&dec, dst_writer, src_reader); @@ -288,10 +291,10 @@ bool do_test_wuffs_deflate_history(int i, uint32_t starting_history_index, uint64_t limit, const char* want_z) { - src->ri = gt->src_offset0; - src->wi = gt->src_offset1; - got->ri = 0; - got->wi = 0; + src->meta.ri = gt->src_offset0; + src->meta.wi = gt->src_offset1; + got->meta.ri = 0; + got->meta.wi = 0; wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(got); wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(src); @@ -314,12 +317,15 @@ bool do_test_wuffs_deflate_history(int i, void test_wuffs_deflate_history_full() { CHECK_FOCUS(__func__); - wuffs_base__io_buffer src = - ((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE}); - wuffs_base__io_buffer got = - ((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE}); - wuffs_base__io_buffer want = - ((wuffs_base__io_buffer){.ptr = global_want_buffer, .len = BUFFER_SIZE}); + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = global_src_slice, + }); + wuffs_base__io_buffer got = ((wuffs_base__io_buffer){ + .data = global_got_slice, + }); + wuffs_base__io_buffer want = ((wuffs_base__io_buffer){ + .data = global_want_slice, + }); golden_test* gt = &deflate_pi_gt; if (!read_file(&src, gt->src_filename)) { @@ -341,7 +347,7 @@ void test_wuffs_deflate_history_full() { } if (!do_test_wuffs_deflate_history( - i, gt, &src, &got, &dec, 0, want.wi + i, + i, gt, &src, &got, &dec, 0, want.meta.wi + i, i >= 0 ? NULL : wuffs_base__suspension__short_write)) { return; } @@ -357,19 +363,23 @@ void test_wuffs_deflate_history_full() { } wuffs_base__io_buffer history_got = ((wuffs_base__io_buffer){ - .ptr = dec.private_impl.f_history, - .len = full_history_size, - .wi = full_history_size, + .data = ((wuffs_base__slice_u8){ + .ptr = dec.private_impl.f_history, + .len = full_history_size, + }), }); - if (want.wi < full_history_size - i) { + history_got.meta.wi = full_history_size; + if (want.meta.wi < full_history_size - i) { FAIL("i=%d: want file is too short", i); return; } wuffs_base__io_buffer history_want = ((wuffs_base__io_buffer){ - .ptr = global_want_buffer + want.wi - (full_history_size - i), - .len = full_history_size, - .wi = full_history_size, + .data = ((wuffs_base__slice_u8){ + .ptr = global_want_array + want.meta.wi - (full_history_size - i), + .len = full_history_size, + }), }); + history_want.meta.wi = full_history_size; if (!io_buffers_equal("", &history_got, &history_want)) { return; } @@ -379,10 +389,12 @@ void test_wuffs_deflate_history_full() { void test_wuffs_deflate_history_partial() { CHECK_FOCUS(__func__); - wuffs_base__io_buffer src = - ((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE}); - wuffs_base__io_buffer got = - ((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE}); + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = global_src_slice, + }); + wuffs_base__io_buffer got = ((wuffs_base__io_buffer){ + .data = global_got_slice, + }); golden_test* gt = &deflate_pi_gt; if (!read_file(&src, gt->src_filename)) { diff --git a/test/c/std/gif.c b/test/c/std/gif.c index bfb1b4b0..0b02e0bc 100644 --- a/test/c/std/gif.c +++ b/test/c/std/gif.c @@ -212,12 +212,8 @@ const char* wuffs_gif_decode(wuffs_base__io_buffer* dst, } wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){}); - z = wuffs_base__pixel_buffer__set_from_slice( - &pb, &ic.pixcfg, - ((wuffs_base__slice_u8){ - .ptr = global_pixel_buffer, - .len = WUFFS_TESTLIB_ARRAY_SIZE(global_pixel_buffer), - })); + z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg, + global_pixel_slice); if (z) { return z; } @@ -227,7 +223,7 @@ const char* wuffs_gif_decode(wuffs_base__io_buffer* dst, return "work buffer size is too large"; } wuffs_base__slice_u8 workbuf = ((wuffs_base__slice_u8){ - .ptr = global_work_buffer, + .ptr = global_work_array, .len = workbuf_len, }); @@ -258,10 +254,12 @@ bool do_test_wuffs_gif_decode(const char* filename, const char* palette_filename, const char* indexes_filename, uint64_t rlimit) { - wuffs_base__io_buffer got = - ((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE}); - wuffs_base__io_buffer src = - ((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE}); + wuffs_base__io_buffer got = ((wuffs_base__io_buffer){ + .data = global_got_slice, + }); + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = global_src_slice, + }); if (!read_file(&src, filename)) { return false; @@ -319,12 +317,8 @@ bool do_test_wuffs_gif_decode(const char* filename, FAIL("first_frame_is_opaque: got false, want true"); return false; } - z = wuffs_base__pixel_buffer__set_from_slice( - &pb, &ic.pixcfg, - ((wuffs_base__slice_u8){ - .ptr = global_pixel_buffer, - .len = WUFFS_TESTLIB_ARRAY_SIZE(global_pixel_buffer), - })); + z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg, + global_pixel_slice); if (z) { FAIL("set_from_slice: \"%s\"", z); return false; @@ -332,7 +326,7 @@ bool do_test_wuffs_gif_decode(const char* filename, } wuffs_base__slice_u8 workbuf = ((wuffs_base__slice_u8){ - .ptr = global_work_buffer, + .ptr = global_work_array, .len = 160, }); @@ -343,7 +337,7 @@ bool do_test_wuffs_gif_decode(const char* filename, if (rlimit) { set_reader_limit(&src_reader, rlimit); } - size_t old_ri = src.ri; + size_t old_ri = src.meta.ri; wuffs_base__status z = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader); @@ -357,11 +351,11 @@ bool do_test_wuffs_gif_decode(const char* filename, return false; } - if (src.ri < old_ri) { - FAIL("read index src.ri went backwards"); + if (src.meta.ri < old_ri) { + FAIL("read index src.meta.ri went backwards"); return false; } - if (src.ri == old_ri) { + if (src.meta.ri == old_ri) { FAIL("no progress was made"); return false; } @@ -373,7 +367,7 @@ bool do_test_wuffs_gif_decode(const char* filename, if (rlimit) { set_reader_limit(&src_reader, rlimit); } - size_t old_ri = src.ri; + size_t old_ri = src.meta.ri; wuffs_base__status z = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader, workbuf, NULL); @@ -387,11 +381,11 @@ bool do_test_wuffs_gif_decode(const char* filename, return false; } - if (src.ri < old_ri) { - FAIL("read index src.ri went backwards"); + if (src.meta.ri < old_ri) { + FAIL("read index src.meta.ri went backwards"); return false; } - if (src.ri == old_ri) { + if (src.meta.ri == old_ri) { FAIL("no progress was made"); return false; } @@ -418,12 +412,17 @@ bool do_test_wuffs_gif_decode(const char* filename, } } - wuffs_base__slice_u8 pal_got_slice = wuffs_base__pixel_buffer__palette(&pb); - wuffs_base__io_buffer pal_got = {.ptr = pal_got_slice.ptr, - .len = pal_got_slice.len, - .wi = pal_got_slice.len}; + wuffs_base__io_buffer pal_got = ((wuffs_base__io_buffer){ + .data = wuffs_base__pixel_buffer__palette(&pb), + }); + pal_got.meta.wi = pal_got.data.len; uint8_t pal_want_array[1024]; - wuffs_base__io_buffer pal_want = {.ptr = pal_want_array, .len = 1024}; + wuffs_base__io_buffer pal_want = ((wuffs_base__io_buffer){ + .data = ((wuffs_base__slice_u8){ + .ptr = pal_want_array, + .len = 1024, + }), + }); if (!read_file(&pal_want, palette_filename)) { return false; } @@ -431,8 +430,9 @@ bool do_test_wuffs_gif_decode(const char* filename, return false; } - wuffs_base__io_buffer ind_want = {.ptr = global_want_buffer, - .len = BUFFER_SIZE}; + wuffs_base__io_buffer ind_want = ((wuffs_base__io_buffer){ + .data = global_want_slice, + }); if (!read_file(&ind_want, indexes_filename)) { return false; } @@ -441,7 +441,7 @@ bool do_test_wuffs_gif_decode(const char* filename, } { - if (src.ri == src.wi) { + if (src.meta.ri == src.meta.wi) { FAIL("decode_frame returned \"ok\" but src was exhausted"); return false; } @@ -453,7 +453,7 @@ bool do_test_wuffs_gif_decode(const char* filename, wuffs_base__warning__end_of_data); return false; } - if (src.ri != src.wi) { + if (src.meta.ri != src.meta.wi) { FAIL("decode_frame returned \"end of data\" but src was not exhausted"); return false; } @@ -465,8 +465,9 @@ bool do_test_wuffs_gif_decode(const char* filename, void test_wuffs_gif_call_sequence() { CHECK_FOCUS(__func__); - wuffs_base__io_buffer src = - ((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE}); + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = global_src_slice, + }); if (!read_file(&src, "../../data/bricks-dither.gif")) { return; @@ -501,7 +502,9 @@ bool do_test_wuffs_gif_decode_animated( uint32_t want_num_loops, uint32_t want_num_frames, wuffs_base__rect_ie_u32* want_frame_config_bounds) { - wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = global_src_slice, + }); if (!read_file(&src, filename)) { return false; @@ -529,7 +532,7 @@ bool do_test_wuffs_gif_decode_animated( return "work buffer size is too large"; } wuffs_base__slice_u8 workbuf = ((wuffs_base__slice_u8){ - .ptr = global_work_buffer, + .ptr = global_work_array, .len = workbuf_len, }); @@ -540,12 +543,8 @@ bool do_test_wuffs_gif_decode_animated( } wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){}); - z = wuffs_base__pixel_buffer__set_from_slice( - &pb, &ic.pixcfg, - ((wuffs_base__slice_u8){ - .ptr = global_pixel_buffer, - .len = WUFFS_TESTLIB_ARRAY_SIZE(global_pixel_buffer), - })); + z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg, + global_pixel_slice); if (z) { FAIL("set_from_slice: \"%s\"", z); return false; @@ -634,8 +633,9 @@ void test_wuffs_gif_decode_animated_small() { void test_wuffs_gif_decode_frame_out_of_bounds() { CHECK_FOCUS(__func__); - wuffs_base__io_buffer src = - ((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE}); + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = global_src_slice, + }); if (!read_file(&src, "../../data/artificial/gif-frame-out-of-bounds.gif")) { return; } @@ -675,12 +675,8 @@ void test_wuffs_gif_decode_frame_out_of_bounds() { } wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){}); - z = wuffs_base__pixel_buffer__set_from_slice( - &pb, &ic.pixcfg, - ((wuffs_base__slice_u8){ - .ptr = global_pixel_buffer, - .len = WUFFS_TESTLIB_ARRAY_SIZE(global_pixel_buffer), - })); + z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg, + global_pixel_slice); if (z) { FAIL("set_from_slice: \"%s\"", z); return; @@ -692,7 +688,7 @@ void test_wuffs_gif_decode_frame_out_of_bounds() { return; } wuffs_base__slice_u8 workbuf = ((wuffs_base__slice_u8){ - .ptr = global_work_buffer, + .ptr = global_work_array, .len = workbuf_len, }); @@ -813,8 +809,9 @@ void test_wuffs_gif_decode_input_is_a_gif_many_small_reads() { void test_wuffs_gif_decode_input_is_a_png() { CHECK_FOCUS(__func__); - wuffs_base__io_buffer src = - ((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE}); + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = global_src_slice, + }); if (!read_file(&src, "../../data/bricks-dither.png")) { return; @@ -839,8 +836,9 @@ void test_wuffs_gif_decode_input_is_a_png() { } bool do_test_wuffs_gif_num_decoded(bool frame_config) { - wuffs_base__io_buffer src = - ((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE}); + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = global_src_slice, + }); if (!read_file(&src, "../../data/animated-red-blue.gif")) { return false; @@ -864,12 +862,8 @@ bool do_test_wuffs_gif_num_decoded(bool frame_config) { return false; } - z = wuffs_base__pixel_buffer__set_from_slice( - &pb, &ic.pixcfg, - ((wuffs_base__slice_u8){ - .ptr = global_pixel_buffer, - .len = WUFFS_TESTLIB_ARRAY_SIZE(global_pixel_buffer), - })); + z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg, + global_pixel_slice); if (z) { FAIL("set_from_slice: \"%s\"", z); return false; @@ -877,7 +871,7 @@ bool do_test_wuffs_gif_num_decoded(bool frame_config) { } wuffs_base__slice_u8 workbuf = ((wuffs_base__slice_u8){ - .ptr = global_work_buffer, + .ptr = global_work_array, .len = 64, }); @@ -935,8 +929,9 @@ void test_wuffs_gif_num_decoded_frames() { } bool do_test_wuffs_gif_io_position(bool chunked) { - wuffs_base__io_buffer src = - ((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE}); + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = global_src_slice, + }); if (!read_file(&src, "../../data/animated-red-blue.gif")) { return false; } @@ -952,14 +947,14 @@ bool do_test_wuffs_gif_io_position(bool chunked) { wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); if (chunked) { - if (src.wi < 50) { + if (src.meta.wi < 50) { FAIL("src is too short"); return false; } - size_t saved_wi = src.wi; - bool saved_closed = src.closed; - src.wi = 30; - src.closed = false; + size_t saved_wi = src.meta.wi; + bool saved_closed = src.meta.closed; + src.meta.wi = 30; + src.meta.closed = false; z = wuffs_gif__decoder__decode_image_config(&dec, NULL, src_reader); if (z != wuffs_base__suspension__short_read) { @@ -967,16 +962,16 @@ bool do_test_wuffs_gif_io_position(bool chunked) { return false; } - src.wi = saved_wi; - src.closed = saved_closed; + src.meta.wi = saved_wi; + src.meta.closed = saved_closed; - if (src.pos != 0) { - FAIL("src.pos: got %" PRIu64 ", want zero", src.pos); + if (src.meta.pos != 0) { + FAIL("src.meta.pos: got %" PRIu64 ", want zero", src.meta.pos); return false; } wuffs_base__io_buffer__compact(&src); - if (src.pos == 0) { - FAIL("src.pos: got %" PRIu64 ", want non-zero", src.pos); + if (src.meta.pos == 0) { + FAIL("src.meta.pos: got %" PRIu64 ", want non-zero", src.meta.pos); return false; } } @@ -1026,16 +1021,16 @@ bool do_test_wuffs_gif_io_position(bool chunked) { // Look for the 0x21 byte that's a GIF's Extension Introducer. Not every // GIF's frame_config's I/O position will point to 0x21, as an 0x2C Image // Separator is also valid. But for animated-red-blue.gif, it'll be 0x21. - if (pos_got < src.pos) { + if (pos_got < src.meta.pos) { FAIL("io_position #%d: got %" PRIu64 ", was too small", i, pos_got); return false; } - uint64_t src_ptr_offset = pos_got - src.pos; - if (src_ptr_offset >= src.wi) { + uint64_t src_ptr_offset = pos_got - src.meta.pos; + if (src_ptr_offset >= src.meta.wi) { FAIL("io_position #%d: got %" PRIu64 ", was too large", i, pos_got); return false; } - uint8_t x = src.ptr[src_ptr_offset]; + uint8_t x = src.data.ptr[src_ptr_offset]; if (x != 0x21) { FAIL("Image Descriptor byte #%d: got 0x%02X, want 0x2C", i, (int)x); return false; @@ -1056,7 +1051,7 @@ bool do_test_wuffs_gif_io_position(bool chunked) { } for (i = 0; i < 4; i++) { - src.ri = pos_wants[i]; + src.meta.ri = pos_wants[i]; z = wuffs_gif__decoder__restart_frame( &dec, i, wuffs_base__frame_config__io_position(&fcs[i])); @@ -1116,24 +1111,27 @@ void test_wuffs_gif_io_position_two_chunks() { #ifdef WUFFS_MIMIC bool do_test_mimic_gif_decode(const char* filename) { - wuffs_base__io_buffer src = - ((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE}); + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = global_src_slice, + }); if (!read_file(&src, filename)) { return false; } - src.ri = 0; - wuffs_base__io_buffer got = - ((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE}); + src.meta.ri = 0; + wuffs_base__io_buffer got = ((wuffs_base__io_buffer){ + .data = global_got_slice, + }); const char* got_msg = wuffs_gif_decode(&got, &src); if (got_msg) { FAIL("%s", got_msg); return false; } - src.ri = 0; - wuffs_base__io_buffer want = - ((wuffs_base__io_buffer){.ptr = global_want_buffer, .len = BUFFER_SIZE}); + src.meta.ri = 0; + wuffs_base__io_buffer want = ((wuffs_base__io_buffer){ + .data = global_want_slice, + }); const char* want_msg = mimic_gif_decode(&want, &src); if (want_msg) { FAIL("%s", want_msg); @@ -1218,10 +1216,12 @@ bool do_bench_gif_decode(const char* (*decode_func)(wuffs_base__io_buffer*, wuffs_base__io_buffer*), const char* filename, uint64_t iters_unscaled) { - wuffs_base__io_buffer dst = - ((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE}); - wuffs_base__io_buffer src = - ((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE}); + wuffs_base__io_buffer got = ((wuffs_base__io_buffer){ + .data = global_got_slice, + }); + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = global_src_slice, + }); if (!read_file(&src, filename)) { return false; @@ -1232,14 +1232,14 @@ bool do_bench_gif_decode(const char* (*decode_func)(wuffs_base__io_buffer*, uint64_t i; uint64_t iters = iters_unscaled * iterscale; for (i = 0; i < iters; i++) { - dst.wi = 0; - src.ri = 0; - const char* error_msg = decode_func(&dst, &src); + got.meta.wi = 0; + src.meta.ri = 0; + const char* error_msg = decode_func(&got, &src); if (error_msg) { FAIL("%s", error_msg); return false; } - n_bytes += dst.wi; + n_bytes += got.meta.wi; } bench_finish(iters, n_bytes); return true; diff --git a/test/c/std/gzip.c b/test/c/std/gzip.c index e512a554..09946e7e 100644 --- a/test/c/std/gzip.c +++ b/test/c/std/gzip.c @@ -114,22 +114,24 @@ const char* wuffs_gzip_decode(wuffs_base__io_buffer* dst, } bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) { - wuffs_base__io_buffer got = - ((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE}); - wuffs_base__io_buffer src = - ((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE}); + wuffs_base__io_buffer got = ((wuffs_base__io_buffer){ + .data = global_got_slice, + }); + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = global_src_slice, + }); if (!read_file(&src, gzip_midsummer_gt.src_filename)) { return false; } // Flip a bit in the gzip checksum, which is in the last 8 bytes of the file. - if (src.wi < 8) { + if (src.meta.wi < 8) { FAIL("source file was too short"); return false; } if (bad_checksum) { - src.ptr[src.wi - 1 - (bad_checksum & 7)] ^= 1; + src.data.ptr[src.meta.wi - 1 - (bad_checksum & 7)] ^= 1; } int end_limit; @@ -142,9 +144,9 @@ bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) { return false; } wuffs_gzip__decoder__set_ignore_checksum(&dec, ignore_checksum); - got.wi = 0; + got.meta.wi = 0; wuffs_base__io_writer got_writer = wuffs_base__io_buffer__writer(&got); - src.ri = 0; + src.meta.ri = 0; // Decode the src data in 1 or 2 chunks, depending on whether end_limit is // or isn't zero. @@ -156,11 +158,11 @@ bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) { if (end_limit == 0) { continue; } - if (src.wi < end_limit) { + if (src.meta.wi < end_limit) { FAIL("end_limit=%d: not enough source data", end_limit); return false; } - set_reader_limit(&src_reader, src.wi - (uint64_t)(end_limit)); + set_reader_limit(&src_reader, src.meta.wi - (uint64_t)(end_limit)); want_z = wuffs_base__suspension__short_read; } else { want_z = (bad_checksum && !ignore_checksum) diff --git a/test/c/std/lzw.c b/test/c/std/lzw.c index ee528390..8a69b038 100644 --- a/test/c/std/lzw.c +++ b/test/c/std/lzw.c @@ -70,33 +70,36 @@ bool do_test_wuffs_lzw_decode(const char* src_filename, uint64_t want_size, uint64_t wlimit, uint64_t rlimit) { - wuffs_base__io_buffer got = - ((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE}); - wuffs_base__io_buffer want = - ((wuffs_base__io_buffer){.ptr = global_want_buffer, .len = BUFFER_SIZE}); - wuffs_base__io_buffer src = - ((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE}); + wuffs_base__io_buffer got = ((wuffs_base__io_buffer){ + .data = global_got_slice, + }); + wuffs_base__io_buffer want = ((wuffs_base__io_buffer){ + .data = global_want_slice, + }); + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = global_src_slice, + }); if (!read_file(&src, src_filename)) { return false; } - if (src.wi != src_size) { - FAIL("src size: got %d, want %d", (int)(src.wi), (int)(src_size)); + if (src.meta.wi != src_size) { + FAIL("src size: got %d, want %d", (int)(src.meta.wi), (int)(src_size)); return false; } // The first byte in that file, the LZW literal width, should be 0x08. - uint8_t literal_width = src.ptr[0]; + uint8_t literal_width = src.data.ptr[0]; if (literal_width != 0x08) { - FAIL("LZW literal width: got %d, want %d", (int)(src.ptr[0]), 0x08); + FAIL("LZW literal width: got %d, want %d", (int)(src.data.ptr[0]), 0x08); return false; } - src.ri++; + src.meta.ri++; if (!read_file(&want, want_filename)) { return false; } - if (want.wi != want_size) { - FAIL("want size: got %d, want %d", (int)(want.wi), (int)(want_size)); + if (want.meta.wi != want_size) { + FAIL("want size: got %d, want %d", (int)(want.meta.wi), (int)(want_size)); return false; } @@ -119,12 +122,12 @@ bool do_test_wuffs_lzw_decode(const char* src_filename, if (rlimit) { set_reader_limit(&src_reader, rlimit); } - size_t old_wi = got.wi; - size_t old_ri = src.ri; + size_t old_wi = got.meta.wi; + size_t old_ri = src.meta.ri; z = wuffs_lzw__decoder__decode(&dec, got_writer, src_reader); if (!z) { - if (src.ri != src.wi) { + if (src.meta.ri != src.meta.wi) { FAIL("decode returned \"ok\" but src was not exhausted"); return false; } @@ -138,15 +141,15 @@ bool do_test_wuffs_lzw_decode(const char* src_filename, return false; } - if (got.wi < old_wi) { + if (got.meta.wi < old_wi) { FAIL("write index got.wi went backwards"); return false; } - if (src.ri < old_ri) { + if (src.meta.ri < old_ri) { FAIL("read index src.ri went backwards"); return false; } - if ((got.wi == old_wi) && (src.ri == old_ri)) { + if ((got.meta.wi == old_wi) && (src.meta.ri == old_ri)) { FAIL("no progress was made"); return false; } @@ -200,23 +203,25 @@ void test_wuffs_lzw_decode_pi() { // ---------------- LZW Benches bool do_bench_wuffs_lzw_decode(const char* filename, uint64_t iters_unscaled) { - wuffs_base__io_buffer dst = - ((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE}); - wuffs_base__io_buffer src = - ((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE}); - wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(&dst); + wuffs_base__io_buffer got = ((wuffs_base__io_buffer){ + .data = global_got_slice, + }); + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = global_src_slice, + }); + wuffs_base__io_writer got_writer = wuffs_base__io_buffer__writer(&got); wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); if (!read_file(&src, filename)) { return false; } - if (src.wi <= 0) { - FAIL("src size: got %d, want > 0", (int)(src.wi)); + if (src.meta.wi <= 0) { + FAIL("src size: got %d, want > 0", (int)(src.meta.wi)); return false; } - uint8_t literal_width = src.ptr[0]; + uint8_t literal_width = src.data.ptr[0]; if (literal_width != 0x08) { - FAIL("LZW literal width: got %d, want %d", (int)(src.ptr[0]), 0x08); + FAIL("LZW literal width: got %d, want %d", (int)(src.data.ptr[0]), 0x08); return false; } @@ -225,8 +230,8 @@ bool do_bench_wuffs_lzw_decode(const char* filename, uint64_t iters_unscaled) { uint64_t i; uint64_t iters = iters_unscaled * iterscale; for (i = 0; i < iters; i++) { - dst.wi = 0; - src.ri = 1; // Skip the literal width. + got.meta.wi = 0; + src.meta.ri = 1; // Skip the literal width. wuffs_lzw__decoder dec = ((wuffs_lzw__decoder){}); wuffs_base__status z = wuffs_lzw__decoder__check_wuffs_version( &dec, sizeof dec, WUFFS_VERSION); @@ -234,12 +239,12 @@ bool do_bench_wuffs_lzw_decode(const char* filename, uint64_t iters_unscaled) { FAIL("check_wuffs_version: \"%s\"", z); return false; } - z = wuffs_lzw__decoder__decode(&dec, dst_writer, src_reader); + z = wuffs_lzw__decoder__decode(&dec, got_writer, src_reader); if (z) { FAIL("decode: \"%s\"", z); return false; } - n_bytes += dst.wi; + n_bytes += got.meta.wi; } bench_finish(iters, n_bytes); return true; diff --git a/test/c/std/zlib.c b/test/c/std/zlib.c index 91a15ab9..46625266 100644 --- a/test/c/std/zlib.c +++ b/test/c/std/zlib.c @@ -114,21 +114,23 @@ const char* wuffs_zlib_decode(wuffs_base__io_buffer* dst, } bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) { - wuffs_base__io_buffer got = - ((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE}); - wuffs_base__io_buffer src = - ((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE}); + wuffs_base__io_buffer got = ((wuffs_base__io_buffer){ + .data = global_got_slice, + }); + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = global_src_slice, + }); if (!read_file(&src, zlib_midsummer_gt.src_filename)) { return false; } // Flip a bit in the zlib checksum, which is in the last 4 bytes of the file. - if (src.wi < 4) { + if (src.meta.wi < 4) { FAIL("source file was too short"); return false; } if (bad_checksum) { - src.ptr[src.wi - 1 - (bad_checksum & 3)] ^= 1; + src.data.ptr[src.meta.wi - 1 - (bad_checksum & 3)] ^= 1; } int end_limit; @@ -141,9 +143,9 @@ bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) { return false; } wuffs_zlib__decoder__set_ignore_checksum(&dec, ignore_checksum); - got.wi = 0; + got.meta.wi = 0; wuffs_base__io_writer got_writer = wuffs_base__io_buffer__writer(&got); - src.ri = 0; + src.meta.ri = 0; // Decode the src data in 1 or 2 chunks, depending on whether end_limit is // or isn't zero. @@ -155,11 +157,11 @@ bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) { if (end_limit == 0) { continue; } - if (src.wi < end_limit) { + if (src.meta.wi < end_limit) { FAIL("end_limit=%d: not enough source data", end_limit); return false; } - set_reader_limit(&src_reader, src.wi - (uint64_t)(end_limit)); + set_reader_limit(&src_reader, src.meta.wi - (uint64_t)(end_limit)); want_z = wuffs_base__suspension__short_read; } else { want_z = (bad_checksum && !ignore_checksum) diff --git a/test/c/testlib/testlib.c b/test/c/testlib/testlib.c index 976beba7..185913fa 100644 --- a/test/c/testlib/testlib.c +++ b/test/c/testlib/testlib.c @@ -23,11 +23,36 @@ #define WUFFS_TESTLIB_ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) -uint8_t global_got_buffer[BUFFER_SIZE]; -uint8_t global_want_buffer[BUFFER_SIZE]; -uint8_t global_work_buffer[BUFFER_SIZE]; -uint8_t global_src_buffer[BUFFER_SIZE]; -uint8_t global_pixel_buffer[BUFFER_SIZE]; +uint8_t global_got_array[BUFFER_SIZE]; +uint8_t global_want_array[BUFFER_SIZE]; +uint8_t global_work_array[BUFFER_SIZE]; +uint8_t global_src_array[BUFFER_SIZE]; +uint8_t global_pixel_array[BUFFER_SIZE]; + +wuffs_base__slice_u8 global_got_slice = ((wuffs_base__slice_u8){ + .ptr = global_got_array, + .len = BUFFER_SIZE, +}); + +wuffs_base__slice_u8 global_want_slice = ((wuffs_base__slice_u8){ + .ptr = global_want_array, + .len = BUFFER_SIZE, +}); + +wuffs_base__slice_u8 global_work_slice = ((wuffs_base__slice_u8){ + .ptr = global_work_array, + .len = BUFFER_SIZE, +}); + +wuffs_base__slice_u8 global_src_slice = ((wuffs_base__slice_u8){ + .ptr = global_src_array, + .len = BUFFER_SIZE, +}); + +wuffs_base__slice_u8 global_pixel_slice = ((wuffs_base__slice_u8){ + .ptr = global_pixel_array, + .len = BUFFER_SIZE, +}); char fail_msg[65536] = {0}; @@ -304,8 +329,8 @@ wuffs_base__rect_ie_u32 make_rect_ie_u32(uint32_t x0, void set_reader_limit(wuffs_base__io_reader* o, uint64_t limit) { if (o && o->private_impl.buf) { - uint8_t* p = o->private_impl.buf->ptr + o->private_impl.buf->ri; - uint8_t* q = o->private_impl.buf->ptr + o->private_impl.buf->wi; + uint8_t* p = o->private_impl.buf->data.ptr + o->private_impl.buf->meta.ri; + uint8_t* q = o->private_impl.buf->data.ptr + o->private_impl.buf->meta.wi; if (!o->private_impl.mark) { o->private_impl.mark = p; o->private_impl.limit = q; @@ -318,8 +343,8 @@ void set_reader_limit(wuffs_base__io_reader* o, uint64_t limit) { void set_writer_limit(wuffs_base__io_writer* o, uint64_t limit) { if (o && o->private_impl.buf) { - uint8_t* p = o->private_impl.buf->ptr + o->private_impl.buf->wi; - uint8_t* q = o->private_impl.buf->ptr + o->private_impl.buf->len; + uint8_t* p = o->private_impl.buf->data.ptr + o->private_impl.buf->meta.wi; + uint8_t* q = o->private_impl.buf->data.ptr + o->private_impl.buf->data.len; if (!o->private_impl.mark) { o->private_impl.mark = p; o->private_impl.limit = q; @@ -345,11 +370,11 @@ const char* copy_to_io_buffer_from_pixel_buffer(wuffs_base__io_buffer* dst, break; } uint32_t n = r.max_excl_x - r.min_incl_x; - if (n > (dst->len - dst->wi)) { + if (n > (dst->data.len - dst->meta.wi)) { return "copy_to_io_buffer_from_pixel_buffer: dst buffer is too small"; } - memmove(dst->ptr + dst->wi, row.ptr + r.min_incl_x, n); - dst->wi += n; + memmove(dst->data.ptr + dst->meta.wi, row.ptr + r.min_incl_x, n); + dst->meta.wi += n; } } return NULL; @@ -360,7 +385,7 @@ bool read_file(wuffs_base__io_buffer* dst, const char* path) { FAIL("read_file: NULL argument"); return false; } - if (dst->closed) { + if (dst->meta.closed) { FAIL("read_file: dst buffer closed for writes"); return false; } @@ -371,8 +396,8 @@ bool read_file(wuffs_base__io_buffer* dst, const char* path) { } uint8_t dummy[1]; - uint8_t* ptr = dst->ptr + dst->wi; - size_t len = dst->len - dst->wi; + uint8_t* ptr = dst->data.ptr + dst->meta.wi; + size_t len = dst->data.len - dst->meta.wi; while (true) { if (!len) { // We have read all that dst can hold. Check that we have read the full @@ -384,7 +409,7 @@ bool read_file(wuffs_base__io_buffer* dst, const char* path) { if (ptr != dummy) { ptr += n; len -= n; - dst->wi += n; + dst->meta.wi += n; } else if (n) { FAIL("read_file(\"%s\"): EOF not reached", path); fclose(f); @@ -406,8 +431,8 @@ bool read_file(wuffs_base__io_buffer* dst, const char* path) { return false; } fclose(f); - dst->pos = 0; - dst->closed = true; + dst->meta.pos = 0; + dst->meta.closed = true; return true; } @@ -416,7 +441,7 @@ char* hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) { FAIL("hex_dump: NULL argument"); return NULL; } - if (buf->wi == 0) { + if (buf->meta.wi == 0) { return msg; } size_t base = i - (i & 15); @@ -426,10 +451,10 @@ char* hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) { continue; } size_t b = base + j; - if (b >= buf->wi) { + if (b >= buf->meta.wi) { break; } - size_t n = buf->wi - b; + size_t n = buf->meta.wi - b; INCR_FAIL(msg, " %06zx:", b); size_t k; for (k = 0; k < 16; k++) { @@ -437,7 +462,7 @@ char* hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) { INCR_FAIL(msg, " "); } if (k < n) { - INCR_FAIL(msg, "%02x", buf->ptr[b + k]); + INCR_FAIL(msg, "%02x", buf->data.ptr[b + k]); } else { INCR_FAIL(msg, " "); } @@ -446,7 +471,7 @@ char* hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) { for (k = 0; k < 16; k++) { char c = ' '; if (k < n) { - c = buf->ptr[b + k]; + c = buf->data.ptr[b + k]; if ((c < 0x20) || (0x7F <= c)) { c = '.'; } @@ -470,16 +495,16 @@ bool io_buffers_equal(const char* prefix, } char* msg = fail_msg; size_t i; - size_t n = got->wi < want->wi ? got->wi : want->wi; + size_t n = got->meta.wi < want->meta.wi ? got->meta.wi : want->meta.wi; for (i = 0; i < n; i++) { - if (got->ptr[i] != want->ptr[i]) { + if (got->data.ptr[i] != want->data.ptr[i]) { break; } } - if (got->wi != want->wi) { + if (got->meta.wi != want->meta.wi) { INCR_FAIL(msg, "%sio_buffers_equal: wi: got %zu, want %zu.\n", prefix, - got->wi, want->wi); - } else if (i < got->wi) { + got->meta.wi, want->meta.wi); + } else if (i < got->meta.wi) { INCR_FAIL(msg, "%sio_buffers_equal: wi=%zu:\n", prefix, n); } else { return true; @@ -520,15 +545,18 @@ bool proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*, return false; } - wuffs_base__io_buffer src = - ((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE}); - wuffs_base__io_buffer got = - ((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE}); - wuffs_base__io_buffer want = - ((wuffs_base__io_buffer){.ptr = global_want_buffer, .len = BUFFER_SIZE}); + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = global_src_slice, + }); + wuffs_base__io_buffer got = ((wuffs_base__io_buffer){ + .data = global_got_slice, + }); + wuffs_base__io_buffer want = ((wuffs_base__io_buffer){ + .data = global_want_slice, + }); if (!gt->src_filename) { - src.closed = true; + src.meta.closed = true; } else if (!read_file(&src, gt->src_filename)) { return false; } @@ -537,12 +565,12 @@ bool proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*, FAIL("inconsistent src_offsets"); return false; } - if (gt->src_offset1 > src.wi) { + if (gt->src_offset1 > src.meta.wi) { FAIL("src_offset1 too large"); return false; } - src.ri = gt->src_offset0; - src.wi = gt->src_offset1; + src.meta.ri = gt->src_offset0; + src.meta.wi = gt->src_offset1; } if (bench) { @@ -552,8 +580,8 @@ bool proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*, uint64_t i; uint64_t iters = iters_unscaled * iterscale; for (i = 0; i < iters; i++) { - got.wi = 0; - src.ri = gt->src_offset0; + got.meta.wi = 0; + src.meta.ri = gt->src_offset0; const char* s = codec_func(&got, &src, wlimit, rlimit); if (s) { FAIL("%s", s); @@ -563,10 +591,10 @@ bool proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*, case tc_neither: break; case tc_dst: - n_bytes += got.wi; + n_bytes += got.meta.wi; break; case tc_src: - n_bytes += src.ri - gt->src_offset0; + n_bytes += src.meta.ri - gt->src_offset0; break; } } @@ -576,7 +604,7 @@ bool proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*, } if (!gt->want_filename) { - want.closed = true; + want.meta.closed = true; } else if (!read_file(&want, gt->want_filename)) { return false; }