From ab7d6de3180b734169f48b5a3a4fda7a363cc083 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sat, 16 Feb 2019 09:02:33 +1100 Subject: [PATCH] Let Wuffs compile with MSVC (Microsoft Visual C++) --- cmd/wuffs-c/internal/cgen/base/core-private.h | 6 +- cmd/wuffs-c/internal/cgen/base/core-public.h | 6 +- cmd/wuffs-c/internal/cgen/base/image-public.h | 28 ++- cmd/wuffs-c/internal/cgen/base/io-private.h | 16 +- cmd/wuffs-c/internal/cgen/base/io-public.h | 4 +- .../internal/cgen/base/memory-public.h | 8 +- cmd/wuffs-c/internal/cgen/cgen.go | 2 +- cmd/wuffs-c/internal/cgen/data.go | 62 +++--- cmd/wuffs-c/internal/cgen/expr.go | 4 +- cmd/wuffs-c/internal/cgen/func.go | 8 +- cmd/wuffs-c/internal/cgen/statement.go | 2 +- cmd/wuffs-c/internal/cgen/var.go | 9 +- release/c/wuffs-unsupported-snapshot.c | 182 ++++++++++-------- 13 files changed, 182 insertions(+), 155 deletions(-) diff --git a/cmd/wuffs-c/internal/cgen/base/core-private.h b/cmd/wuffs-c/internal/cgen/base/core-private.h index a48f55f3..6c099405 100644 --- a/cmd/wuffs-c/internal/cgen/base/core-private.h +++ b/cmd/wuffs-c/internal/cgen/base/core-private.h @@ -83,7 +83,7 @@ wuffs_base__ignore_status(wuffs_base__status z) {} static inline wuffs_base__empty_struct // wuffs_base__return_empty_struct() { - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } // ---------------- Numeric Types @@ -420,14 +420,14 @@ wuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) { .len = t.width, }); } - return ((wuffs_base__slice_u8){}); + return ((wuffs_base__slice_u8){0}); } // ---------------- Slices and Tables (Utility) static inline wuffs_base__slice_u8 // wuffs_base__utility__null_slice_u8() { - return ((wuffs_base__slice_u8){}); + return ((wuffs_base__slice_u8){0}); } // ---------------- Bureaucracy re -Wunused-function diff --git a/cmd/wuffs-c/internal/cgen/base/core-public.h b/cmd/wuffs-c/internal/cgen/base/core-public.h index 0f09e048..8b3d4388 100644 --- a/cmd/wuffs-c/internal/cgen/base/core-public.h +++ b/cmd/wuffs-c/internal/cgen/base/core-public.h @@ -317,7 +317,7 @@ wuffs_base__slice_u8__subslice_i(wuffs_base__slice_u8 s, uint64_t i) { .len = s.len - i, }); } - return ((wuffs_base__slice_u8){}); + return ((wuffs_base__slice_u8){0}); } // wuffs_base__slice_u8__subslice_j returns s[:j]. @@ -331,7 +331,7 @@ wuffs_base__slice_u8__subslice_j(wuffs_base__slice_u8 s, uint64_t j) { .len = j, }); } - return ((wuffs_base__slice_u8){}); + return ((wuffs_base__slice_u8){0}); } // wuffs_base__slice_u8__subslice_ij returns s[i:j]. @@ -347,7 +347,7 @@ wuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s, .len = j - i, }); } - return ((wuffs_base__slice_u8){}); + return ((wuffs_base__slice_u8){0}); } // ---------------- Bureaucracy re -Wunused-function diff --git a/cmd/wuffs-c/internal/cgen/base/image-public.h b/cmd/wuffs-c/internal/cgen/base/image-public.h index 55ccc669..92632e46 100644 --- a/cmd/wuffs-c/internal/cgen/base/image-public.h +++ b/cmd/wuffs-c/internal/cgen/base/image-public.h @@ -374,13 +374,17 @@ wuffs_base__pixel_config__set(wuffs_base__pixel_config* c, return; } } - *c = ((wuffs_base__pixel_config){}); + *c = ((wuffs_base__pixel_config){ + .private_impl = {0}, + }); } static inline void // wuffs_base__pixel_config__invalidate(wuffs_base__pixel_config* c) { if (c) { - *c = ((wuffs_base__pixel_config){}); + *c = ((wuffs_base__pixel_config){ + .private_impl = {0}, + }); } } @@ -407,7 +411,7 @@ wuffs_base__pixel_config__bounds(wuffs_base__pixel_config* c) { .max_excl_x = c->private_impl.width, .max_excl_y = c->private_impl.height, }) - : ((wuffs_base__rect_ie_u32){}); + : ((wuffs_base__rect_ie_u32){0}); } static inline uint32_t // @@ -566,13 +570,19 @@ wuffs_base__image_config__set(wuffs_base__image_config* c, c->private_impl.first_frame_is_opaque = first_frame_is_opaque; return; } - *c = ((wuffs_base__image_config){}); + *c = ((wuffs_base__image_config){ + .pixcfg = {.private_impl = {0}}, + .private_impl = {0}, + }); } static inline void // wuffs_base__image_config__invalidate(wuffs_base__image_config* c) { if (c) { - *c = ((wuffs_base__image_config){}); + *c = ((wuffs_base__image_config){ + .pixcfg = {.private_impl = {0}}, + .private_impl = {0}, + }); } } @@ -719,7 +729,7 @@ wuffs_base__frame_config__update(wuffs_base__frame_config* c, static inline wuffs_base__rect_ie_u32 // wuffs_base__frame_config__bounds(wuffs_base__frame_config* c) { - return c ? c->private_impl.bounds : ((wuffs_base__rect_ie_u32){}); + return c ? c->private_impl.bounds : ((wuffs_base__rect_ie_u32){0}); } static inline uint32_t // @@ -851,7 +861,7 @@ wuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b, if (!b) { return wuffs_base__error__bad_receiver; } - *b = ((wuffs_base__pixel_buffer){}); + memset(b, 0, sizeof(*b)); if (!pixcfg) { return wuffs_base__error__bad_argument; } @@ -923,7 +933,7 @@ wuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* b) { }); } } - return ((wuffs_base__slice_u8){}); + return ((wuffs_base__slice_u8){0}); } static inline wuffs_base__pixel_format // @@ -938,7 +948,7 @@ static inline wuffs_base__table_u8 // wuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* b, uint32_t p) { return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX)) ? b->private_impl.planes[p] - : ((wuffs_base__table_u8){}); + : ((wuffs_base__table_u8){0}); } #ifdef __cplusplus diff --git a/cmd/wuffs-c/internal/cgen/base/io-private.h b/cmd/wuffs-c/internal/cgen/base/io-private.h index e5323815..a2d9d14e 100644 --- a/cmd/wuffs-c/internal/cgen/base/io-private.h +++ b/cmd/wuffs-c/internal/cgen/base/io-private.h @@ -205,7 +205,7 @@ wuffs_base__io_reader__set(wuffs_base__io_reader* o, o->private_impl.limit = data.ptr + data.len; *ptr_iop_r = data.ptr; *ptr_io1_r = data.ptr + data.len; - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } static inline wuffs_base__empty_struct // @@ -215,13 +215,13 @@ wuffs_base__io_reader__set_limit(wuffs_base__io_reader* o, if (o && (((size_t)(o->private_impl.limit - iop_r)) > limit)) { o->private_impl.limit = iop_r + limit; } - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } static inline wuffs_base__empty_struct // wuffs_base__io_reader__set_mark(wuffs_base__io_reader* o, uint8_t* mark) { o->private_impl.mark = mark; - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } static inline wuffs_base__slice_u8 // @@ -234,7 +234,7 @@ wuffs_base__io_reader__take(uint8_t** ptr_iop_r, uint8_t* io1_r, uint64_t n) { .len = n, }); } - return ((wuffs_base__slice_u8){}); + return ((wuffs_base__slice_u8){0}); } static inline wuffs_base__empty_struct // @@ -254,25 +254,25 @@ wuffs_base__io_writer__set(wuffs_base__io_writer* o, o->private_impl.limit = data.ptr + data.len; *ptr_iop_w = data.ptr; *ptr_io1_w = data.ptr + data.len; - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } static inline wuffs_base__empty_struct // wuffs_base__io_writer__set_mark(wuffs_base__io_writer* o, uint8_t* mark) { o->private_impl.mark = mark; - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } // ---------------- I/O (Utility) static inline wuffs_base__io_reader // wuffs_base__utility__null_io_reader() { - return ((wuffs_base__io_reader){}); + return ((wuffs_base__io_reader){.private_impl = {0}}); } static inline wuffs_base__io_writer // wuffs_base__utility__null_io_writer() { - return ((wuffs_base__io_writer){}); + return ((wuffs_base__io_writer){.private_impl = {0}}); } // ---------------- Bureaucracy re -Wunused-function diff --git a/cmd/wuffs-c/internal/cgen/base/io-public.h b/cmd/wuffs-c/internal/cgen/base/io-public.h index 61affe21..fef95484 100644 --- a/cmd/wuffs-c/internal/cgen/base/io-public.h +++ b/cmd/wuffs-c/internal/cgen/base/io-public.h @@ -89,14 +89,14 @@ wuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) { static inline wuffs_base__io_reader // wuffs_base__io_buffer__reader(wuffs_base__io_buffer* buf) { - wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); + wuffs_base__io_reader ret = ((wuffs_base__io_reader){.private_impl = {0}}); ret.private_impl.buf = buf; return ret; } static inline wuffs_base__io_writer // wuffs_base__io_buffer__writer(wuffs_base__io_buffer* buf) { - wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); + wuffs_base__io_writer ret = ((wuffs_base__io_writer){.private_impl = {0}}); ret.private_impl.buf = buf; return ret; } diff --git a/cmd/wuffs-c/internal/cgen/base/memory-public.h b/cmd/wuffs-c/internal/cgen/base/memory-public.h index 0d8c6621..111115ec 100644 --- a/cmd/wuffs-c/internal/cgen/base/memory-public.h +++ b/cmd/wuffs-c/internal/cgen/base/memory-public.h @@ -40,7 +40,7 @@ wuffs_base__malloc_slice_u8(void* (*malloc_func)(size_t), uint64_t num_u8) { }); } } - return ((wuffs_base__slice_u8){}); + return ((wuffs_base__slice_u8){0}); } static inline wuffs_base__slice_u16 // @@ -54,7 +54,7 @@ wuffs_base__malloc_slice_u16(void* (*malloc_func)(size_t), uint64_t num_u16) { }); } } - return ((wuffs_base__slice_u16){}); + return ((wuffs_base__slice_u16){0}); } static inline wuffs_base__slice_u32 // @@ -68,7 +68,7 @@ wuffs_base__malloc_slice_u32(void* (*malloc_func)(size_t), uint64_t num_u32) { }); } } - return ((wuffs_base__slice_u32){}); + return ((wuffs_base__slice_u32){0}); } static inline wuffs_base__slice_u64 // @@ -82,7 +82,7 @@ wuffs_base__malloc_slice_u64(void* (*malloc_func)(size_t), uint64_t num_u64) { }); } } - return ((wuffs_base__slice_u64){}); + return ((wuffs_base__slice_u64){0}); } // ---------------- Bureaucracy re -Wunused-function diff --git a/cmd/wuffs-c/internal/cgen/cgen.go b/cmd/wuffs-c/internal/cgen/cgen.go index c05446b4..7452ff91 100644 --- a/cmd/wuffs-c/internal/cgen/cgen.go +++ b/cmd/wuffs-c/internal/cgen/cgen.go @@ -1057,7 +1057,7 @@ func (g *gen) writeInitializerImpl(b *buffer, n *a.Struct) error { if err := g.writeSizeofSignature(b, n); err != nil { return err } - b.printf("{ return sizeof((%s%s){}); }\n\n", g.pkgPrefix, n.QID().Str(g.tm)) + b.printf("{ return sizeof (%s%s); }\n\n", g.pkgPrefix, n.QID().Str(g.tm)) } return nil } diff --git a/cmd/wuffs-c/internal/cgen/data.go b/cmd/wuffs-c/internal/cgen/data.go index f7f2c350..f04421e6 100644 --- a/cmd/wuffs-c/internal/cgen/data.go +++ b/cmd/wuffs-c/internal/cgen/data.go @@ -34,7 +34,7 @@ const baseImageImplC = "" + const baseCorePrivateH = "" + "static inline void //\nwuffs_base__ignore_status(wuffs_base__status z) {}\n\n// WUFFS_BASE__MAGIC is a magic number to check that initializers are called.\n// It's not foolproof, given C doesn't automatically zero memory before use,\n// but it should catch 99.99% of cases.\n//\n// Its (non-zero) value is arbitrary, based on md5sum(\"wuffs\").\n#define WUFFS_BASE__MAGIC ((uint32_t)0x3CCB6C71)\n\n// WUFFS_BASE__DISABLED is a magic number to indicate that a non-recoverable\n// error was previously encountered.\n//\n// Its (non-zero) value is arbitrary, based on md5sum(\"disabled\").\n#define WUFFS_BASE__DISABLED ((uint32_t)0x075AE3D2)\n\n// Denote intentional fallthroughs for -Wimplicit-fallthrough.\n//\n// The order matters here. Clang also defines \"__GNUC__\".\n#if defined(__clang__) && __cplusplus >= 201103L\n#define WUFFS_BASE__FALLTHROUGH [[clang::fallthrough]]\n#elif !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 7)\n#define WUFFS_BASE__FALLTHROUGH __attribute__((fallthrough))\n#else\n#define WUFFS_BASE__FALLTHROUGH\n#endif\n" + "\n// Use switch cases for coroutine suspension points, similar to the technique\n// in https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html\n//\n// We use trivial macros instead of an explicit assignment and case statement\n// so that clang-format doesn't get confused by the unusual \"case\"s.\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0 case 0:;\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT(n) \\\n coro_susp_point = n; \\\n WUFFS_BASE__FALLTHROUGH; \\\n case n:;\n\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \\\n if (!status) { \\\n goto ok; \\\n } else if (*status != '$') { \\\n goto exit; \\\n } \\\n coro_susp_point = n; \\\n goto suspend; " + - " \\\n case n:;\n\n// Clang also defines \"__GNUC__\".\n#if defined(__GNUC__)\n#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1))\n#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))\n#else\n#define WUFFS_BASE__LIKELY(expr) (expr)\n#define WUFFS_BASE__UNLIKELY(expr) (expr)\n#endif\n\n// The helpers below are functions, instead of macros, because their arguments\n// can be an expression that we shouldn't evaluate more than once.\n//\n// They are static, so that linking multiple wuffs .o files won't complain about\n// duplicate function definitions.\n//\n// They are explicitly marked inline, even if modern compilers don't use the\n// inline attribute to guide optimizations such as inlining, to avoid the\n// -Wunused-function warning, and we like to compile with -Wall -Werror.\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__return_empty_struct() {\n return ((wuffs_base__empty_struct){});\n}\n\n" + + " \\\n case n:;\n\n// Clang also defines \"__GNUC__\".\n#if defined(__GNUC__)\n#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1))\n#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))\n#else\n#define WUFFS_BASE__LIKELY(expr) (expr)\n#define WUFFS_BASE__UNLIKELY(expr) (expr)\n#endif\n\n// The helpers below are functions, instead of macros, because their arguments\n// can be an expression that we shouldn't evaluate more than once.\n//\n// They are static, so that linking multiple wuffs .o files won't complain about\n// duplicate function definitions.\n//\n// They are explicitly marked inline, even if modern compilers don't use the\n// inline attribute to guide optimizations such as inlining, to avoid the\n// -Wunused-function warning, and we like to compile with -Wall -Werror.\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__return_empty_struct() {\n return ((wuffs_base__empty_struct){0});\n}\n\n" + "" + "// ---------------- Numeric Types\n\nstatic inline uint8_t //\nwuffs_base__load_u8be(uint8_t* p) {\n return p[0];\n}\n\nstatic inline uint16_t //\nwuffs_base__load_u16be(uint8_t* p) {\n return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0);\n}\n\nstatic inline uint16_t //\nwuffs_base__load_u16le(uint8_t* p) {\n return ((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8);\n}\n\nstatic inline uint32_t //\nwuffs_base__load_u24be(uint8_t* p) {\n return ((uint32_t)(p[0]) << 16) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 0);\n}\n\nstatic inline uint32_t //\nwuffs_base__load_u24le(uint8_t* p) {\n return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 16);\n}\n\nstatic inline uint32_t //\nwuffs_base__load_u32be(uint8_t* p) {\n return ((uint32_t)(p[0]) << 24) | ((uint32_t)(p[1]) << 16) |\n ((uint32_t)(p[2]) << 8) | ((uint32_t)(p[3]) << 0);\n}\n\nstatic inline uint32_t //\nwuffs_base__load_u32le(uint8_t* p) {\n return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |\n ((uin" + "t32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24);\n}\n\nstatic inline uint64_t //\nwuffs_base__load_u40be(uint8_t* p) {\n return ((uint64_t)(p[0]) << 32) | ((uint64_t)(p[1]) << 24) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 8) |\n ((uint64_t)(p[4]) << 0);\n}\n\nstatic inline uint64_t //\nwuffs_base__load_u40le(uint8_t* p) {\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32);\n}\n\nstatic inline uint64_t //\nwuffs_base__load_u48be(uint8_t* p) {\n return ((uint64_t)(p[0]) << 40) | ((uint64_t)(p[1]) << 32) |\n ((uint64_t)(p[2]) << 24) | ((uint64_t)(p[3]) << 16) |\n ((uint64_t)(p[4]) << 8) | ((uint64_t)(p[5]) << 0);\n}\n\nstatic inline uint64_t //\nwuffs_base__load_u48le(uint8_t* p) {\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40);\n}\n\nstatic inline u" + @@ -52,9 +52,9 @@ const baseCorePrivateH = "" + "// ---------------- Slices and Tables\n\n// wuffs_base__slice_u8__prefix returns up to the first up_to bytes of s.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__prefix(wuffs_base__slice_u8 s, uint64_t up_to) {\n if ((uint64_t)(s.len) > up_to) {\n s.len = up_to;\n }\n return s;\n}\n\n// wuffs_base__slice_u8__suffix returns up to the last up_to bytes of s.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__suffix(wuffs_base__slice_u8 s, uint64_t up_to) {\n if ((uint64_t)(s.len) > up_to) {\n s.ptr += (uint64_t)(s.len) - up_to;\n s.len = up_to;\n }\n return s;\n}\n\n// wuffs_base__slice_u8__copy_from_slice calls memmove(dst.ptr, src.ptr, len)\n// where len is the minimum of dst.len and src.len.\n//\n// Passing a wuffs_base__slice_u8 with all fields NULL or zero (a valid, empty\n// slice) is valid and results in a no-op.\nstatic inline uint64_t //\nwuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src) {\n size_t len = dst.l" + "en < src.len ? dst.len : src.len;\n if (len > 0) {\n memmove(dst.ptr, src.ptr, len);\n }\n return len;\n}\n\n" + "" + - "// --------\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) {\n if (y < t.height) {\n return ((wuffs_base__slice_u8){\n .ptr = t.ptr + (t.stride * y),\n .len = t.width,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\n" + + "// --------\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) {\n if (y < t.height) {\n return ((wuffs_base__slice_u8){\n .ptr = t.ptr + (t.stride * y),\n .len = t.width,\n });\n }\n return ((wuffs_base__slice_u8){0});\n}\n\n" + "" + - "// ---------------- Slices and Tables (Utility)\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__utility__null_slice_u8() {\n return ((wuffs_base__slice_u8){});\n}\n\n" + + "// ---------------- Slices and Tables (Utility)\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__utility__null_slice_u8() {\n return ((wuffs_base__slice_u8){0});\n}\n\n" + "" + "// ---------------- Bureaucracy re -Wunused-function\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__core_private()\n WUFFS_BASE__POTENTIALLY_UNUSED;\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__core_private() {\n (void)(wuffs_base__ignore_status);\n (void)(wuffs_base__load_u16be);\n (void)(wuffs_base__load_u16le);\n (void)(wuffs_base__load_u24be);\n (void)(wuffs_base__load_u24le);\n (void)(wuffs_base__load_u32be);\n (void)(wuffs_base__load_u32le);\n (void)(wuffs_base__load_u40be);\n (void)(wuffs_base__load_u40le);\n (void)(wuffs_base__load_u48be);\n (void)(wuffs_base__load_u48le);\n (void)(wuffs_base__load_u56be);\n (void)(wuffs_base__load_u56le);\n (void)(wuffs_base__load_u64be);\n (void)(wuffs_base__load_u64le);\n (void)(wuffs_base__load_u8be);\n (void)(wuffs_base__return_empty_struct);\n (void)(wuffs_base__slice_u8__copy_from_slice);\n (void)(wuffs_base__slice_u8__prefix);\n (void)(wuffs_base__slice_u8__suffix);\n (void)(wuffs_base__store_u16be);\n " + "(void)(wuffs_base__store_u16le);\n (void)(wuffs_base__store_u24be);\n (void)(wuffs_base__store_u24le);\n (void)(wuffs_base__store_u32be);\n (void)(wuffs_base__store_u32le);\n (void)(wuffs_base__store_u40be);\n (void)(wuffs_base__store_u40le);\n (void)(wuffs_base__store_u48be);\n (void)(wuffs_base__store_u48le);\n (void)(wuffs_base__store_u56be);\n (void)(wuffs_base__store_u56le);\n (void)(wuffs_base__store_u64be);\n (void)(wuffs_base__store_u64le);\n (void)(wuffs_base__store_u8be);\n (void)(wuffs_base__table_u8__row);\n (void)(wuffs_base__u16__sat_add_indirect);\n (void)(wuffs_base__u16__sat_sub_indirect);\n (void)(wuffs_base__u32__sat_add_indirect);\n (void)(wuffs_base__u32__sat_sub_indirect);\n (void)(wuffs_base__u64__sat_add_indirect);\n (void)(wuffs_base__u64__sat_sub_indirect);\n (void)(wuffs_base__u8__sat_add_indirect);\n (void)(wuffs_base__u8__sat_sub_indirect);\n (void)(wuffs_base__utility__null_slice_u8);\n}\n" + @@ -79,8 +79,8 @@ const baseCorePublicH = "" + "_u32__sat_sub(uint32_t x, uint32_t y) {\n uint32_t res = x - y;\n res &= -(res <= x);\n return res;\n}\n\nstatic inline uint64_t //\nwuffs_base__u64__sat_add(uint64_t x, uint64_t y) {\n uint64_t res = x + y;\n res |= -(res < x);\n return res;\n}\n\nstatic inline uint64_t //\nwuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {\n uint64_t res = x - y;\n res &= -(res <= x);\n return res;\n}\n\n" + "" + "// ---------------- Slices and Tables\n\n// WUFFS_BASE__SLICE is a 1-dimensional buffer.\n//\n// len measures a number of elements, not necessarily a size in bytes.\n//\n// A value with all fields NULL or zero is a valid, empty slice.\n#define WUFFS_BASE__SLICE(T) \\\n struct { \\\n T* ptr; \\\n size_t len; \\\n }\n\n// WUFFS_BASE__TABLE is a 2-dimensional buffer.\n//\n// width height, and stride measure a number of elements, not necessarily a\n// size in bytes.\n//\n// A value with all fields NULL or zero is a valid, empty table.\n#define WUFFS_BASE__TABLE(T) \\\n struct { \\\n T* ptr; \\\n size_t width; \\\n size_t height; \\\n size_t stride; \\\n }\n\ntypedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8;\ntypedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16;\ntypedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32;\ntypedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64;\n\ntypedef WUFFS_BASE__TABLE(u" + - "int8_t) wuffs_base__table_u8;\ntypedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16;\ntypedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32;\ntypedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;\n\n// wuffs_base__slice_u8__subslice_i returns s[i:].\n//\n// It returns an empty slice if i is out of bounds.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__subslice_i(wuffs_base__slice_u8 s, uint64_t i) {\n if ((i <= SIZE_MAX) && (i <= s.len)) {\n return ((wuffs_base__slice_u8){\n .ptr = s.ptr + i,\n .len = s.len - i,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\n// wuffs_base__slice_u8__subslice_j returns s[:j].\n//\n// It returns an empty slice if j is out of bounds.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__subslice_j(wuffs_base__slice_u8 s, uint64_t j) {\n if ((j <= SIZE_MAX) && (j <= s.len)) {\n return ((wuffs_base__slice_u8){\n .ptr = s.ptr,\n .len = j,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\n// wuffs_base__slice_u8__subslice_" + - "ij returns s[i:j].\n//\n// It returns an empty slice if i or j is out of bounds.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s,\n uint64_t i,\n uint64_t j) {\n if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) {\n return ((wuffs_base__slice_u8){\n .ptr = s.ptr + i,\n .len = j - i,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\n" + + "int8_t) wuffs_base__table_u8;\ntypedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16;\ntypedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32;\ntypedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;\n\n// wuffs_base__slice_u8__subslice_i returns s[i:].\n//\n// It returns an empty slice if i is out of bounds.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__subslice_i(wuffs_base__slice_u8 s, uint64_t i) {\n if ((i <= SIZE_MAX) && (i <= s.len)) {\n return ((wuffs_base__slice_u8){\n .ptr = s.ptr + i,\n .len = s.len - i,\n });\n }\n return ((wuffs_base__slice_u8){0});\n}\n\n// wuffs_base__slice_u8__subslice_j returns s[:j].\n//\n// It returns an empty slice if j is out of bounds.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__subslice_j(wuffs_base__slice_u8 s, uint64_t j) {\n if ((j <= SIZE_MAX) && (j <= s.len)) {\n return ((wuffs_base__slice_u8){\n .ptr = s.ptr,\n .len = j,\n });\n }\n return ((wuffs_base__slice_u8){0});\n}\n\n// wuffs_base__slice_u8__subslic" + + "e_ij returns s[i:j].\n//\n// It returns an empty slice if i or j is out of bounds.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s,\n uint64_t i,\n uint64_t j) {\n if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) {\n return ((wuffs_base__slice_u8){\n .ptr = s.ptr + i,\n .len = j - i,\n });\n }\n return ((wuffs_base__slice_u8){0});\n}\n\n" + "" + "// ---------------- Bureaucracy re -Wunused-function\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__core_public()\n WUFFS_BASE__POTENTIALLY_UNUSED;\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__core_public() {\n (void)(wuffs_base__slice_u8__subslice_i);\n (void)(wuffs_base__slice_u8__subslice_ij);\n (void)(wuffs_base__slice_u8__subslice_j);\n (void)(wuffs_base__status__is_complete);\n (void)(wuffs_base__status__is_error);\n (void)(wuffs_base__status__is_ok);\n (void)(wuffs_base__status__is_suspension);\n (void)(wuffs_base__status__is_warning);\n (void)(wuffs_base__u16__max);\n (void)(wuffs_base__u16__min);\n (void)(wuffs_base__u16__sat_add);\n (void)(wuffs_base__u16__sat_sub);\n (void)(wuffs_base__u32__max);\n (void)(wuffs_base__u32__min);\n (void)(wuffs_base__u32__sat_add);\n (void)(wuffs_base__u32__sat_sub);\n (void)(wuffs_base__u64__max);\n (void)(wuffs_base__u64__min);\n (void)(wuffs_base__u64__sat_add);\n (void)(wuffs_base__u64__sat_sub);\n (void)(" + "wuffs_base__u8__max);\n (void)(wuffs_base__u8__min);\n (void)(wuffs_base__u8__sat_add);\n (void)(wuffs_base__u8__sat_sub);\n}\n" + @@ -91,9 +91,9 @@ const baseMemoryPrivateH = "" + "" const baseMemoryPublicH = "" + - "// ---------------- 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" + + "// ---------------- 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){0});\n}\n\nstatic inl" + + "ine 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){0});\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){0});\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 = (uint64_t*)(p),\n .len = num_u64,\n });\n }\n }\n return ((wuffs_base__slice_u64){0});\n}\n\n" + "" + "// ---------------- Bureaucracy re -Wunused-function\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__memory_public()\n WUFFS_BASE__POTENTIALLY_UNUSED;\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__memory_public() {\n (void)(wuffs_base__malloc_slice_u16);\n (void)(wuffs_base__malloc_slice_u32);\n (void)(wuffs_base__malloc_slice_u64);\n (void)(wuffs_base__malloc_slice_u8);\n}\n" + "" @@ -122,33 +122,33 @@ const baseImagePublicH = "" + " uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 2;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_subsampling__shift_y(wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 0;\n return (s >> shift) & 0x03;\n}\n\n" + "" + "// --------\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__pixel_format pixfmt;\n wuffs_base__pixel_subsampling pixsub;\n uint32_t width;\n uint32_t height;\n } private_impl;\n\n#ifdef __cplusplus\n // TODO: deprecated. This is for transitioning pre-v0.2 code.\n inline void initialize(wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height);\n\n inline void set(wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height);\n inline void invalidate();\n inline bool is_valid();\n inline wuffs_base__pixel_format pixel_format();\n inline wuffs_base__pixel_subsampling pixel_subsampling();\n inline wuffs_base__rect_ie_u32 bounds();\n inline uint32_t width();\n inline uint32_" + - "t height();\n inline uint64_t pixbuf_len();\n#endif // __cplusplus\n\n} wuffs_base__pixel_config;\n\n// TODO: Should this function return bool? An error type?\nstatic inline void //\nwuffs_base__pixel_config__set(wuffs_base__pixel_config* c,\n wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height) {\n if (!c) {\n return;\n }\n if (pixfmt) {\n uint64_t wh = ((uint64_t)width) * ((uint64_t)height);\n // TODO: handle things other than 1 byte per pixel.\n if (wh <= ((uint64_t)SIZE_MAX)) {\n c->private_impl.pixfmt = pixfmt;\n c->private_impl.pixsub = pixsub;\n c->private_impl.width = width;\n c->private_impl.height = height;\n return;\n }\n }\n *c = ((wuffs_base__pixel_config){});\n}\n\nstatic inline void //\nwuffs_base__pixel_config__invalidate(wuffs_base__pixel_config* c) {\n if (c) {\n *c = ((wuffs_base__pixel_config){});\n " + - "}\n}\n\nstatic inline bool //\nwuffs_base__pixel_config__is_valid(wuffs_base__pixel_config* c) {\n return c && c->private_impl.pixfmt;\n}\n\nstatic inline wuffs_base__pixel_format //\nwuffs_base__pixel_config__pixel_format(wuffs_base__pixel_config* c) {\n return c ? c->private_impl.pixfmt : 0;\n}\n\nstatic inline wuffs_base__pixel_subsampling //\nwuffs_base__pixel_config__pixel_subsampling(wuffs_base__pixel_config* c) {\n return c ? c->private_impl.pixsub : 0;\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__pixel_config__bounds(wuffs_base__pixel_config* c) {\n return c ? ((wuffs_base__rect_ie_u32){\n .min_incl_x = 0,\n .min_incl_y = 0,\n .max_excl_x = c->private_impl.width,\n .max_excl_y = c->private_impl.height,\n })\n : ((wuffs_base__rect_ie_u32){});\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_config__width(wuffs_base__pixel_config* c) {\n return c ? c->private_impl.width : 0;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_" + - "config__height(wuffs_base__pixel_config* c) {\n return c ? c->private_impl.height : 0;\n}\n\n// TODO: this is the right API for planar (not packed) pixbufs? Should it allow\n// decoding into a color model different from the format's intrinsic one? For\n// example, decoding a JPEG image straight to RGBA instead of to YCbCr?\nstatic inline uint64_t //\nwuffs_base__pixel_config__pixbuf_len(wuffs_base__pixel_config* c) {\n if (!c) {\n return 0;\n }\n if (wuffs_base__pixel_format__is_planar(c->private_impl.pixfmt)) {\n // TODO: support planar pixel formats, concious of pixel subsampling.\n return 0;\n }\n uint32_t bits_per_pixel =\n wuffs_base__pixel_format__bits_per_pixel(c->private_impl.pixfmt);\n if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {\n // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?\n return 0;\n }\n uint64_t bytes_per_pixel = bits_per_pixel / 8;\n\n uint64_t n =\n ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);\n if (n > (UINT64_MAX / byt" + - "es_per_pixel)) {\n return 0;\n }\n n *= bytes_per_pixel;\n\n if (wuffs_base__pixel_format__is_indexed(c->private_impl.pixfmt)) {\n if (n > (UINT64_MAX - 1024)) {\n return 0;\n }\n n += 1024;\n }\n\n return n;\n}\n\n#ifdef __cplusplus\n\n// TODO: deprecated. This is for transitioning pre-v0.2 code.\ninline void //\nwuffs_base__pixel_config::initialize(wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height) {\n wuffs_base__pixel_config__set(this, pixfmt, pixsub, width, height);\n}\n\ninline void //\nwuffs_base__pixel_config::set(wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height) {\n wuffs_base__pixel_config__set(this, pixfmt, pixsub, width, height);\n}\n\ninline void //\nwuffs_base__pixel_config::invalidate() {\n wuf" + - "fs_base__pixel_config__invalidate(this);\n}\n\ninline bool //\nwuffs_base__pixel_config::is_valid() {\n return wuffs_base__pixel_config__is_valid(this);\n}\n\ninline wuffs_base__pixel_format //\nwuffs_base__pixel_config::pixel_format() {\n return wuffs_base__pixel_config__pixel_format(this);\n}\n\ninline wuffs_base__pixel_subsampling //\nwuffs_base__pixel_config::pixel_subsampling() {\n return wuffs_base__pixel_config__pixel_subsampling(this);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__pixel_config::bounds() {\n return wuffs_base__pixel_config__bounds(this);\n}\n\ninline uint32_t //\nwuffs_base__pixel_config::width() {\n return wuffs_base__pixel_config__width(this);\n}\n\ninline uint32_t //\nwuffs_base__pixel_config::height() {\n return wuffs_base__pixel_config__height(this);\n}\n\ninline uint64_t //\nwuffs_base__pixel_config::pixbuf_len() {\n return wuffs_base__pixel_config__pixbuf_len(this);\n}\n\n#endif // __cplusplus\n\n" + + "t height();\n inline uint64_t pixbuf_len();\n#endif // __cplusplus\n\n} wuffs_base__pixel_config;\n\n// TODO: Should this function return bool? An error type?\nstatic inline void //\nwuffs_base__pixel_config__set(wuffs_base__pixel_config* c,\n wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height) {\n if (!c) {\n return;\n }\n if (pixfmt) {\n uint64_t wh = ((uint64_t)width) * ((uint64_t)height);\n // TODO: handle things other than 1 byte per pixel.\n if (wh <= ((uint64_t)SIZE_MAX)) {\n c->private_impl.pixfmt = pixfmt;\n c->private_impl.pixsub = pixsub;\n c->private_impl.width = width;\n c->private_impl.height = height;\n return;\n }\n }\n *c = ((wuffs_base__pixel_config){\n .private_impl = {0},\n });\n}\n\nstatic inline void //\nwuffs_base__pixel_config__invalidate(wuffs_base__pixel_config* c) {\n if (c) {\n *c = ((wu" + + "ffs_base__pixel_config){\n .private_impl = {0},\n });\n }\n}\n\nstatic inline bool //\nwuffs_base__pixel_config__is_valid(wuffs_base__pixel_config* c) {\n return c && c->private_impl.pixfmt;\n}\n\nstatic inline wuffs_base__pixel_format //\nwuffs_base__pixel_config__pixel_format(wuffs_base__pixel_config* c) {\n return c ? c->private_impl.pixfmt : 0;\n}\n\nstatic inline wuffs_base__pixel_subsampling //\nwuffs_base__pixel_config__pixel_subsampling(wuffs_base__pixel_config* c) {\n return c ? c->private_impl.pixsub : 0;\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__pixel_config__bounds(wuffs_base__pixel_config* c) {\n return c ? ((wuffs_base__rect_ie_u32){\n .min_incl_x = 0,\n .min_incl_y = 0,\n .max_excl_x = c->private_impl.width,\n .max_excl_y = c->private_impl.height,\n })\n : ((wuffs_base__rect_ie_u32){0});\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_config__width(wuffs_base__pixel_config* c) {\n return c ? c->private" + + "_impl.width : 0;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_config__height(wuffs_base__pixel_config* c) {\n return c ? c->private_impl.height : 0;\n}\n\n// TODO: this is the right API for planar (not packed) pixbufs? Should it allow\n// decoding into a color model different from the format's intrinsic one? For\n// example, decoding a JPEG image straight to RGBA instead of to YCbCr?\nstatic inline uint64_t //\nwuffs_base__pixel_config__pixbuf_len(wuffs_base__pixel_config* c) {\n if (!c) {\n return 0;\n }\n if (wuffs_base__pixel_format__is_planar(c->private_impl.pixfmt)) {\n // TODO: support planar pixel formats, concious of pixel subsampling.\n return 0;\n }\n uint32_t bits_per_pixel =\n wuffs_base__pixel_format__bits_per_pixel(c->private_impl.pixfmt);\n if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {\n // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?\n return 0;\n }\n uint64_t bytes_per_pixel = bits_per_pixel / 8;\n\n uint64_t n =\n ((uint64_t)c->private_impl.width) " + + "* ((uint64_t)c->private_impl.height);\n if (n > (UINT64_MAX / bytes_per_pixel)) {\n return 0;\n }\n n *= bytes_per_pixel;\n\n if (wuffs_base__pixel_format__is_indexed(c->private_impl.pixfmt)) {\n if (n > (UINT64_MAX - 1024)) {\n return 0;\n }\n n += 1024;\n }\n\n return n;\n}\n\n#ifdef __cplusplus\n\n// TODO: deprecated. This is for transitioning pre-v0.2 code.\ninline void //\nwuffs_base__pixel_config::initialize(wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height) {\n wuffs_base__pixel_config__set(this, pixfmt, pixsub, width, height);\n}\n\ninline void //\nwuffs_base__pixel_config::set(wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height) {\n wuffs_base__pixel_config__set(this, pixfmt, pixsub, width, height);\n" + + "}\n\ninline void //\nwuffs_base__pixel_config::invalidate() {\n wuffs_base__pixel_config__invalidate(this);\n}\n\ninline bool //\nwuffs_base__pixel_config::is_valid() {\n return wuffs_base__pixel_config__is_valid(this);\n}\n\ninline wuffs_base__pixel_format //\nwuffs_base__pixel_config::pixel_format() {\n return wuffs_base__pixel_config__pixel_format(this);\n}\n\ninline wuffs_base__pixel_subsampling //\nwuffs_base__pixel_config::pixel_subsampling() {\n return wuffs_base__pixel_config__pixel_subsampling(this);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__pixel_config::bounds() {\n return wuffs_base__pixel_config__bounds(this);\n}\n\ninline uint32_t //\nwuffs_base__pixel_config::width() {\n return wuffs_base__pixel_config__width(this);\n}\n\ninline uint32_t //\nwuffs_base__pixel_config::height() {\n return wuffs_base__pixel_config__height(this);\n}\n\ninline uint64_t //\nwuffs_base__pixel_config::pixbuf_len() {\n return wuffs_base__pixel_config__pixbuf_len(this);\n}\n\n#endif // __cplusplus\n\n" + "" + "// --------\n\ntypedef struct {\n wuffs_base__pixel_config pixcfg;\n\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 uint64_t first_frame_io_position;\n bool first_frame_is_opaque;\n } private_impl;\n\n#ifdef __cplusplus\n inline void set(wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height,\n uint64_t first_frame_io_position,\n bool first_frame_is_opaque);\n inline void invalidate();\n inline bool is_valid();\n inline uint64_t first_frame_io_position();\n inline bool first_frame_is_opaque();\n#endif // __cplusplus\n\n} wuffs_base__image_config;\n\n// TODO: Should this function return bool? An error type?\nstatic inline void //\nwuffs_base__image_config__set(wuffs_base__image_config* c,\n wuffs_base__pixel_format pixfmt,\n wuffs_base__" + - "pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height,\n uint64_t first_frame_io_position,\n bool first_frame_is_opaque) {\n if (!c) {\n return;\n }\n if (wuffs_base__pixel_format__is_valid(pixfmt)) {\n c->pixcfg.private_impl.pixfmt = pixfmt;\n c->pixcfg.private_impl.pixsub = pixsub;\n c->pixcfg.private_impl.width = width;\n c->pixcfg.private_impl.height = height;\n c->private_impl.first_frame_io_position = first_frame_io_position;\n c->private_impl.first_frame_is_opaque = first_frame_is_opaque;\n return;\n }\n *c = ((wuffs_base__image_config){});\n}\n\nstatic inline void //\nwuffs_base__image_config__invalidate(wuffs_base__image_config* c) {\n if (c) {\n *c = ((wuffs_base__image_config){});\n }\n}\n\nstatic inline bool //\nwuffs_base__image_config__is_valid(wuffs_base__image_config* c) {\n return c && wuffs_base__pixel_config__is_valid(&(c->pixcfg));\n}\n\nstatic inline uint64_t /" + - "/\nwuffs_base__image_config__first_frame_io_position(wuffs_base__image_config* c) {\n return c ? c->private_impl.first_frame_io_position : 0;\n}\n\nstatic inline bool //\nwuffs_base__image_config__first_frame_is_opaque(wuffs_base__image_config* c) {\n return c ? c->private_impl.first_frame_is_opaque : false;\n}\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__image_config::set(wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height,\n uint64_t first_frame_io_position,\n bool first_frame_is_opaque) {\n wuffs_base__image_config__set(this, pixfmt, pixsub, width, height,\n first_frame_io_position, first_frame_is_opaque);\n}\n\ninline void //\nwuffs_base__image_config::invalidate() {\n wuffs_base__image_config__invalidate(this);\n}\n\ninline bool //\nwuffs_base__image_config::is_valid() {\n return wuffs_ba" + - "se__image_config__is_valid(this);\n}\n\ninline uint64_t //\nwuffs_base__image_config::first_frame_io_position() {\n return wuffs_base__image_config__first_frame_io_position(this);\n}\n\ninline bool //\nwuffs_base__image_config::first_frame_is_opaque() {\n return wuffs_base__image_config__first_frame_is_opaque(this);\n}\n\n#endif // __cplusplus\n\n" + + "pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height,\n uint64_t first_frame_io_position,\n bool first_frame_is_opaque) {\n if (!c) {\n return;\n }\n if (wuffs_base__pixel_format__is_valid(pixfmt)) {\n c->pixcfg.private_impl.pixfmt = pixfmt;\n c->pixcfg.private_impl.pixsub = pixsub;\n c->pixcfg.private_impl.width = width;\n c->pixcfg.private_impl.height = height;\n c->private_impl.first_frame_io_position = first_frame_io_position;\n c->private_impl.first_frame_is_opaque = first_frame_is_opaque;\n return;\n }\n *c = ((wuffs_base__image_config){\n .pixcfg = {.private_impl = {0}},\n .private_impl = {0},\n });\n}\n\nstatic inline void //\nwuffs_base__image_config__invalidate(wuffs_base__image_config* c) {\n if (c) {\n *c = ((wuffs_base__image_config){\n .pixcfg = {.private_impl = {0}},\n .private_impl = {0},\n });\n }\n}\n\nstatic inline bool //\nwuffs_base__im" + + "age_config__is_valid(wuffs_base__image_config* c) {\n return c && wuffs_base__pixel_config__is_valid(&(c->pixcfg));\n}\n\nstatic inline uint64_t //\nwuffs_base__image_config__first_frame_io_position(wuffs_base__image_config* c) {\n return c ? c->private_impl.first_frame_io_position : 0;\n}\n\nstatic inline bool //\nwuffs_base__image_config__first_frame_is_opaque(wuffs_base__image_config* c) {\n return c ? c->private_impl.first_frame_is_opaque : false;\n}\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__image_config::set(wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height,\n uint64_t first_frame_io_position,\n bool first_frame_is_opaque) {\n wuffs_base__image_config__set(this, pixfmt, pixsub, width, height,\n first_frame_io_position, first_frame_is_opaque);\n}\n\ninline void //\nwuffs_base__image_" + + "config::invalidate() {\n wuffs_base__image_config__invalidate(this);\n}\n\ninline bool //\nwuffs_base__image_config::is_valid() {\n return wuffs_base__image_config__is_valid(this);\n}\n\ninline uint64_t //\nwuffs_base__image_config::first_frame_io_position() {\n return wuffs_base__image_config__first_frame_io_position(this);\n}\n\ninline bool //\nwuffs_base__image_config::first_frame_is_opaque() {\n return wuffs_base__image_config__first_frame_is_opaque(this);\n}\n\n#endif // __cplusplus\n\n" + "" + "// --------\n\n// wuffs_base__animation_blend encodes, for an animated image, how to blend the\n// transparent pixels of this frame with the existing canvas. In Porter-Duff\n// compositing operator terminology:\n// - 0 means the frame may be transparent, and should be blended \"src over\n// dst\", also known as just \"over\".\n// - 1 means the frame may be transparent, and should be blended \"src\".\n// - 2 means the frame is completely opaque, so that \"src over dst\" and \"src\"\n// are equivalent.\n//\n// These semantics are conservative. It is valid for a completely opaque frame\n// to have a blend value other than 2.\ntypedef uint8_t wuffs_base__animation_blend;\n\n#define WUFFS_BASE__ANIMATION_BLEND__SRC_OVER_DST \\\n ((wuffs_base__animation_blend)0)\n#define WUFFS_BASE__ANIMATION_BLEND__SRC ((wuffs_base__animation_blend)1)\n#define WUFFS_BASE__ANIMATION_BLEND__OPAQUE ((wuffs_base__animation_blend)2)\n\n" + "" + "// --------\n\n// wuffs_base__animation_disposal encodes, for an animated image, how to\n// dispose of a frame after displaying it:\n// - None means to draw the next frame on top of this one.\n// - Restore Background means to clear the frame's dirty rectangle to \"the\n// background color\" (in practice, this means transparent black) before\n// drawing the next frame.\n// - Restore Previous means to undo the current frame, so that the next frame\n// is drawn on top of the previous one.\ntypedef uint8_t wuffs_base__animation_disposal;\n\n#define WUFFS_BASE__ANIMATION_DISPOSAL__NONE ((wuffs_base__animation_disposal)0)\n#define WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND \\\n ((wuffs_base__animation_disposal)1)\n#define WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_PREVIOUS \\\n ((wuffs_base__animation_disposal)2)\n\n" + "" + "// --------\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__rect_ie_u32 bounds;\n wuffs_base__flicks duration;\n uint64_t index;\n uint64_t io_position;\n wuffs_base__animation_blend blend;\n wuffs_base__animation_disposal disposal;\n } private_impl;\n\n#ifdef __cplusplus\n inline void update(wuffs_base__rect_ie_u32 bounds,\n wuffs_base__flicks duration,\n uint64_t index,\n uint64_t io_position,\n wuffs_base__animation_blend blend,\n wuffs_base__animation_disposal disposal);\n inline wuffs_base__rect_ie_u32 bounds();\n inline uint32_t width();\n inline uint32_t height();\n inline wuffs_base__flicks duration();\n inline uint64_t index();\n inline uint64_t io_position();\n inline wuffs_base__animation_blend blend();\n inline wuffs_base__animation_disposal disposal();\n#endif // __cpluspl" + - "us\n\n} wuffs_base__frame_config;\n\nstatic inline void //\nwuffs_base__frame_config__update(wuffs_base__frame_config* c,\n wuffs_base__rect_ie_u32 bounds,\n wuffs_base__flicks duration,\n uint64_t index,\n uint64_t io_position,\n wuffs_base__animation_blend blend,\n wuffs_base__animation_disposal disposal) {\n if (!c) {\n return;\n }\n\n c->private_impl.bounds = bounds;\n c->private_impl.duration = duration;\n c->private_impl.index = index;\n c->private_impl.io_position = io_position;\n c->private_impl.blend = blend;\n c->private_impl.disposal = disposal;\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__frame_config__bounds(wuffs_base__frame_config* c) {\n return c ? c->private_impl.bounds : ((wuffs_base__rect_ie_u32){});\n}\n\nstatic inline uint32_t //\nwuffs_base__frame_config__width(wuffs_base__frame_config* c) {\n retur" + - "n c ? wuffs_base__rect_ie_u32__width(&c->private_impl.bounds) : 0;\n}\n\nstatic inline uint32_t //\nwuffs_base__frame_config__height(wuffs_base__frame_config* c) {\n return c ? wuffs_base__rect_ie_u32__height(&c->private_impl.bounds) : 0;\n}\n\n// wuffs_base__frame_config__duration returns the amount of time to display\n// this frame. Zero means to display forever - a still (non-animated) image.\nstatic inline wuffs_base__flicks //\nwuffs_base__frame_config__duration(wuffs_base__frame_config* c) {\n return c ? c->private_impl.duration : 0;\n}\n\n// wuffs_base__frame_config__index returns the index of this frame. The first\n// frame in an image has index 0, the second frame has index 1, and so on.\nstatic inline uint64_t //\nwuffs_base__frame_config__index(wuffs_base__frame_config* c) {\n return c ? c->private_impl.index : 0;\n}\n\n// wuffs_base__frame_config__io_position returns the I/O stream position before\n// the frame config.\nstatic inline uint64_t //\nwuffs_base__frame_config__io_position(wuffs_base__frame_config* c) {\n" + - " return c ? c->private_impl.io_position : 0;\n}\n\n// wuffs_base__frame_config__blend returns, for an animated image, how to blend\n// the transparent pixels of this frame with the existing canvas.\nstatic inline wuffs_base__animation_blend //\nwuffs_base__frame_config__blend(wuffs_base__frame_config* c) {\n return c ? c->private_impl.blend : 0;\n}\n\n// wuffs_base__frame_config__disposal returns, for an animated image, how to\n// dispose of this frame after displaying it.\nstatic inline wuffs_base__animation_disposal //\nwuffs_base__frame_config__disposal(wuffs_base__frame_config* c) {\n return c ? c->private_impl.disposal : 0;\n}\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__frame_config::update(wuffs_base__rect_ie_u32 bounds,\n wuffs_base__flicks duration,\n uint64_t index,\n uint64_t io_position,\n wuffs_base__animation_blend blend,\n wuffs_base__animation_dis" + - "posal disposal) {\n wuffs_base__frame_config__update(this, bounds, duration, index, io_position,\n blend, disposal);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__frame_config::bounds() {\n return wuffs_base__frame_config__bounds(this);\n}\n\ninline uint32_t //\nwuffs_base__frame_config::width() {\n return wuffs_base__frame_config__width(this);\n}\n\ninline uint32_t //\nwuffs_base__frame_config::height() {\n return wuffs_base__frame_config__height(this);\n}\n\ninline wuffs_base__flicks //\nwuffs_base__frame_config::duration() {\n return wuffs_base__frame_config__duration(this);\n}\n\ninline uint64_t //\nwuffs_base__frame_config::index() {\n return wuffs_base__frame_config__index(this);\n}\n\ninline uint64_t //\nwuffs_base__frame_config::io_position() {\n return wuffs_base__frame_config__io_position(this);\n}\n\ninline wuffs_base__animation_blend //\nwuffs_base__frame_config::blend() {\n return wuffs_base__frame_config__blend(this);\n}\n\ninline wuffs_base__animation_disposal //\nwuffs_base__fr" + - "ame_config::disposal() {\n return wuffs_base__frame_config__disposal(this);\n}\n\n#endif // __cplusplus\n\n" + + "us\n\n} wuffs_base__frame_config;\n\nstatic inline void //\nwuffs_base__frame_config__update(wuffs_base__frame_config* c,\n wuffs_base__rect_ie_u32 bounds,\n wuffs_base__flicks duration,\n uint64_t index,\n uint64_t io_position,\n wuffs_base__animation_blend blend,\n wuffs_base__animation_disposal disposal) {\n if (!c) {\n return;\n }\n\n c->private_impl.bounds = bounds;\n c->private_impl.duration = duration;\n c->private_impl.index = index;\n c->private_impl.io_position = io_position;\n c->private_impl.blend = blend;\n c->private_impl.disposal = disposal;\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__frame_config__bounds(wuffs_base__frame_config* c) {\n return c ? c->private_impl.bounds : ((wuffs_base__rect_ie_u32){0});\n}\n\nstatic inline uint32_t //\nwuffs_base__frame_config__width(wuffs_base__frame_config* c) {\n retu" + + "rn c ? wuffs_base__rect_ie_u32__width(&c->private_impl.bounds) : 0;\n}\n\nstatic inline uint32_t //\nwuffs_base__frame_config__height(wuffs_base__frame_config* c) {\n return c ? wuffs_base__rect_ie_u32__height(&c->private_impl.bounds) : 0;\n}\n\n// wuffs_base__frame_config__duration returns the amount of time to display\n// this frame. Zero means to display forever - a still (non-animated) image.\nstatic inline wuffs_base__flicks //\nwuffs_base__frame_config__duration(wuffs_base__frame_config* c) {\n return c ? c->private_impl.duration : 0;\n}\n\n// wuffs_base__frame_config__index returns the index of this frame. The first\n// frame in an image has index 0, the second frame has index 1, and so on.\nstatic inline uint64_t //\nwuffs_base__frame_config__index(wuffs_base__frame_config* c) {\n return c ? c->private_impl.index : 0;\n}\n\n// wuffs_base__frame_config__io_position returns the I/O stream position before\n// the frame config.\nstatic inline uint64_t //\nwuffs_base__frame_config__io_position(wuffs_base__frame_config* c) {" + + "\n return c ? c->private_impl.io_position : 0;\n}\n\n// wuffs_base__frame_config__blend returns, for an animated image, how to blend\n// the transparent pixels of this frame with the existing canvas.\nstatic inline wuffs_base__animation_blend //\nwuffs_base__frame_config__blend(wuffs_base__frame_config* c) {\n return c ? c->private_impl.blend : 0;\n}\n\n// wuffs_base__frame_config__disposal returns, for an animated image, how to\n// dispose of this frame after displaying it.\nstatic inline wuffs_base__animation_disposal //\nwuffs_base__frame_config__disposal(wuffs_base__frame_config* c) {\n return c ? c->private_impl.disposal : 0;\n}\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__frame_config::update(wuffs_base__rect_ie_u32 bounds,\n wuffs_base__flicks duration,\n uint64_t index,\n uint64_t io_position,\n wuffs_base__animation_blend blend,\n wuffs_base__animation_di" + + "sposal disposal) {\n wuffs_base__frame_config__update(this, bounds, duration, index, io_position,\n blend, disposal);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__frame_config::bounds() {\n return wuffs_base__frame_config__bounds(this);\n}\n\ninline uint32_t //\nwuffs_base__frame_config::width() {\n return wuffs_base__frame_config__width(this);\n}\n\ninline uint32_t //\nwuffs_base__frame_config::height() {\n return wuffs_base__frame_config__height(this);\n}\n\ninline wuffs_base__flicks //\nwuffs_base__frame_config::duration() {\n return wuffs_base__frame_config__duration(this);\n}\n\ninline uint64_t //\nwuffs_base__frame_config::index() {\n return wuffs_base__frame_config__index(this);\n}\n\ninline uint64_t //\nwuffs_base__frame_config::io_position() {\n return wuffs_base__frame_config__io_position(this);\n}\n\ninline wuffs_base__animation_blend //\nwuffs_base__frame_config::blend() {\n return wuffs_base__frame_config__blend(this);\n}\n\ninline wuffs_base__animation_disposal //\nwuffs_base__f" + + "rame_config::disposal() {\n return wuffs_base__frame_config__disposal(this);\n}\n\n#endif // __cplusplus\n\n" + "" + - "// --------\n\ntypedef struct {\n wuffs_base__pixel_config pixcfg;\n\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX];\n // TODO: color spaces.\n } private_impl;\n\n#ifdef __cplusplus\n inline wuffs_base__status set_from_slice(wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory);\n inline wuffs_base__slice_u8 palette();\n inline wuffs_base__pixel_format pixel_format();\n inline wuffs_base__table_u8 plane(uint32_t p);\n#endif // __cplusplus\n\n} wuffs_base__pixel_buffer;\n\nstatic inline wuffs_base__status //\nwuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b,\n wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory) {\n if (!b) {\n return wuffs_base__error__bad_receiver;\n }\n *b = (" + - "(wuffs_base__pixel_buffer){});\n if (!pixcfg) {\n return wuffs_base__error__bad_argument;\n }\n if (wuffs_base__pixel_format__is_planar(pixcfg->private_impl.pixfmt)) {\n // TODO: support planar pixel formats, concious of pixel subsampling.\n return wuffs_base__error__bad_argument;\n }\n uint32_t bits_per_pixel =\n wuffs_base__pixel_format__bits_per_pixel(pixcfg->private_impl.pixfmt);\n if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {\n return wuffs_base__error__bad_argument;\n }\n uint64_t bytes_per_pixel = bits_per_pixel / 8;\n\n uint8_t* ptr = pixbuf_memory.ptr;\n uint64_t len = pixbuf_memory.len;\n if (wuffs_base__pixel_format__is_indexed(pixcfg->private_impl.pixfmt)) {\n // Split a 1024 byte chunk (256 palette entries × 4 bytes per entry) from\n // the start of pixbuf_memory. We split from the start, not the end, so\n // that the both chunks' pointers have the same alignment as the original\n // pointer, up to an alignment of 1024.\n if (len < 1024) {\n return wuffs_ba" + - "se__error__bad_argument_length_too_short;\n }\n wuffs_base__table_u8* tab =\n &b->private_impl.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n tab->ptr = ptr;\n tab->width = 1024;\n tab->height = 1;\n tab->stride = 1024;\n ptr += 1024;\n len -= 1024;\n }\n\n uint64_t wh = ((uint64_t)pixcfg->private_impl.width) *\n ((uint64_t)pixcfg->private_impl.height);\n size_t width = (size_t)(pixcfg->private_impl.width);\n if ((wh > (UINT64_MAX / bytes_per_pixel)) ||\n (width > (SIZE_MAX / bytes_per_pixel))) {\n return wuffs_base__error__bad_argument;\n }\n wh *= bytes_per_pixel;\n width *= bytes_per_pixel;\n if (wh > len) {\n return wuffs_base__error__bad_argument_length_too_short;\n }\n\n b->pixcfg = *pixcfg;\n wuffs_base__table_u8* tab = &b->private_impl.planes[0];\n tab->ptr = ptr;\n tab->width = width;\n tab->height = pixcfg->private_impl.height;\n tab->stride = width;\n return NULL;\n}\n\n// wuffs_base__pixel_buffer__palette returns the palette color data. If\n// non-e" + - "mpty, it will have length 1024.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* b) {\n if (b &&\n wuffs_base__pixel_format__is_indexed(b->pixcfg.private_impl.pixfmt)) {\n wuffs_base__table_u8* tab =\n &b->private_impl.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n if ((tab->width == 1024) && (tab->height == 1)) {\n return ((wuffs_base__slice_u8){\n .ptr = tab->ptr,\n .len = 1024,\n });\n }\n }\n return ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__pixel_format //\nwuffs_base__pixel_buffer__pixel_format(wuffs_base__pixel_buffer* b) {\n if (b) {\n return b->pixcfg.private_impl.pixfmt;\n }\n return WUFFS_BASE__PIXEL_FORMAT__INVALID;\n}\n\nstatic inline wuffs_base__table_u8 //\nwuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* b, uint32_t p) {\n return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX))\n ? b->private_impl.planes[p]\n : ((wuffs_base__table_u8){});\n}\n\n#ifd" + - "ef __cplusplus\n\ninline wuffs_base__status //\nwuffs_base__pixel_buffer::set_from_slice(wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory) {\n return wuffs_base__pixel_buffer__set_from_slice(this, pixcfg, pixbuf_memory);\n}\n\ninline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer::palette() {\n return wuffs_base__pixel_buffer__palette(this);\n}\n\ninline wuffs_base__pixel_format //\nwuffs_base__pixel_buffer::pixel_format() {\n return wuffs_base__pixel_buffer__pixel_format(this);\n}\n\ninline wuffs_base__table_u8 //\nwuffs_base__pixel_buffer::plane(uint32_t p) {\n return wuffs_base__pixel_buffer__plane(this, p);\n}\n\n#endif // __cplusplus\n\n" + + "// --------\n\ntypedef struct {\n wuffs_base__pixel_config pixcfg;\n\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX];\n // TODO: color spaces.\n } private_impl;\n\n#ifdef __cplusplus\n inline wuffs_base__status set_from_slice(wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory);\n inline wuffs_base__slice_u8 palette();\n inline wuffs_base__pixel_format pixel_format();\n inline wuffs_base__table_u8 plane(uint32_t p);\n#endif // __cplusplus\n\n} wuffs_base__pixel_buffer;\n\nstatic inline wuffs_base__status //\nwuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b,\n wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory) {\n if (!b) {\n return wuffs_base__error__bad_receiver;\n }\n memset" + + "(b, 0, sizeof(*b));\n if (!pixcfg) {\n return wuffs_base__error__bad_argument;\n }\n if (wuffs_base__pixel_format__is_planar(pixcfg->private_impl.pixfmt)) {\n // TODO: support planar pixel formats, concious of pixel subsampling.\n return wuffs_base__error__bad_argument;\n }\n uint32_t bits_per_pixel =\n wuffs_base__pixel_format__bits_per_pixel(pixcfg->private_impl.pixfmt);\n if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {\n return wuffs_base__error__bad_argument;\n }\n uint64_t bytes_per_pixel = bits_per_pixel / 8;\n\n uint8_t* ptr = pixbuf_memory.ptr;\n uint64_t len = pixbuf_memory.len;\n if (wuffs_base__pixel_format__is_indexed(pixcfg->private_impl.pixfmt)) {\n // Split a 1024 byte chunk (256 palette entries × 4 bytes per entry) from\n // the start of pixbuf_memory. We split from the start, not the end, so\n // that the both chunks' pointers have the same alignment as the original\n // pointer, up to an alignment of 1024.\n if (len < 1024) {\n return wuffs_base__error__" + + "bad_argument_length_too_short;\n }\n wuffs_base__table_u8* tab =\n &b->private_impl.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n tab->ptr = ptr;\n tab->width = 1024;\n tab->height = 1;\n tab->stride = 1024;\n ptr += 1024;\n len -= 1024;\n }\n\n uint64_t wh = ((uint64_t)pixcfg->private_impl.width) *\n ((uint64_t)pixcfg->private_impl.height);\n size_t width = (size_t)(pixcfg->private_impl.width);\n if ((wh > (UINT64_MAX / bytes_per_pixel)) ||\n (width > (SIZE_MAX / bytes_per_pixel))) {\n return wuffs_base__error__bad_argument;\n }\n wh *= bytes_per_pixel;\n width *= bytes_per_pixel;\n if (wh > len) {\n return wuffs_base__error__bad_argument_length_too_short;\n }\n\n b->pixcfg = *pixcfg;\n wuffs_base__table_u8* tab = &b->private_impl.planes[0];\n tab->ptr = ptr;\n tab->width = width;\n tab->height = pixcfg->private_impl.height;\n tab->stride = width;\n return NULL;\n}\n\n// wuffs_base__pixel_buffer__palette returns the palette color data. If\n// non-empty, it wi" + + "ll have length 1024.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* b) {\n if (b &&\n wuffs_base__pixel_format__is_indexed(b->pixcfg.private_impl.pixfmt)) {\n wuffs_base__table_u8* tab =\n &b->private_impl.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n if ((tab->width == 1024) && (tab->height == 1)) {\n return ((wuffs_base__slice_u8){\n .ptr = tab->ptr,\n .len = 1024,\n });\n }\n }\n return ((wuffs_base__slice_u8){0});\n}\n\nstatic inline wuffs_base__pixel_format //\nwuffs_base__pixel_buffer__pixel_format(wuffs_base__pixel_buffer* b) {\n if (b) {\n return b->pixcfg.private_impl.pixfmt;\n }\n return WUFFS_BASE__PIXEL_FORMAT__INVALID;\n}\n\nstatic inline wuffs_base__table_u8 //\nwuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* b, uint32_t p) {\n return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX))\n ? b->private_impl.planes[p]\n : ((wuffs_base__table_u8){0});\n}\n\n#ifdef __cplu" + + "splus\n\ninline wuffs_base__status //\nwuffs_base__pixel_buffer::set_from_slice(wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory) {\n return wuffs_base__pixel_buffer__set_from_slice(this, pixcfg, pixbuf_memory);\n}\n\ninline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer::palette() {\n return wuffs_base__pixel_buffer__palette(this);\n}\n\ninline wuffs_base__pixel_format //\nwuffs_base__pixel_buffer::pixel_format() {\n return wuffs_base__pixel_buffer__pixel_format(this);\n}\n\ninline wuffs_base__table_u8 //\nwuffs_base__pixel_buffer::plane(uint32_t p) {\n return wuffs_base__pixel_buffer__plane(this, p);\n}\n\n#endif // __cplusplus\n\n" + "" + "// --------\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n uint8_t TODO;\n } private_impl;\n\n#ifdef __cplusplus\n#endif // __cplusplus\n\n} wuffs_base__decode_frame_options;\n\n#ifdef __cplusplus\n\n#endif // __cplusplus\n\n" + "" + @@ -168,10 +168,10 @@ const baseIOPrivateH = "" + "y, 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 *p++ = *q++;\n *p++ = *q++;\n *p++ = *q++;\n }\n for (; n; n--) {\n *p++ = *q++;\n }\n *ptr_iop_w = p;\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_iop_w - io0_w)\n// - length <= (io1_w - *ptr_iop_w)\nstatic inline uint32_t //\nwuffs_base__io_writer__copy_n_from_history_fast(uint8_t** ptr_iop_w,\n uint8_t* io0_w,\n uint8_t* io1_w,\n uint32_t length,\n uint32_t distance) {\n uint8_t* p = *ptr_iop_w;\n uint8_t* q = p - distance;\n uint32_t n = length;\n for (; n" + " >= 3; n -= 3) {\n *p++ = *q++;\n *p++ = *q++;\n *p++ = *q++;\n }\n for (; n; n--) {\n *p++ = *q++;\n }\n *ptr_iop_w = p;\n return length;\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__copy_n_from_reader(uint8_t** ptr_iop_w,\n uint8_t* io1_w,\n uint32_t length,\n uint8_t** ptr_iop_r,\n uint8_t* io1_r) {\n uint8_t* iop_w = *ptr_iop_w;\n size_t n = length;\n if (n > ((size_t)(io1_w - iop_w))) {\n n = io1_w - iop_w;\n }\n uint8_t* iop_r = *ptr_iop_r;\n if (n > ((size_t)(io1_r - iop_r))) {\n n = io1_r - iop_r;\n }\n if (n > 0) {\n memmove(iop_w, iop_r, n);\n *ptr_iop_w += n;\n *ptr_iop_r += n;\n }\n return n;\n}\n\nstatic inline uint64_t //\nwuffs_base__io_writer__copy_from_slice(uint8_t** ptr_iop_w,\n uint8_t* io1_w,\n wuffs_base__slice_u8 src) {\n uint8_t* iop" + "_w = *ptr_iop_w;\n size_t n = src.len;\n if (n > ((size_t)(io1_w - iop_w))) {\n n = io1_w - iop_w;\n }\n if (n > 0) {\n memmove(iop_w, src.ptr, n);\n *ptr_iop_w += n;\n }\n return n;\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__copy_n_from_slice(uint8_t** ptr_iop_w,\n uint8_t* io1_w,\n uint32_t length,\n wuffs_base__slice_u8 src) {\n uint8_t* iop_w = *ptr_iop_w;\n size_t n = src.len;\n if (n > length) {\n n = length;\n }\n if (n > ((size_t)(io1_w - iop_w))) {\n n = io1_w - iop_w;\n }\n if (n > 0) {\n memmove(iop_w, src.ptr, n);\n *ptr_iop_w += n;\n }\n return n;\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_reader__set(wuffs_base__io_reader* o,\n wuffs_base__io_buffer* b,\n uint8_t** ptr_iop_r,\n uint8_t** ptr_io1_r,\n wuffs_base__slice_u8 data) {\n b->data = " + - "data;\n b->meta.wi = data.len;\n b->meta.ri = 0;\n b->meta.pos = 0;\n b->meta.closed = false;\n\n o->private_impl.buf = b;\n o->private_impl.mark = data.ptr;\n o->private_impl.limit = data.ptr + data.len;\n *ptr_iop_r = data.ptr;\n *ptr_io1_r = data.ptr + data.len;\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_reader__set_limit(wuffs_base__io_reader* o,\n uint8_t* iop_r,\n uint64_t limit) {\n if (o && (((size_t)(o->private_impl.limit - iop_r)) > limit)) {\n o->private_impl.limit = iop_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__slice_u8 //\nwuffs_base__io_reader__take(uint8_t** ptr_iop_r, uint8_t* io1_r, uint64_t n) {\n if (n <= ((size_t)(io1_r - *ptr_iop_r))) {\n" + - " uint8_t* p = *ptr_iop_r;\n *ptr_iop_r += n;\n return ((wuffs_base__slice_u8){\n .ptr = p,\n .len = n,\n });\n }\n return ((wuffs_base__slice_u8){});\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** ptr_iop_w,\n uint8_t** ptr_io1_w,\n wuffs_base__slice_u8 data) {\n b->data = data;\n b->meta.wi = 0;\n b->meta.ri = 0;\n b->meta.pos = 0;\n b->meta.closed = false;\n\n o->private_impl.buf = b;\n o->private_impl.mark = data.ptr;\n o->private_impl.limit = data.ptr + data.len;\n *ptr_iop_w = data.ptr;\n *ptr_io1_w = data.ptr + data.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->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n\n" + + "data;\n b->meta.wi = data.len;\n b->meta.ri = 0;\n b->meta.pos = 0;\n b->meta.closed = false;\n\n o->private_impl.buf = b;\n o->private_impl.mark = data.ptr;\n o->private_impl.limit = data.ptr + data.len;\n *ptr_iop_r = data.ptr;\n *ptr_io1_r = data.ptr + data.len;\n return ((wuffs_base__empty_struct){0});\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_reader__set_limit(wuffs_base__io_reader* o,\n uint8_t* iop_r,\n uint64_t limit) {\n if (o && (((size_t)(o->private_impl.limit - iop_r)) > limit)) {\n o->private_impl.limit = iop_r + limit;\n }\n return ((wuffs_base__empty_struct){0});\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){0});\n}\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__io_reader__take(uint8_t** ptr_iop_r, uint8_t* io1_r, uint64_t n) {\n if (n <= ((size_t)(io1_r - *ptr_iop_r)))" + + " {\n uint8_t* p = *ptr_iop_r;\n *ptr_iop_r += n;\n return ((wuffs_base__slice_u8){\n .ptr = p,\n .len = n,\n });\n }\n return ((wuffs_base__slice_u8){0});\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** ptr_iop_w,\n uint8_t** ptr_io1_w,\n wuffs_base__slice_u8 data) {\n b->data = data;\n b->meta.wi = 0;\n b->meta.ri = 0;\n b->meta.pos = 0;\n b->meta.closed = false;\n\n o->private_impl.buf = b;\n o->private_impl.mark = data.ptr;\n o->private_impl.limit = data.ptr + data.len;\n *ptr_iop_w = data.ptr;\n *ptr_io1_w = data.ptr + data.len;\n return ((wuffs_base__empty_struct){0});\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){0});\n}\n\n" + "" + - "// ---------------- I/O (Utility)\n\nstatic inline wuffs_base__io_reader //\nwuffs_base__utility__null_io_reader() {\n return ((wuffs_base__io_reader){});\n}\n\nstatic inline wuffs_base__io_writer //\nwuffs_base__utility__null_io_writer() {\n return ((wuffs_base__io_writer){});\n}\n\n" + + "// ---------------- I/O (Utility)\n\nstatic inline wuffs_base__io_reader //\nwuffs_base__utility__null_io_reader() {\n return ((wuffs_base__io_reader){.private_impl = {0}});\n}\n\nstatic inline wuffs_base__io_writer //\nwuffs_base__utility__null_io_writer() {\n return ((wuffs_base__io_writer){.private_impl = {0}});\n}\n\n" + "" + "// ---------------- Bureaucracy re -Wunused-function\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__io_private()\n WUFFS_BASE__POTENTIALLY_UNUSED;\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__io_private() {\n (void)(wuffs_base__io_buffer__is_valid);\n (void)(wuffs_base__io_reader__is_eof);\n (void)(wuffs_base__io_reader__is_valid);\n (void)(wuffs_base__io_reader__set);\n (void)(wuffs_base__io_reader__set_limit);\n (void)(wuffs_base__io_reader__set_mark);\n (void)(wuffs_base__io_reader__take);\n (void)(wuffs_base__io_writer__copy_from_slice);\n (void)(wuffs_base__io_writer__copy_n_from_history);\n (void)(wuffs_base__io_writer__copy_n_from_history_fast);\n (void)(wuffs_base__io_writer__copy_n_from_reader);\n (void)(wuffs_base__io_writer__copy_n_from_slice);\n (void)(wuffs_base__io_writer__is_valid);\n (void)(wuffs_base__io_writer__set);\n (void)(wuffs_base__io_writer__set_mark);\n (void)(wuffs_base__utility__null_io_reader);\n (void)(wuffs_base__utility_" + "_null_io_writer);\n}\n" + @@ -180,8 +180,8 @@ const baseIOPrivateH = "" + const baseIOPublicH = "" + "// ---------------- 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 wuffs_base__io_reader reader();\n inline wuffs_base__io_writer writer();\n inline uint64_t reader_io_position();\n inline uint64_t writer_io_position();\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 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\nstatic inline uint64_t //\nwuffs_base__io_buffer__reader_io_position(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__writer_io_position(wuffs_base__io_buffer* buf) {\n return buf ? wuffs" + - "_base__u64__sat_add(buf->meta.pos, buf->meta.wi) : 0;\n}\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__io_buffer__struct::compact() {\n wuffs_base__io_buffer__compact(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\ninline uint64_t //\nwuffs_base__io_buffer__struct::reader_io_position() {\n return wuffs_base__io_buffer__reader_io_position(this);\n}\n\ninline uint64_t //\nwuffs_base__io_buffer__struct::writer_io_position() {\n return wuffs_base__io_buffer__writer_io_position(this);\n}\n\n#endif // __cplusplus\n\n" + + "_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 wuffs_base__io_reader //\nwuffs_base__io_buffer__reader(wuffs_base__io_buffer* buf) {\n wuffs_base__io_reader ret = ((wuffs_base__io_reader){.private_impl = {0}});\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){.private_impl = {0}});\n ret.private_impl.buf = buf;\n return ret;\n}\n\nstatic inline uint64_t //\nwuffs_base__io_buffer__reader_io_position(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__writer_io_position(wuffs_base__" + + "io_buffer* buf) {\n return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.wi) : 0;\n}\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__io_buffer__struct::compact() {\n wuffs_base__io_buffer__compact(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\ninline uint64_t //\nwuffs_base__io_buffer__struct::reader_io_position() {\n return wuffs_base__io_buffer__reader_io_position(this);\n}\n\ninline uint64_t //\nwuffs_base__io_buffer__struct::writer_io_position() {\n return wuffs_base__io_buffer__writer_io_position(this);\n}\n\n#endif // __cplusplus\n\n" + "" + "// ---------------- Bureaucracy re -Wunused-function\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__io_public()\n WUFFS_BASE__POTENTIALLY_UNUSED;\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__io_public() {\n (void)(wuffs_base__io_buffer__compact);\n (void)(wuffs_base__io_buffer__reader);\n (void)(wuffs_base__io_buffer__reader_io_position);\n (void)(wuffs_base__io_buffer__writer);\n (void)(wuffs_base__io_buffer__writer_io_position);\n}\n" + "" diff --git a/cmd/wuffs-c/internal/cgen/expr.go b/cmd/wuffs-c/internal/cgen/expr.go index 84d26e09..c9f48b5e 100644 --- a/cmd/wuffs-c/internal/cgen/expr.go +++ b/cmd/wuffs-c/internal/cgen/expr.go @@ -123,7 +123,7 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, depth uint32) error { if err := g.writeExpr(b, recv, depth); err != nil { return err } - b.printf(", 0, sizeof ((%s%s){}))", g.packagePrefix(qid), qid[1].Str(g.tm)) + b.printf(", 0, sizeof (%s%s))", g.packagePrefix(qid), qid[1].Str(g.tm)) if !isBaseRangeType(qid) { b.printf(", wuffs_base__ignore_status("+ @@ -131,7 +131,7 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, depth uint32) error { if err := g.writeExpr(b, recv, depth); err != nil { return err } - b.printf(", sizeof ((%s%s){}), WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED))", + b.printf(", sizeof (%s%s), WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED))", g.packagePrefix(qid), qid[1].Str(g.tm)) } diff --git a/cmd/wuffs-c/internal/cgen/func.go b/cmd/wuffs-c/internal/cgen/func.go index 865cab7a..7809567e 100644 --- a/cmd/wuffs-c/internal/cgen/func.go +++ b/cmd/wuffs-c/internal/cgen/func.go @@ -218,7 +218,7 @@ func (g *gen) gatherFuncImpl(_ *buffer, n *a.Func) error { func (g *gen) writeOutParamZeroValue(b *buffer, typ *a.TypeExpr) error { if typ == nil { - b.writes("((wuffs_base__empty_struct){})") + b.writes("((wuffs_base__empty_struct){0})") } else if typ.IsNumType() { b.writes("0") } else { @@ -226,7 +226,7 @@ func (g *gen) writeOutParamZeroValue(b *buffer, typ *a.TypeExpr) error { if err := g.writeCTypeName(b, typ, "", ""); err != nil { return err } - b.writes("){})") + b.writes("){0})") } return nil } @@ -379,7 +379,7 @@ func (g *gen) writeFuncImplEpilogue(b *buffer) error { } b.writes("return status;\n") } else if g.currFunk.astFunc.Out() == nil { - b.writes("return ((wuffs_base__empty_struct){});\n") + b.writes("return ((wuffs_base__empty_struct){0});\n") } return nil } @@ -448,7 +448,7 @@ func (g *gen) writeFuncImplArgChecks(b *buffer, n *a.Func) error { b.writes("return wuffs_base__error__bad_argument;\n\n") } else { // TODO: don't assume that the return type is empty. - b.printf("return ((wuffs_base__empty_struct){});\n") + b.printf("return ((wuffs_base__empty_struct){0});\n") } b.writes("}\n") return nil diff --git a/cmd/wuffs-c/internal/cgen/statement.go b/cmd/wuffs-c/internal/cgen/statement.go index 64f65ea6..e5675140 100644 --- a/cmd/wuffs-c/internal/cgen/statement.go +++ b/cmd/wuffs-c/internal/cgen/statement.go @@ -446,7 +446,7 @@ func (g *gen) writeStatementRet(b *buffer, n *a.Ret, depth uint32) error { b.writes("return ") if g.currFunk.astFunc.Out() == nil { - b.writes("((wuffs_base__empty_struct){})") + b.writes("((wuffs_base__empty_struct){0})") } else if err := g.writeExpr(b, retExpr, depth); err != nil { return err } diff --git a/cmd/wuffs-c/internal/cgen/var.go b/cmd/wuffs-c/internal/cgen/var.go index d92b3fff..25030f60 100644 --- a/cmd/wuffs-c/internal/cgen/var.go +++ b/cmd/wuffs-c/internal/cgen/var.go @@ -289,12 +289,17 @@ func (g *gen) writeVars(b *buffer, f *funk, inStructDecl bool) error { b.writes(" = false;\n") } else if typ.IsStatus() { b.writes(" = NULL;\n") + } else if typ.IsIOType() { + b.writes(" = {.private_impl = {0}};\n") } else { - b.writes(" = {};\n") + b.writes(" = {0};\n") } if typ.IsIOType() { - b.printf("wuffs_base__io_buffer %s%s WUFFS_BASE__POTENTIALLY_UNUSED = {};\n", uPrefix, name) + b.printf("wuffs_base__io_buffer %s%s WUFFS_BASE__POTENTIALLY_UNUSED = {"+ + ".data = ((wuffs_base__slice_u8){0}),\n"+ + ".meta = ((wuffs_base__io_buffer_meta){0}),\n"+ + "};\n", uPrefix, name) preName := vPrefix + name // TODO: io0_etc variables? b.printf("uint8_t* %s%s WUFFS_BASE__POTENTIALLY_UNUSED = NULL;\n", iopPrefix, preName) diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 8f79c9b4..eb9e5b7b 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -348,7 +348,7 @@ wuffs_base__slice_u8__subslice_i(wuffs_base__slice_u8 s, uint64_t i) { .len = s.len - i, }); } - return ((wuffs_base__slice_u8){}); + return ((wuffs_base__slice_u8){0}); } // wuffs_base__slice_u8__subslice_j returns s[:j]. @@ -362,7 +362,7 @@ wuffs_base__slice_u8__subslice_j(wuffs_base__slice_u8 s, uint64_t j) { .len = j, }); } - return ((wuffs_base__slice_u8){}); + return ((wuffs_base__slice_u8){0}); } // wuffs_base__slice_u8__subslice_ij returns s[i:j]. @@ -378,7 +378,7 @@ wuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s, .len = j - i, }); } - return ((wuffs_base__slice_u8){}); + return ((wuffs_base__slice_u8){0}); } // ---------------- Bureaucracy re -Wunused-function @@ -1266,14 +1266,14 @@ wuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) { static inline wuffs_base__io_reader // wuffs_base__io_buffer__reader(wuffs_base__io_buffer* buf) { - wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); + wuffs_base__io_reader ret = ((wuffs_base__io_reader){.private_impl = {0}}); ret.private_impl.buf = buf; return ret; } static inline wuffs_base__io_writer // wuffs_base__io_buffer__writer(wuffs_base__io_buffer* buf) { - wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); + wuffs_base__io_writer ret = ((wuffs_base__io_writer){.private_impl = {0}}); ret.private_impl.buf = buf; return ret; } @@ -1358,7 +1358,7 @@ wuffs_base__malloc_slice_u8(void* (*malloc_func)(size_t), uint64_t num_u8) { }); } } - return ((wuffs_base__slice_u8){}); + return ((wuffs_base__slice_u8){0}); } static inline wuffs_base__slice_u16 // @@ -1372,7 +1372,7 @@ wuffs_base__malloc_slice_u16(void* (*malloc_func)(size_t), uint64_t num_u16) { }); } } - return ((wuffs_base__slice_u16){}); + return ((wuffs_base__slice_u16){0}); } static inline wuffs_base__slice_u32 // @@ -1386,7 +1386,7 @@ wuffs_base__malloc_slice_u32(void* (*malloc_func)(size_t), uint64_t num_u32) { }); } } - return ((wuffs_base__slice_u32){}); + return ((wuffs_base__slice_u32){0}); } static inline wuffs_base__slice_u64 // @@ -1400,7 +1400,7 @@ wuffs_base__malloc_slice_u64(void* (*malloc_func)(size_t), uint64_t num_u64) { }); } } - return ((wuffs_base__slice_u64){}); + return ((wuffs_base__slice_u64){0}); } // ---------------- Bureaucracy re -Wunused-function @@ -1777,13 +1777,17 @@ wuffs_base__pixel_config__set(wuffs_base__pixel_config* c, return; } } - *c = ((wuffs_base__pixel_config){}); + *c = ((wuffs_base__pixel_config){ + .private_impl = {0}, + }); } static inline void // wuffs_base__pixel_config__invalidate(wuffs_base__pixel_config* c) { if (c) { - *c = ((wuffs_base__pixel_config){}); + *c = ((wuffs_base__pixel_config){ + .private_impl = {0}, + }); } } @@ -1810,7 +1814,7 @@ wuffs_base__pixel_config__bounds(wuffs_base__pixel_config* c) { .max_excl_x = c->private_impl.width, .max_excl_y = c->private_impl.height, }) - : ((wuffs_base__rect_ie_u32){}); + : ((wuffs_base__rect_ie_u32){0}); } static inline uint32_t // @@ -1969,13 +1973,19 @@ wuffs_base__image_config__set(wuffs_base__image_config* c, c->private_impl.first_frame_is_opaque = first_frame_is_opaque; return; } - *c = ((wuffs_base__image_config){}); + *c = ((wuffs_base__image_config){ + .pixcfg = {.private_impl = {0}}, + .private_impl = {0}, + }); } static inline void // wuffs_base__image_config__invalidate(wuffs_base__image_config* c) { if (c) { - *c = ((wuffs_base__image_config){}); + *c = ((wuffs_base__image_config){ + .pixcfg = {.private_impl = {0}}, + .private_impl = {0}, + }); } } @@ -2122,7 +2132,7 @@ wuffs_base__frame_config__update(wuffs_base__frame_config* c, static inline wuffs_base__rect_ie_u32 // wuffs_base__frame_config__bounds(wuffs_base__frame_config* c) { - return c ? c->private_impl.bounds : ((wuffs_base__rect_ie_u32){}); + return c ? c->private_impl.bounds : ((wuffs_base__rect_ie_u32){0}); } static inline uint32_t // @@ -2254,7 +2264,7 @@ wuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b, if (!b) { return wuffs_base__error__bad_receiver; } - *b = ((wuffs_base__pixel_buffer){}); + memset(b, 0, sizeof(*b)); if (!pixcfg) { return wuffs_base__error__bad_argument; } @@ -2326,7 +2336,7 @@ wuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* b) { }); } } - return ((wuffs_base__slice_u8){}); + return ((wuffs_base__slice_u8){0}); } static inline wuffs_base__pixel_format // @@ -2341,7 +2351,7 @@ static inline wuffs_base__table_u8 // wuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* b, uint32_t p) { return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX)) ? b->private_impl.planes[p] - : ((wuffs_base__table_u8){}); + : ((wuffs_base__table_u8){0}); } #ifdef __cplusplus @@ -3895,7 +3905,7 @@ wuffs_base__ignore_status(wuffs_base__status z) {} static inline wuffs_base__empty_struct // wuffs_base__return_empty_struct() { - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } // ---------------- Numeric Types @@ -4232,14 +4242,14 @@ wuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) { .len = t.width, }); } - return ((wuffs_base__slice_u8){}); + return ((wuffs_base__slice_u8){0}); } // ---------------- Slices and Tables (Utility) static inline wuffs_base__slice_u8 // wuffs_base__utility__null_slice_u8() { - return ((wuffs_base__slice_u8){}); + return ((wuffs_base__slice_u8){0}); } // ---------------- Bureaucracy re -Wunused-function @@ -4614,7 +4624,7 @@ wuffs_base__io_reader__set(wuffs_base__io_reader* o, o->private_impl.limit = data.ptr + data.len; *ptr_iop_r = data.ptr; *ptr_io1_r = data.ptr + data.len; - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } static inline wuffs_base__empty_struct // @@ -4624,13 +4634,13 @@ wuffs_base__io_reader__set_limit(wuffs_base__io_reader* o, if (o && (((size_t)(o->private_impl.limit - iop_r)) > limit)) { o->private_impl.limit = iop_r + limit; } - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } static inline wuffs_base__empty_struct // wuffs_base__io_reader__set_mark(wuffs_base__io_reader* o, uint8_t* mark) { o->private_impl.mark = mark; - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } static inline wuffs_base__slice_u8 // @@ -4643,7 +4653,7 @@ wuffs_base__io_reader__take(uint8_t** ptr_iop_r, uint8_t* io1_r, uint64_t n) { .len = n, }); } - return ((wuffs_base__slice_u8){}); + return ((wuffs_base__slice_u8){0}); } static inline wuffs_base__empty_struct // @@ -4663,25 +4673,25 @@ wuffs_base__io_writer__set(wuffs_base__io_writer* o, o->private_impl.limit = data.ptr + data.len; *ptr_iop_w = data.ptr; *ptr_io1_w = data.ptr + data.len; - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } static inline wuffs_base__empty_struct // wuffs_base__io_writer__set_mark(wuffs_base__io_writer* o, uint8_t* mark) { o->private_impl.mark = mark; - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } // ---------------- I/O (Utility) static inline wuffs_base__io_reader // wuffs_base__utility__null_io_reader() { - return ((wuffs_base__io_reader){}); + return ((wuffs_base__io_reader){.private_impl = {0}}); } static inline wuffs_base__io_writer // wuffs_base__utility__null_io_writer() { - return ((wuffs_base__io_writer){}); + return ((wuffs_base__io_writer){.private_impl = {0}}); } // ---------------- Bureaucracy re -Wunused-function @@ -4989,7 +4999,7 @@ wuffs_adler32__hasher__check_wuffs_version(wuffs_adler32__hasher* self, size_t // sizeof__wuffs_adler32__hasher() { - return sizeof((wuffs_adler32__hasher){}); + return sizeof(wuffs_adler32__hasher); } // ---------------- Function Implementations @@ -5008,8 +5018,8 @@ wuffs_adler32__hasher__update(wuffs_adler32__hasher* self, uint32_t v_s1 = 0; uint32_t v_s2 = 0; - wuffs_base__slice_u8 v_remaining = {}; - wuffs_base__slice_u8 v_p = {}; + wuffs_base__slice_u8 v_remaining = {0}; + wuffs_base__slice_u8 v_p = {0}; if (!self->private_impl.f_started) { self->private_impl.f_started = true; @@ -5988,7 +5998,7 @@ wuffs_crc32__ieee_hasher__check_wuffs_version(wuffs_crc32__ieee_hasher* self, size_t // sizeof__wuffs_crc32__ieee_hasher() { - return sizeof((wuffs_crc32__ieee_hasher){}); + return sizeof(wuffs_crc32__ieee_hasher); } // ---------------- Function Implementations @@ -6006,7 +6016,7 @@ wuffs_crc32__ieee_hasher__update(wuffs_crc32__ieee_hasher* self, } uint32_t v_s = 0; - wuffs_base__slice_u8 v_p = {}; + wuffs_base__slice_u8 v_p = {0}; v_s = (4294967295 ^ self->private_impl.f_state); { @@ -6266,7 +6276,7 @@ wuffs_deflate__decoder__check_wuffs_version(wuffs_deflate__decoder* self, size_t // sizeof__wuffs_deflate__decoder() { - return sizeof((wuffs_deflate__decoder){}); + return sizeof(wuffs_deflate__decoder); } // ---------------- Function Implementations @@ -6276,10 +6286,10 @@ sizeof__wuffs_deflate__decoder() { WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 // wuffs_deflate__decoder__workbuf_len(const wuffs_deflate__decoder* self) { if (!self) { - return ((wuffs_base__range_ii_u64){}); + return ((wuffs_base__range_ii_u64){0}); } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - return ((wuffs_base__range_ii_u64){}); + return ((wuffs_base__range_ii_u64){0}); } return wuffs_base__utility__make_range_ii_u64(33280, 33280); @@ -6309,7 +6319,7 @@ wuffs_deflate__decoder__decode_io_writer(wuffs_deflate__decoder* self, wuffs_base__status status = NULL; wuffs_base__status v_status = NULL; - wuffs_base__slice_u8 v_written = {}; + wuffs_base__slice_u8 v_written = {0}; uint64_t v_n_copied = 0; uint32_t v_already_full = 0; @@ -7030,13 +7040,13 @@ wuffs_deflate__decoder__init_huff(wuffs_deflate__decoder* self, uint32_t a_n_codes0, uint32_t a_n_codes1, uint32_t a_base_symbol) { - uint16_t v_counts[16] = {}; + uint16_t v_counts[16] = {0}; uint32_t v_i = 0; uint32_t v_remaining = 0; - uint16_t v_offsets[16] = {}; + uint16_t v_offsets[16] = {0}; uint32_t v_n_symbols = 0; uint32_t v_count = 0; - uint16_t v_symbols[320] = {}; + uint16_t v_symbols[320] = {0}; uint32_t v_min_cl = 0; uint32_t v_max_cl = 0; uint32_t v_initial_high_bits = 0; @@ -8049,7 +8059,7 @@ wuffs_lzw__decoder__check_wuffs_version(wuffs_lzw__decoder* self, size_t // sizeof__wuffs_lzw__decoder() { - return sizeof((wuffs_lzw__decoder){}); + return sizeof(wuffs_lzw__decoder); } // ---------------- Function Implementations @@ -8059,18 +8069,18 @@ sizeof__wuffs_lzw__decoder() { WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct // wuffs_lzw__decoder__set_literal_width(wuffs_lzw__decoder* self, uint32_t a_lw) { if (!self) { - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } if (a_lw < 2 || a_lw > 8) { self->private_impl.magic = WUFFS_BASE__DISABLED; - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } self->private_impl.f_set_literal_width_arg = a_lw; - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } // -------- func lzw.decoder.workbuf_len @@ -8078,10 +8088,10 @@ wuffs_lzw__decoder__set_literal_width(wuffs_lzw__decoder* self, uint32_t a_lw) { WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 // wuffs_lzw__decoder__workbuf_len(const wuffs_lzw__decoder* self) { if (!self) { - return ((wuffs_base__range_ii_u64){}); + return ((wuffs_base__range_ii_u64){0}); } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - return ((wuffs_base__range_ii_u64){}); + return ((wuffs_base__range_ii_u64){0}); } return wuffs_base__utility__make_range_ii_u64(0, 0); @@ -8379,7 +8389,7 @@ label_0_break:; iop_a_src - a_src.private_impl.buf->data.ptr; } - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } // -------- func lzw.decoder.write_to @@ -8389,7 +8399,7 @@ wuffs_lzw__decoder__write_to(wuffs_lzw__decoder* self, wuffs_base__io_writer a_dst) { wuffs_base__status status = NULL; - wuffs_base__slice_u8 v_s = {}; + wuffs_base__slice_u8 v_s = {0}; uint64_t v_n = 0; uint8_t* iop_a_dst = NULL; @@ -8466,13 +8476,13 @@ exit: WUFFS_BASE__MAYBE_STATIC wuffs_base__slice_u8 // wuffs_lzw__decoder__flush(wuffs_lzw__decoder* self) { if (!self) { - return ((wuffs_base__slice_u8){}); + return ((wuffs_base__slice_u8){0}); } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - return ((wuffs_base__slice_u8){}); + return ((wuffs_base__slice_u8){0}); } - wuffs_base__slice_u8 v_s = {}; + wuffs_base__slice_u8 v_s = {0}; if (self->private_impl.f_output_ri <= self->private_impl.f_output_wi) { v_s = wuffs_base__slice_u8__subslice_ij( @@ -8633,7 +8643,7 @@ wuffs_gif__decoder__check_wuffs_version(wuffs_gif__decoder* self, size_t // sizeof__wuffs_gif__decoder() { - return sizeof((wuffs_gif__decoder){}); + return sizeof(wuffs_gif__decoder); } // ---------------- Function Implementations @@ -8770,10 +8780,10 @@ wuffs_gif__decoder__num_decoded_frames(const wuffs_gif__decoder* self) { WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32 // wuffs_gif__decoder__frame_dirty_rect(const wuffs_gif__decoder* self) { if (!self) { - return ((wuffs_base__rect_ie_u32){}); + return ((wuffs_base__rect_ie_u32){0}); } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - return ((wuffs_base__rect_ie_u32){}); + return ((wuffs_base__rect_ie_u32){0}); } return wuffs_base__utility__make_rect_ie_u32( @@ -8790,10 +8800,10 @@ wuffs_gif__decoder__frame_dirty_rect(const wuffs_gif__decoder* self) { WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 // wuffs_gif__decoder__workbuf_len(const wuffs_gif__decoder* self) { if (!self) { - return ((wuffs_base__range_ii_u64){}); + return ((wuffs_base__range_ii_u64){0}); } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - return ((wuffs_base__range_ii_u64){}); + return ((wuffs_base__range_ii_u64){0}); } return wuffs_base__utility__make_range_ii_u64( @@ -8858,8 +8868,7 @@ wuffs_gif__decoder__decode_frame_config(wuffs_gif__decoder* self, switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; - (memset(&self->private_impl.f_dirty_y, 0, - sizeof((wuffs_base__range_ie_u32){})), + (memset(&self->private_impl.f_dirty_y, 0, sizeof(wuffs_base__range_ie_u32)), wuffs_base__return_empty_struct()); if (!self->private_impl.f_end_of_data) { if (self->private_impl.f_call_sequence == 0) { @@ -9110,7 +9119,7 @@ wuffs_gif__decoder__reset_gc(wuffs_gif__decoder* self) { self->private_impl.f_gc_transparent_index = 0; self->private_impl.f_gc_disposal = 0; self->private_impl.f_gc_duration = 0; - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } // -------- func gif.decoder.decode_up_to_id_part1 @@ -9237,7 +9246,7 @@ wuffs_gif__decoder__decode_header(wuffs_gif__decoder* self, wuffs_base__io_reader a_src) { wuffs_base__status status = NULL; - uint8_t v_c[6] = {}; + uint8_t v_c[6] = {0}; uint32_t v_i = 0; uint8_t* iop_a_src = NULL; @@ -10208,7 +10217,7 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, uint32_t v_num_palette_entries = 0; uint32_t v_i = 0; uint32_t v_argb = 0; - wuffs_base__slice_u8 v_dst_palette = {}; + wuffs_base__slice_u8 v_dst_palette = {0}; uint8_t v_lw = 0; uint8_t* iop_a_src = NULL; @@ -10346,10 +10355,10 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, .len = 1024, })); if (self->private_impl.f_previous_lzw_decode_ended_abruptly) { - (memset(&self->private_data.f_lzw, 0, sizeof((wuffs_lzw__decoder){})), + (memset(&self->private_data.f_lzw, 0, sizeof(wuffs_lzw__decoder)), wuffs_base__ignore_status(wuffs_lzw__decoder__initialize( - &self->private_data.f_lzw, sizeof((wuffs_lzw__decoder){}), - WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED)), + &self->private_data.f_lzw, sizeof(wuffs_lzw__decoder), WUFFS_VERSION, + WUFFS_INITIALIZE__ALREADY_ZEROED)), wuffs_base__return_empty_struct()); } { @@ -10404,14 +10413,17 @@ wuffs_gif__decoder__decode_id_part2(wuffs_gif__decoder* self, uint64_t v_block_size = 0; bool v_need_block_size = false; uint64_t v_n_compressed = 0; - wuffs_base__slice_u8 v_compressed = {}; - wuffs_base__io_reader v_r = {}; - wuffs_base__io_buffer u_r WUFFS_BASE__POTENTIALLY_UNUSED = {}; + wuffs_base__slice_u8 v_compressed = {0}; + wuffs_base__io_reader v_r = {.private_impl = {0}}; + wuffs_base__io_buffer u_r WUFFS_BASE__POTENTIALLY_UNUSED = { + .data = ((wuffs_base__slice_u8){0}), + .meta = ((wuffs_base__io_buffer_meta){0}), + }; uint8_t* iop_v_r WUFFS_BASE__POTENTIALLY_UNUSED = NULL; uint8_t* io1_v_r WUFFS_BASE__POTENTIALLY_UNUSED = NULL; wuffs_base__status v_lzw_status = NULL; wuffs_base__status v_copy_status = NULL; - wuffs_base__slice_u8 v_uncompressed = {}; + wuffs_base__slice_u8 v_uncompressed = {0}; uint8_t* iop_a_src = NULL; uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; @@ -10628,13 +10640,13 @@ static wuffs_base__status // wuffs_gif__decoder__copy_to_image_buffer(wuffs_gif__decoder* self, wuffs_base__pixel_buffer* a_pb, wuffs_base__slice_u8 a_src) { - wuffs_base__slice_u8 v_dst = {}; - wuffs_base__slice_u8 v_src = {}; + wuffs_base__slice_u8 v_dst = {0}; + wuffs_base__slice_u8 v_src = {0}; uint64_t v_n = 0; uint64_t v_src_ri = 0; uint32_t v_bytes_per_pixel = 0; uint32_t v_pixfmt = 0; - wuffs_base__table_u8 v_tab = {}; + wuffs_base__table_u8 v_tab = {0}; uint64_t v_i = 0; uint64_t v_j = 0; @@ -10801,7 +10813,7 @@ wuffs_gzip__decoder__check_wuffs_version(wuffs_gzip__decoder* self, size_t // sizeof__wuffs_gzip__decoder() { - return sizeof((wuffs_gzip__decoder){}); + return sizeof(wuffs_gzip__decoder); } // ---------------- Function Implementations @@ -10811,14 +10823,14 @@ sizeof__wuffs_gzip__decoder() { WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct // wuffs_gzip__decoder__set_ignore_checksum(wuffs_gzip__decoder* self, bool a_ic) { if (!self) { - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } self->private_impl.f_ignore_checksum = a_ic; - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } // -------- func gzip.decoder.workbuf_len @@ -10826,10 +10838,10 @@ wuffs_gzip__decoder__set_ignore_checksum(wuffs_gzip__decoder* self, bool a_ic) { WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 // wuffs_gzip__decoder__workbuf_len(const wuffs_gzip__decoder* self) { if (!self) { - return ((wuffs_base__range_ii_u64){}); + return ((wuffs_base__range_ii_u64){0}); } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - return ((wuffs_base__range_ii_u64){}); + return ((wuffs_base__range_ii_u64){0}); } return wuffs_base__utility__make_range_ii_u64(33280, 33280); @@ -11274,7 +11286,7 @@ wuffs_zlib__decoder__check_wuffs_version(wuffs_zlib__decoder* self, size_t // sizeof__wuffs_zlib__decoder() { - return sizeof((wuffs_zlib__decoder){}); + return sizeof(wuffs_zlib__decoder); } // ---------------- Function Implementations @@ -11284,14 +11296,14 @@ sizeof__wuffs_zlib__decoder() { WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct // wuffs_zlib__decoder__set_ignore_checksum(wuffs_zlib__decoder* self, bool a_ic) { if (!self) { - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } self->private_impl.f_ignore_checksum = a_ic; - return ((wuffs_base__empty_struct){}); + return ((wuffs_base__empty_struct){0}); } // -------- func zlib.decoder.workbuf_len @@ -11299,10 +11311,10 @@ wuffs_zlib__decoder__set_ignore_checksum(wuffs_zlib__decoder* self, bool a_ic) { WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 // wuffs_zlib__decoder__workbuf_len(const wuffs_zlib__decoder* self) { if (!self) { - return ((wuffs_base__range_ii_u64){}); + return ((wuffs_base__range_ii_u64){0}); } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - return ((wuffs_base__range_ii_u64){}); + return ((wuffs_base__range_ii_u64){0}); } return wuffs_base__utility__make_range_ii_u64(33280, 33280);