From 91f7f4b70a576947aa9558dd7d68e2c8dbb95628 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sat, 2 Feb 2019 14:15:52 +1100 Subject: [PATCH] Avoid -Wunused-function warnings with clang --- cmd/wuffs-c/internal/cgen/base/core-private.h | 53 ++++ cmd/wuffs-c/internal/cgen/base/core-public.h | 34 +++ cmd/wuffs-c/internal/cgen/base/image-public.h | 49 ++++ cmd/wuffs-c/internal/cgen/base/io-private.h | 27 ++ cmd/wuffs-c/internal/cgen/base/io-public.h | 15 + .../internal/cgen/base/memory-public.h | 14 + .../internal/cgen/base/range-private.h | 24 ++ cmd/wuffs-c/internal/cgen/base/range-public.h | 58 +++- cmd/wuffs-c/internal/cgen/data.go | 44 ++- release/c/wuffs-unsupported-snapshot.c | 274 +++++++++++++++++- 10 files changed, 565 insertions(+), 27 deletions(-) diff --git a/cmd/wuffs-c/internal/cgen/base/core-private.h b/cmd/wuffs-c/internal/cgen/base/core-private.h index 6b83afc0..f8eb5821 100644 --- a/cmd/wuffs-c/internal/cgen/base/core-private.h +++ b/cmd/wuffs-c/internal/cgen/base/core-private.h @@ -422,3 +422,56 @@ wuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) { } return ((wuffs_base__slice_u8){}); } + +// ---------------- Bureaucracy re -Wunused-function + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__core_private() + WUFFS_BASE__POTENTIALLY_UNUSED; + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__core_private() { + (void)(wuffs_base__load_u16be); + (void)(wuffs_base__load_u16le); + (void)(wuffs_base__load_u24be); + (void)(wuffs_base__load_u24le); + (void)(wuffs_base__load_u32be); + (void)(wuffs_base__load_u32le); + (void)(wuffs_base__load_u40be); + (void)(wuffs_base__load_u40le); + (void)(wuffs_base__load_u48be); + (void)(wuffs_base__load_u48le); + (void)(wuffs_base__load_u56be); + (void)(wuffs_base__load_u56le); + (void)(wuffs_base__load_u64be); + (void)(wuffs_base__load_u64le); + (void)(wuffs_base__load_u8be); + (void)(wuffs_base__return_empty_struct); + (void)(wuffs_base__slice_u8__copy_from_slice); + (void)(wuffs_base__slice_u8__prefix); + (void)(wuffs_base__slice_u8__suffix); + (void)(wuffs_base__store_u16be); + (void)(wuffs_base__store_u16le); + (void)(wuffs_base__store_u24be); + (void)(wuffs_base__store_u24le); + (void)(wuffs_base__store_u32be); + (void)(wuffs_base__store_u32le); + (void)(wuffs_base__store_u40be); + (void)(wuffs_base__store_u40le); + (void)(wuffs_base__store_u48be); + (void)(wuffs_base__store_u48le); + (void)(wuffs_base__store_u56be); + (void)(wuffs_base__store_u56le); + (void)(wuffs_base__store_u64be); + (void)(wuffs_base__store_u64le); + (void)(wuffs_base__store_u8be); + (void)(wuffs_base__table_u8__row); + (void)(wuffs_base__u16__sat_add_indirect); + (void)(wuffs_base__u16__sat_sub_indirect); + (void)(wuffs_base__u32__sat_add_indirect); + (void)(wuffs_base__u32__sat_sub_indirect); + (void)(wuffs_base__u64__sat_add_indirect); + (void)(wuffs_base__u64__sat_sub_indirect); + (void)(wuffs_base__u8__sat_add_indirect); + (void)(wuffs_base__u8__sat_sub_indirect); +} diff --git a/cmd/wuffs-c/internal/cgen/base/core-public.h b/cmd/wuffs-c/internal/cgen/base/core-public.h index 2f69e72e..20f11a50 100644 --- a/cmd/wuffs-c/internal/cgen/base/core-public.h +++ b/cmd/wuffs-c/internal/cgen/base/core-public.h @@ -341,3 +341,37 @@ wuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s, } return ((wuffs_base__slice_u8){}); } + +// ---------------- Bureaucracy re -Wunused-function + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__core_public() + WUFFS_BASE__POTENTIALLY_UNUSED; + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__core_public() { + (void)(wuffs_base__slice_u8__subslice_i); + (void)(wuffs_base__slice_u8__subslice_ij); + (void)(wuffs_base__slice_u8__subslice_j); + (void)(wuffs_base__status__is_complete); + (void)(wuffs_base__status__is_error); + (void)(wuffs_base__status__is_ok); + (void)(wuffs_base__status__is_suspension); + (void)(wuffs_base__status__is_warning); + (void)(wuffs_base__u16__max); + (void)(wuffs_base__u16__min); + (void)(wuffs_base__u16__sat_add); + (void)(wuffs_base__u16__sat_sub); + (void)(wuffs_base__u32__max); + (void)(wuffs_base__u32__min); + (void)(wuffs_base__u32__sat_add); + (void)(wuffs_base__u32__sat_sub); + (void)(wuffs_base__u64__max); + (void)(wuffs_base__u64__min); + (void)(wuffs_base__u64__sat_add); + (void)(wuffs_base__u64__sat_sub); + (void)(wuffs_base__u8__max); + (void)(wuffs_base__u8__min); + (void)(wuffs_base__u8__sat_add); + (void)(wuffs_base__u8__sat_sub); +} diff --git a/cmd/wuffs-c/internal/cgen/base/image-public.h b/cmd/wuffs-c/internal/cgen/base/image-public.h index 59e1d3f9..ab3efebc 100644 --- a/cmd/wuffs-c/internal/cgen/base/image-public.h +++ b/cmd/wuffs-c/internal/cgen/base/image-public.h @@ -1028,3 +1028,52 @@ wuffs_base__pixel_swizzler::swizzle_packed(wuffs_base__slice_u8 dst, } #endif // __cplusplus + +// ---------------- Bureaucracy re -Wunused-function + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__image_public() + WUFFS_BASE__POTENTIALLY_UNUSED; + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__image_public() { + (void)(wuffs_base__frame_config__blend); + (void)(wuffs_base__frame_config__bounds); + (void)(wuffs_base__frame_config__disposal); + (void)(wuffs_base__frame_config__duration); + (void)(wuffs_base__frame_config__height); + (void)(wuffs_base__frame_config__index); + (void)(wuffs_base__frame_config__io_position); + (void)(wuffs_base__frame_config__update); + (void)(wuffs_base__frame_config__width); + (void)(wuffs_base__image_config__first_frame_io_position); + (void)(wuffs_base__image_config__first_frame_is_opaque); + (void)(wuffs_base__image_config__invalidate); + (void)(wuffs_base__image_config__is_valid); + (void)(wuffs_base__image_config__set); + (void)(wuffs_base__pixel_buffer__palette); + (void)(wuffs_base__pixel_buffer__pixel_format); + (void)(wuffs_base__pixel_buffer__plane); + (void)(wuffs_base__pixel_buffer__set_from_slice); + (void)(wuffs_base__pixel_config__bounds); + (void)(wuffs_base__pixel_config__height); + (void)(wuffs_base__pixel_config__invalidate); + (void)(wuffs_base__pixel_config__is_valid); + (void)(wuffs_base__pixel_config__pixbuf_len); + (void)(wuffs_base__pixel_config__pixel_format); + (void)(wuffs_base__pixel_config__pixel_subsampling); + (void)(wuffs_base__pixel_config__set); + (void)(wuffs_base__pixel_config__width); + (void)(wuffs_base__pixel_format__bits_per_pixel); + (void)(wuffs_base__pixel_format__is_indexed); + (void)(wuffs_base__pixel_format__is_packed); + (void)(wuffs_base__pixel_format__is_planar); + (void)(wuffs_base__pixel_format__is_valid); + (void)(wuffs_base__pixel_format__num_planes); + (void)(wuffs_base__pixel_subsampling__bias_x); + (void)(wuffs_base__pixel_subsampling__bias_y); + (void)(wuffs_base__pixel_subsampling__shift_x); + (void)(wuffs_base__pixel_subsampling__shift_y); + (void)(wuffs_base__pixel_swizzler__prepare); + (void)(wuffs_base__pixel_swizzler__swizzle_packed); +} diff --git a/cmd/wuffs-c/internal/cgen/base/io-private.h b/cmd/wuffs-c/internal/cgen/base/io-private.h index 725adf58..af2ee922 100644 --- a/cmd/wuffs-c/internal/cgen/base/io-private.h +++ b/cmd/wuffs-c/internal/cgen/base/io-private.h @@ -274,3 +274,30 @@ static inline wuffs_base__io_writer // wuffs_base__utility__null_io_writer(const wuffs_base__utility* ignored) { return ((wuffs_base__io_writer){}); } + +// ---------------- Bureaucracy re -Wunused-function + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__io_private() + WUFFS_BASE__POTENTIALLY_UNUSED; + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__io_private() { + (void)(wuffs_base__io_buffer__is_valid); + (void)(wuffs_base__io_reader__is_eof); + (void)(wuffs_base__io_reader__is_valid); + (void)(wuffs_base__io_reader__set); + (void)(wuffs_base__io_reader__set_limit); + (void)(wuffs_base__io_reader__set_mark); + (void)(wuffs_base__io_reader__take); + (void)(wuffs_base__io_writer__copy_from_slice); + (void)(wuffs_base__io_writer__copy_n_from_history); + (void)(wuffs_base__io_writer__copy_n_from_history_fast); + (void)(wuffs_base__io_writer__copy_n_from_reader); + (void)(wuffs_base__io_writer__copy_n_from_slice); + (void)(wuffs_base__io_writer__is_valid); + (void)(wuffs_base__io_writer__set); + (void)(wuffs_base__io_writer__set_mark); + (void)(wuffs_base__utility__null_io_reader); + (void)(wuffs_base__utility__null_io_writer); +} diff --git a/cmd/wuffs-c/internal/cgen/base/io-public.h b/cmd/wuffs-c/internal/cgen/base/io-public.h index a87a7c09..61affe21 100644 --- a/cmd/wuffs-c/internal/cgen/base/io-public.h +++ b/cmd/wuffs-c/internal/cgen/base/io-public.h @@ -139,3 +139,18 @@ wuffs_base__io_buffer__struct::writer_io_position() { } #endif // __cplusplus + +// ---------------- Bureaucracy re -Wunused-function + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__io_public() + WUFFS_BASE__POTENTIALLY_UNUSED; + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__io_public() { + (void)(wuffs_base__io_buffer__compact); + (void)(wuffs_base__io_buffer__reader); + (void)(wuffs_base__io_buffer__reader_io_position); + (void)(wuffs_base__io_buffer__writer); + (void)(wuffs_base__io_buffer__writer_io_position); +} diff --git a/cmd/wuffs-c/internal/cgen/base/memory-public.h b/cmd/wuffs-c/internal/cgen/base/memory-public.h index fbf0e058..0d8c6621 100644 --- a/cmd/wuffs-c/internal/cgen/base/memory-public.h +++ b/cmd/wuffs-c/internal/cgen/base/memory-public.h @@ -84,3 +84,17 @@ wuffs_base__malloc_slice_u64(void* (*malloc_func)(size_t), uint64_t num_u64) { } return ((wuffs_base__slice_u64){}); } + +// ---------------- Bureaucracy re -Wunused-function + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__memory_public() + WUFFS_BASE__POTENTIALLY_UNUSED; + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__memory_public() { + (void)(wuffs_base__malloc_slice_u16); + (void)(wuffs_base__malloc_slice_u32); + (void)(wuffs_base__malloc_slice_u64); + (void)(wuffs_base__malloc_slice_u8); +} diff --git a/cmd/wuffs-c/internal/cgen/base/range-private.h b/cmd/wuffs-c/internal/cgen/base/range-private.h index e37a3ae4..cd776980 100644 --- a/cmd/wuffs-c/internal/cgen/base/range-private.h +++ b/cmd/wuffs-c/internal/cgen/base/range-private.h @@ -125,3 +125,27 @@ wuffs_base__utility__make_rect_ie_u32(const wuffs_base__utility* ignored, .max_excl_y = max_excl_y, }); } + +// ---------------- Bureaucracy re -Wunused-function + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__range_private() + WUFFS_BASE__POTENTIALLY_UNUSED; + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__range_private() { + (void)(wuffs_base__range_ie_u32__get_max_excl); + (void)(wuffs_base__range_ie_u32__get_min_incl); + (void)(wuffs_base__range_ie_u64__get_max_excl); + (void)(wuffs_base__range_ie_u64__get_min_incl); + (void)(wuffs_base__range_ii_u32__get_max_incl); + (void)(wuffs_base__range_ii_u32__get_min_incl); + (void)(wuffs_base__range_ii_u64__get_max_incl); + (void)(wuffs_base__range_ii_u64__get_min_incl); + (void)(wuffs_base__utility__make_range_ie_u32); + (void)(wuffs_base__utility__make_range_ie_u64); + (void)(wuffs_base__utility__make_range_ii_u32); + (void)(wuffs_base__utility__make_range_ii_u64); + (void)(wuffs_base__utility__make_rect_ie_u32); + (void)(wuffs_base__utility__make_rect_ii_u32); +} diff --git a/cmd/wuffs-c/internal/cgen/base/range-public.h b/cmd/wuffs-c/internal/cgen/base/range-public.h index 2071d9cb..68027369 100644 --- a/cmd/wuffs-c/internal/cgen/base/range-public.h +++ b/cmd/wuffs-c/internal/cgen/base/range-public.h @@ -81,20 +81,18 @@ wuffs_base__range_ii_u32__contains(wuffs_base__range_ii_u32* r, uint32_t x) { return (r->min_incl <= x) && (x <= r->max_incl); } -static inline // - wuffs_base__range_ii_u32 - wuffs_base__range_ii_u32__intersect(wuffs_base__range_ii_u32* r, - wuffs_base__range_ii_u32 s) { +static inline wuffs_base__range_ii_u32 // +wuffs_base__range_ii_u32__intersect(wuffs_base__range_ii_u32* r, + wuffs_base__range_ii_u32 s) { wuffs_base__range_ii_u32 t; t.min_incl = wuffs_base__u32__max(r->min_incl, s.min_incl); t.max_incl = wuffs_base__u32__min(r->max_incl, s.max_incl); return t; } -static inline // - wuffs_base__range_ii_u32 - wuffs_base__range_ii_u32__unite(wuffs_base__range_ii_u32* r, - wuffs_base__range_ii_u32 s) { +static inline wuffs_base__range_ii_u32 // +wuffs_base__range_ii_u32__unite(wuffs_base__range_ii_u32* r, + wuffs_base__range_ii_u32 s) { if (wuffs_base__range_ii_u32__is_empty(r)) { return s; } @@ -663,3 +661,47 @@ wuffs_base__rect_ie_u32::height() { } #endif // __cplusplus + +// ---------------- Bureaucracy re -Wunused-function + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__range_public() + WUFFS_BASE__POTENTIALLY_UNUSED; + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__range_public() { + (void)(wuffs_base__range_ie_u32__contains); + (void)(wuffs_base__range_ie_u32__equals); + (void)(wuffs_base__range_ie_u32__intersect); + (void)(wuffs_base__range_ie_u32__is_empty); + (void)(wuffs_base__range_ie_u32__length); + (void)(wuffs_base__range_ie_u32__unite); + (void)(wuffs_base__range_ie_u64__contains); + (void)(wuffs_base__range_ie_u64__equals); + (void)(wuffs_base__range_ie_u64__intersect); + (void)(wuffs_base__range_ie_u64__is_empty); + (void)(wuffs_base__range_ie_u64__length); + (void)(wuffs_base__range_ie_u64__unite); + (void)(wuffs_base__range_ii_u32__contains); + (void)(wuffs_base__range_ii_u32__equals); + (void)(wuffs_base__range_ii_u32__intersect); + (void)(wuffs_base__range_ii_u32__is_empty); + (void)(wuffs_base__range_ii_u32__unite); + (void)(wuffs_base__range_ii_u64__contains); + (void)(wuffs_base__range_ii_u64__equals); + (void)(wuffs_base__range_ii_u64__intersect); + (void)(wuffs_base__range_ii_u64__is_empty); + (void)(wuffs_base__range_ii_u64__unite); + (void)(wuffs_base__rect_ie_u32__contains); + (void)(wuffs_base__rect_ie_u32__equals); + (void)(wuffs_base__rect_ie_u32__height); + (void)(wuffs_base__rect_ie_u32__intersect); + (void)(wuffs_base__rect_ie_u32__is_empty); + (void)(wuffs_base__rect_ie_u32__unite); + (void)(wuffs_base__rect_ie_u32__width); + (void)(wuffs_base__rect_ii_u32__contains); + (void)(wuffs_base__rect_ii_u32__equals); + (void)(wuffs_base__rect_ii_u32__intersect); + (void)(wuffs_base__rect_ii_u32__is_empty); + (void)(wuffs_base__rect_ii_u32__unite); +} diff --git a/cmd/wuffs-c/internal/cgen/data.go b/cmd/wuffs-c/internal/cgen/data.go index c8102cda..00280e5c 100644 --- a/cmd/wuffs-c/internal/cgen/data.go +++ b/cmd/wuffs-c/internal/cgen/data.go @@ -52,7 +52,10 @@ 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\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" + + "" + + "// ---------------- 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__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 (v" + + "oid)(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}\n" + "" const baseCorePublicH = "" + @@ -73,7 +76,10 @@ const baseCorePublicH = "" + "" + "// ---------------- 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" + + "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" + + "" + + "// ---------------- 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" + "" const baseMemoryPrivateH = "" + @@ -83,7 +89,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" + + "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" + + "" + + "// ---------------- 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" + "" const baseImagePrivateH = "" + @@ -142,7 +150,11 @@ const baseImagePublicH = "" + "" + "// --------\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 // TODO: should the func type take restrict pointers?\n uint64_t (*func)(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src);\n } private_impl;\n\n#ifdef __cplusplus\n inline void prepare(wuffs_base__pixel_format dst_format,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__pixel_format src_format,\n wuffs_base__slice_u8 src_palette);\n inline uint64_t swizzle_packed(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src);\n#endif // __cplusplus\n\n} wuffs_base__pixel_swizzler;\n\n// TODO: should prepare (both the C and C++ methods) return a status?\n\nvoid //\nwuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swi" + "zzler* p,\n wuffs_base__pixel_format dst_format,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__pixel_format src_format,\n wuffs_base__slice_u8 src_palette);\n\nuint64_t //\nwuffs_base__pixel_swizzler__swizzle_packed(wuffs_base__pixel_swizzler* p,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src);\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__pixel_swizzler::prepare(wuffs_base__pixel_format dst_format,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__pixel_format src_format,\n wuffs_base__slice_u8 src_palette) {\n wuffs_base__pixel_swizzler__prepare(this, dst_format, dst_palette, src_format,\n " + - " src_palette);\n}\n\nuint64_t //\nwuffs_base__pixel_swizzler::swizzle_packed(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n return wuffs_base__pixel_swizzler__swizzle_packed(this, dst, dst_palette,\n src);\n}\n\n#endif // __cplusplus\n" + + " src_palette);\n}\n\nuint64_t //\nwuffs_base__pixel_swizzler::swizzle_packed(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n return wuffs_base__pixel_swizzler__swizzle_packed(this, dst, dst_palette,\n src);\n}\n\n#endif // __cplusplus\n\n" + + "" + + "// ---------------- Bureaucracy re -Wunused-function\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__image_public()\n WUFFS_BASE__POTENTIALLY_UNUSED;\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__image_public() {\n (void)(wuffs_base__frame_config__blend);\n (void)(wuffs_base__frame_config__bounds);\n (void)(wuffs_base__frame_config__disposal);\n (void)(wuffs_base__frame_config__duration);\n (void)(wuffs_base__frame_config__height);\n (void)(wuffs_base__frame_config__index);\n (void)(wuffs_base__frame_config__io_position);\n (void)(wuffs_base__frame_config__update);\n (void)(wuffs_base__frame_config__width);\n (void)(wuffs_base__image_config__first_frame_io_position);\n (void)(wuffs_base__image_config__first_frame_is_opaque);\n (void)(wuffs_base__image_config__invalidate);\n (void)(wuffs_base__image_config__is_valid);\n (void)(wuffs_base__image_config__set);\n (void)(wuffs_base__pixel_buffer__palette);\n (void)(wuffs_base__pixel_buffer__pixel_format);\n (" + + "void)(wuffs_base__pixel_buffer__plane);\n (void)(wuffs_base__pixel_buffer__set_from_slice);\n (void)(wuffs_base__pixel_config__bounds);\n (void)(wuffs_base__pixel_config__height);\n (void)(wuffs_base__pixel_config__invalidate);\n (void)(wuffs_base__pixel_config__is_valid);\n (void)(wuffs_base__pixel_config__pixbuf_len);\n (void)(wuffs_base__pixel_config__pixel_format);\n (void)(wuffs_base__pixel_config__pixel_subsampling);\n (void)(wuffs_base__pixel_config__set);\n (void)(wuffs_base__pixel_config__width);\n (void)(wuffs_base__pixel_format__bits_per_pixel);\n (void)(wuffs_base__pixel_format__is_indexed);\n (void)(wuffs_base__pixel_format__is_packed);\n (void)(wuffs_base__pixel_format__is_planar);\n (void)(wuffs_base__pixel_format__is_valid);\n (void)(wuffs_base__pixel_format__num_planes);\n (void)(wuffs_base__pixel_subsampling__bias_x);\n (void)(wuffs_base__pixel_subsampling__bias_y);\n (void)(wuffs_base__pixel_subsampling__shift_x);\n (void)(wuffs_base__pixel_subsampling__shift_y);\n (void)(wuffs_base__pixel_" + + "swizzler__prepare);\n (void)(wuffs_base__pixel_swizzler__swizzle_packed);\n}\n" + "" const baseIOPrivateH = "" + @@ -155,14 +167,19 @@ const baseIOPrivateH = "" + "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" + "" + - "// ---------------- I/O (Utility)\n\nstatic inline wuffs_base__io_reader //\nwuffs_base__utility__null_io_reader(const wuffs_base__utility* ignored) {\n return ((wuffs_base__io_reader){});\n}\n\nstatic inline wuffs_base__io_writer //\nwuffs_base__utility__null_io_writer(const wuffs_base__utility* ignored) {\n return ((wuffs_base__io_writer){});\n}\n" + + "// ---------------- I/O (Utility)\n\nstatic inline wuffs_base__io_reader //\nwuffs_base__utility__null_io_reader(const wuffs_base__utility* ignored) {\n return ((wuffs_base__io_reader){});\n}\n\nstatic inline wuffs_base__io_writer //\nwuffs_base__utility__null_io_writer(const wuffs_base__utility* ignored) {\n return ((wuffs_base__io_writer){});\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" + "" 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" + + "_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" + "" const baseRangePrivateH = "" + @@ -171,15 +188,17 @@ const baseRangePrivateH = "" + "" + "// ---------------- Ranges and Rects (Utility)\n\nstatic inline wuffs_base__range_ii_u32 //\nwuffs_base__utility__make_range_ii_u32(const wuffs_base__utility* ignored,\n uint32_t min_incl,\n uint32_t max_incl) {\n return ((wuffs_base__range_ii_u32){\n .min_incl = min_incl,\n .max_incl = max_incl,\n });\n}\n\nstatic inline wuffs_base__range_ie_u32 //\nwuffs_base__utility__make_range_ie_u32(const wuffs_base__utility* ignored,\n uint32_t min_incl,\n uint32_t max_excl) {\n return ((wuffs_base__range_ie_u32){\n .min_incl = min_incl,\n .max_excl = max_excl,\n });\n}\n\nstatic inline wuffs_base__range_ii_u64 //\nwuffs_base__utility__make_range_ii_u64(const wuffs_base__utility* ignored,\n uint64_t min_incl,\n uint64_t max_incl) {\n return ((wuffs_base__range_ii_u64){\n .min_incl = min_in" + "cl,\n .max_incl = max_incl,\n });\n}\n\nstatic inline wuffs_base__range_ie_u64 //\nwuffs_base__utility__make_range_ie_u64(const wuffs_base__utility* ignored,\n uint64_t min_incl,\n uint64_t max_excl) {\n return ((wuffs_base__range_ie_u64){\n .min_incl = min_incl,\n .max_excl = max_excl,\n });\n}\n\nstatic inline wuffs_base__rect_ii_u32 //\nwuffs_base__utility__make_rect_ii_u32(const wuffs_base__utility* ignored,\n uint32_t min_incl_x,\n uint32_t min_incl_y,\n uint32_t max_incl_x,\n uint32_t max_incl_y) {\n return ((wuffs_base__rect_ii_u32){\n .min_incl_x = min_incl_x,\n .min_incl_y = min_incl_y,\n .max_incl_x = max_incl_x,\n .max_incl_y = max_incl_y,\n });\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__utility__make_rect_ie_u32(const wuffs_base__utility* ignored,\n" + - " uint32_t min_incl_x,\n uint32_t min_incl_y,\n uint32_t max_excl_x,\n uint32_t max_excl_y) {\n return ((wuffs_base__rect_ie_u32){\n .min_incl_x = min_incl_x,\n .min_incl_y = min_incl_y,\n .max_excl_x = max_excl_x,\n .max_excl_y = max_excl_y,\n });\n}\n" + + " uint32_t min_incl_x,\n uint32_t min_incl_y,\n uint32_t max_excl_x,\n uint32_t max_excl_y) {\n return ((wuffs_base__rect_ie_u32){\n .min_incl_x = min_incl_x,\n .min_incl_y = min_incl_y,\n .max_excl_x = max_excl_x,\n .max_excl_y = max_excl_y,\n });\n}\n\n" + + "" + + "// ---------------- Bureaucracy re -Wunused-function\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__range_private()\n WUFFS_BASE__POTENTIALLY_UNUSED;\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__range_private() {\n (void)(wuffs_base__range_ie_u32__get_max_excl);\n (void)(wuffs_base__range_ie_u32__get_min_incl);\n (void)(wuffs_base__range_ie_u64__get_max_excl);\n (void)(wuffs_base__range_ie_u64__get_min_incl);\n (void)(wuffs_base__range_ii_u32__get_max_incl);\n (void)(wuffs_base__range_ii_u32__get_min_incl);\n (void)(wuffs_base__range_ii_u64__get_max_incl);\n (void)(wuffs_base__range_ii_u64__get_min_incl);\n (void)(wuffs_base__utility__make_range_ie_u32);\n (void)(wuffs_base__utility__make_range_ie_u64);\n (void)(wuffs_base__utility__make_range_ii_u32);\n (void)(wuffs_base__utility__make_range_ii_u64);\n (void)(wuffs_base__utility__make_rect_ie_u32);\n (void)(wuffs_base__utility__make_rect_ii_u32);\n}\n" + "" const baseRangePublicH = "" + "// ---------------- Ranges and Rects\n\n// Ranges are either inclusive (\"range_ii\") or exclusive (\"range_ie\") on the\n// high end. Both the \"ii\" and \"ie\" flavors are useful in practice.\n//\n// The \"ei\" and \"ee\" flavors also exist in theory, but aren't widely used. In\n// Wuffs, the low end is always inclusive.\n//\n// The \"ii\" (closed interval) flavor is useful when refining e.g. \"the set of\n// all uint32_t values\" to a contiguous subset: \"uint32_t values in the closed\n// interval [M, N]\", for uint32_t values M and N. An unrefined type (in other\n// words, the set of all uint32_t values) is not representable in the \"ie\"\n// flavor because if N equals ((1<<32) - 1) then (N + 1) will overflow.\n//\n// On the other hand, the \"ie\" (half-open interval) flavor is recommended by\n// Dijkstra's \"Why numbering should start at zero\" at\n// http://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF and a further\n// discussion of motivating rationale is at\n// https://www.quora.com/Why-are-Python-ranges-half-open-exclusive-instead-of-close" + "d-inclusive\n//\n// For example, with \"ie\", the number of elements in \"uint32_t values in the\n// half-open interval [M, N)\" is equal to max(0, N-M). Furthermore, that number\n// of elements (in one dimension, a length, in two dimensions, a width or\n// height) is itself representable as a uint32_t without overflow, again for\n// uint32_t values M and N. In the contrasting \"ii\" flavor, the length of the\n// closed interval [0, (1<<32) - 1] is 1<<32, which cannot be represented as a\n// uint32_t. In Wuffs, because of this potential overflow, the \"ie\" flavor has\n// length / width / height methods, but the \"ii\" flavor does not.\n//\n// It is valid for min > max (for range_ii) or for min >= max (for range_ie),\n// in which case the range is empty. There are multiple representations of an\n// empty range.\n\ntypedef struct wuffs_base__range_ii_u32__struct {\n uint32_t min_incl;\n uint32_t max_incl;\n\n#ifdef __cplusplus\n inline bool is_empty();\n inline bool equals(wuffs_base__range_ii_u32__struct s);\n inline bool contains(uint" + - "32_t x);\n inline wuffs_base__range_ii_u32__struct intersect(\n wuffs_base__range_ii_u32__struct s);\n inline wuffs_base__range_ii_u32__struct unite(\n wuffs_base__range_ii_u32__struct s);\n#endif // __cplusplus\n\n} wuffs_base__range_ii_u32;\n\nstatic inline bool //\nwuffs_base__range_ii_u32__is_empty(wuffs_base__range_ii_u32* r) {\n return r->min_incl > r->max_incl;\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u32__equals(wuffs_base__range_ii_u32* r,\n wuffs_base__range_ii_u32 s) {\n return (r->min_incl == s.min_incl && r->max_incl == s.max_incl) ||\n (wuffs_base__range_ii_u32__is_empty(r) &&\n wuffs_base__range_ii_u32__is_empty(&s));\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u32__contains(wuffs_base__range_ii_u32* r, uint32_t x) {\n return (r->min_incl <= x) && (x <= r->max_incl);\n}\n\nstatic inline //\n wuffs_base__range_ii_u32\n wuffs_base__range_ii_u32__intersect(wuffs_base__range_ii_u32* r,\n wuffs_base__r" + - "ange_ii_u32 s) {\n wuffs_base__range_ii_u32 t;\n t.min_incl = wuffs_base__u32__max(r->min_incl, s.min_incl);\n t.max_incl = wuffs_base__u32__min(r->max_incl, s.max_incl);\n return t;\n}\n\nstatic inline //\n wuffs_base__range_ii_u32\n wuffs_base__range_ii_u32__unite(wuffs_base__range_ii_u32* r,\n wuffs_base__range_ii_u32 s) {\n if (wuffs_base__range_ii_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ii_u32__is_empty(&s)) {\n return *r;\n }\n wuffs_base__range_ii_u32 t;\n t.min_incl = wuffs_base__u32__min(r->min_incl, s.min_incl);\n t.max_incl = wuffs_base__u32__max(r->max_incl, s.max_incl);\n return t;\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__range_ii_u32::is_empty() {\n return wuffs_base__range_ii_u32__is_empty(this);\n}\n\ninline bool //\nwuffs_base__range_ii_u32::equals(wuffs_base__range_ii_u32 s) {\n return wuffs_base__range_ii_u32__equals(this, s);\n}\n\ninline bool //\nwuffs_base__range_ii_u32::contains(uint32_t x) {\n return wuffs_base__range_ii_u" + - "32__contains(this, x);\n}\n\ninline wuffs_base__range_ii_u32 //\nwuffs_base__range_ii_u32::intersect(wuffs_base__range_ii_u32 s) {\n return wuffs_base__range_ii_u32__intersect(this, s);\n}\n\ninline wuffs_base__range_ii_u32 //\nwuffs_base__range_ii_u32::unite(wuffs_base__range_ii_u32 s) {\n return wuffs_base__range_ii_u32__unite(this, s);\n}\n\n#endif // __cplusplus\n\n" + + "32_t x);\n inline wuffs_base__range_ii_u32__struct intersect(\n wuffs_base__range_ii_u32__struct s);\n inline wuffs_base__range_ii_u32__struct unite(\n wuffs_base__range_ii_u32__struct s);\n#endif // __cplusplus\n\n} wuffs_base__range_ii_u32;\n\nstatic inline bool //\nwuffs_base__range_ii_u32__is_empty(wuffs_base__range_ii_u32* r) {\n return r->min_incl > r->max_incl;\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u32__equals(wuffs_base__range_ii_u32* r,\n wuffs_base__range_ii_u32 s) {\n return (r->min_incl == s.min_incl && r->max_incl == s.max_incl) ||\n (wuffs_base__range_ii_u32__is_empty(r) &&\n wuffs_base__range_ii_u32__is_empty(&s));\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u32__contains(wuffs_base__range_ii_u32* r, uint32_t x) {\n return (r->min_incl <= x) && (x <= r->max_incl);\n}\n\nstatic inline wuffs_base__range_ii_u32 //\nwuffs_base__range_ii_u32__intersect(wuffs_base__range_ii_u32* r,\n wuffs_base__range_ii_u32 " + + "s) {\n wuffs_base__range_ii_u32 t;\n t.min_incl = wuffs_base__u32__max(r->min_incl, s.min_incl);\n t.max_incl = wuffs_base__u32__min(r->max_incl, s.max_incl);\n return t;\n}\n\nstatic inline wuffs_base__range_ii_u32 //\nwuffs_base__range_ii_u32__unite(wuffs_base__range_ii_u32* r,\n wuffs_base__range_ii_u32 s) {\n if (wuffs_base__range_ii_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ii_u32__is_empty(&s)) {\n return *r;\n }\n wuffs_base__range_ii_u32 t;\n t.min_incl = wuffs_base__u32__min(r->min_incl, s.min_incl);\n t.max_incl = wuffs_base__u32__max(r->max_incl, s.max_incl);\n return t;\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__range_ii_u32::is_empty() {\n return wuffs_base__range_ii_u32__is_empty(this);\n}\n\ninline bool //\nwuffs_base__range_ii_u32::equals(wuffs_base__range_ii_u32 s) {\n return wuffs_base__range_ii_u32__equals(this, s);\n}\n\ninline bool //\nwuffs_base__range_ii_u32::contains(uint32_t x) {\n return wuffs_base__range_ii_u32__contains(this, x);\n}" + + "\n\ninline wuffs_base__range_ii_u32 //\nwuffs_base__range_ii_u32::intersect(wuffs_base__range_ii_u32 s) {\n return wuffs_base__range_ii_u32__intersect(this, s);\n}\n\ninline wuffs_base__range_ii_u32 //\nwuffs_base__range_ii_u32::unite(wuffs_base__range_ii_u32 s) {\n return wuffs_base__range_ii_u32__unite(this, s);\n}\n\n#endif // __cplusplus\n\n" + "" + "// --------\n\ntypedef struct wuffs_base__range_ie_u32__struct {\n uint32_t min_incl;\n uint32_t max_excl;\n\n#ifdef __cplusplus\n inline bool is_empty();\n inline bool equals(wuffs_base__range_ie_u32__struct s);\n inline bool contains(uint32_t x);\n inline wuffs_base__range_ie_u32__struct intersect(\n wuffs_base__range_ie_u32__struct s);\n inline wuffs_base__range_ie_u32__struct unite(\n wuffs_base__range_ie_u32__struct s);\n inline uint32_t length();\n#endif // __cplusplus\n\n} wuffs_base__range_ie_u32;\n\nstatic inline bool //\nwuffs_base__range_ie_u32__is_empty(wuffs_base__range_ie_u32* r) {\n return r->min_incl >= r->max_excl;\n}\n\nstatic inline bool //\nwuffs_base__range_ie_u32__equals(wuffs_base__range_ie_u32* r,\n wuffs_base__range_ie_u32 s) {\n return (r->min_incl == s.min_incl && r->max_excl == s.max_excl) ||\n (wuffs_base__range_ie_u32__is_empty(r) &&\n wuffs_base__range_ie_u32__is_empty(&s));\n}\n\nstatic inline bool //\nwuffs_base__range_ie_u32__contains(w" + "uffs_base__range_ie_u32* r, uint32_t x) {\n return (r->min_incl <= x) && (x < r->max_excl);\n}\n\nstatic inline wuffs_base__range_ie_u32 //\nwuffs_base__range_ie_u32__intersect(wuffs_base__range_ie_u32* r,\n wuffs_base__range_ie_u32 s) {\n wuffs_base__range_ie_u32 t;\n t.min_incl = wuffs_base__u32__max(r->min_incl, s.min_incl);\n t.max_excl = wuffs_base__u32__min(r->max_excl, s.max_excl);\n return t;\n}\n\nstatic inline wuffs_base__range_ie_u32 //\nwuffs_base__range_ie_u32__unite(wuffs_base__range_ie_u32* r,\n wuffs_base__range_ie_u32 s) {\n if (wuffs_base__range_ie_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ie_u32__is_empty(&s)) {\n return *r;\n }\n wuffs_base__range_ie_u32 t;\n t.min_incl = wuffs_base__u32__min(r->min_incl, s.min_incl);\n t.max_excl = wuffs_base__u32__max(r->max_excl, s.max_excl);\n return t;\n}\n\nstatic inline uint32_t //\nwuffs_base__range_ie_u32__length(wuffs_base__range_ie_u32* r) {\n return wuffs_base__u32__sa" + @@ -202,7 +221,10 @@ const baseRangePublicH = "" + ");\n inline uint32_t height();\n#endif // __cplusplus\n\n} wuffs_base__rect_ie_u32;\n\nstatic inline bool //\nwuffs_base__rect_ie_u32__is_empty(wuffs_base__rect_ie_u32* r) {\n return (r->min_incl_x >= r->max_excl_x) || (r->min_incl_y >= r->max_excl_y);\n}\n\nstatic inline bool //\nwuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32* r,\n wuffs_base__rect_ie_u32 s) {\n return (r->min_incl_x == s.min_incl_x && r->min_incl_y == s.min_incl_y &&\n r->max_excl_x == s.max_excl_x && r->max_excl_y == s.max_excl_y) ||\n (wuffs_base__rect_ie_u32__is_empty(r) &&\n wuffs_base__rect_ie_u32__is_empty(&s));\n}\n\nstatic inline bool //\nwuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32* r,\n uint32_t x,\n uint32_t y) {\n return (r->min_incl_x <= x) && (x < r->max_excl_x) && (r->min_incl_y <= y) &&\n (y < r->max_excl_y);\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__rect_ie_u32__intersect(wuf" + "fs_base__rect_ie_u32* r,\n wuffs_base__rect_ie_u32 s) {\n wuffs_base__rect_ie_u32 t;\n t.min_incl_x = wuffs_base__u32__max(r->min_incl_x, s.min_incl_x);\n t.min_incl_y = wuffs_base__u32__max(r->min_incl_y, s.min_incl_y);\n t.max_excl_x = wuffs_base__u32__min(r->max_excl_x, s.max_excl_x);\n t.max_excl_y = wuffs_base__u32__min(r->max_excl_y, s.max_excl_y);\n return t;\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__rect_ie_u32__unite(wuffs_base__rect_ie_u32* r,\n wuffs_base__rect_ie_u32 s) {\n if (wuffs_base__rect_ie_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__rect_ie_u32__is_empty(&s)) {\n return *r;\n }\n wuffs_base__rect_ie_u32 t;\n t.min_incl_x = wuffs_base__u32__min(r->min_incl_x, s.min_incl_x);\n t.min_incl_y = wuffs_base__u32__min(r->min_incl_y, s.min_incl_y);\n t.max_excl_x = wuffs_base__u32__max(r->max_excl_x, s.max_excl_x);\n t.max_excl_y = wuffs_base__u32__max(r->max_excl_y, s.max_excl_y);\n return t;\n}\n\nstatic inlin" + "e uint32_t //\nwuffs_base__rect_ie_u32__width(wuffs_base__rect_ie_u32* r) {\n return wuffs_base__u32__sat_sub(r->max_excl_x, r->min_incl_x);\n}\n\nstatic inline uint32_t //\nwuffs_base__rect_ie_u32__height(wuffs_base__rect_ie_u32* r) {\n return wuffs_base__u32__sat_sub(r->max_excl_y, r->min_incl_y);\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__rect_ie_u32::is_empty() {\n return wuffs_base__rect_ie_u32__is_empty(this);\n}\n\ninline bool //\nwuffs_base__rect_ie_u32::equals(wuffs_base__rect_ie_u32 s) {\n return wuffs_base__rect_ie_u32__equals(this, s);\n}\n\ninline bool //\nwuffs_base__rect_ie_u32::contains(uint32_t x, uint32_t y) {\n return wuffs_base__rect_ie_u32__contains(this, x, y);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__rect_ie_u32::intersect(wuffs_base__rect_ie_u32 s) {\n return wuffs_base__rect_ie_u32__intersect(this, s);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__rect_ie_u32::unite(wuffs_base__rect_ie_u32 s) {\n return wuffs_base__rect_ie_u32__unite(this, s);\n}\n\ninline uint32_t //\nwuffs_" + - "base__rect_ie_u32::width() {\n return wuffs_base__rect_ie_u32__width(this);\n}\n\ninline uint32_t //\nwuffs_base__rect_ie_u32::height() {\n return wuffs_base__rect_ie_u32__height(this);\n}\n\n#endif // __cplusplus\n" + + "base__rect_ie_u32::width() {\n return wuffs_base__rect_ie_u32__width(this);\n}\n\ninline uint32_t //\nwuffs_base__rect_ie_u32::height() {\n return wuffs_base__rect_ie_u32__height(this);\n}\n\n#endif // __cplusplus\n\n" + + "" + + "// ---------------- Bureaucracy re -Wunused-function\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__range_public()\n WUFFS_BASE__POTENTIALLY_UNUSED;\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__range_public() {\n (void)(wuffs_base__range_ie_u32__contains);\n (void)(wuffs_base__range_ie_u32__equals);\n (void)(wuffs_base__range_ie_u32__intersect);\n (void)(wuffs_base__range_ie_u32__is_empty);\n (void)(wuffs_base__range_ie_u32__length);\n (void)(wuffs_base__range_ie_u32__unite);\n (void)(wuffs_base__range_ie_u64__contains);\n (void)(wuffs_base__range_ie_u64__equals);\n (void)(wuffs_base__range_ie_u64__intersect);\n (void)(wuffs_base__range_ie_u64__is_empty);\n (void)(wuffs_base__range_ie_u64__length);\n (void)(wuffs_base__range_ie_u64__unite);\n (void)(wuffs_base__range_ii_u32__contains);\n (void)(wuffs_base__range_ii_u32__equals);\n (void)(wuffs_base__range_ii_u32__intersect);\n (void)(wuffs_base__range_ii_u32__is_empty);\n (void)(wuffs_base__range_ii_u3" + + "2__unite);\n (void)(wuffs_base__range_ii_u64__contains);\n (void)(wuffs_base__range_ii_u64__equals);\n (void)(wuffs_base__range_ii_u64__intersect);\n (void)(wuffs_base__range_ii_u64__is_empty);\n (void)(wuffs_base__range_ii_u64__unite);\n (void)(wuffs_base__rect_ie_u32__contains);\n (void)(wuffs_base__rect_ie_u32__equals);\n (void)(wuffs_base__rect_ie_u32__height);\n (void)(wuffs_base__rect_ie_u32__intersect);\n (void)(wuffs_base__rect_ie_u32__is_empty);\n (void)(wuffs_base__rect_ie_u32__unite);\n (void)(wuffs_base__rect_ie_u32__width);\n (void)(wuffs_base__rect_ii_u32__contains);\n (void)(wuffs_base__rect_ii_u32__equals);\n (void)(wuffs_base__rect_ii_u32__intersect);\n (void)(wuffs_base__rect_ii_u32__is_empty);\n (void)(wuffs_base__rect_ii_u32__unite);\n}\n" + "" const baseCopyright = "" + diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 10bdd1f5..1ce9bbb3 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -373,6 +373,40 @@ wuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s, return ((wuffs_base__slice_u8){}); } +// ---------------- Bureaucracy re -Wunused-function + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__core_public() + WUFFS_BASE__POTENTIALLY_UNUSED; + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__core_public() { + (void)(wuffs_base__slice_u8__subslice_i); + (void)(wuffs_base__slice_u8__subslice_ij); + (void)(wuffs_base__slice_u8__subslice_j); + (void)(wuffs_base__status__is_complete); + (void)(wuffs_base__status__is_error); + (void)(wuffs_base__status__is_ok); + (void)(wuffs_base__status__is_suspension); + (void)(wuffs_base__status__is_warning); + (void)(wuffs_base__u16__max); + (void)(wuffs_base__u16__min); + (void)(wuffs_base__u16__sat_add); + (void)(wuffs_base__u16__sat_sub); + (void)(wuffs_base__u32__max); + (void)(wuffs_base__u32__min); + (void)(wuffs_base__u32__sat_add); + (void)(wuffs_base__u32__sat_sub); + (void)(wuffs_base__u64__max); + (void)(wuffs_base__u64__min); + (void)(wuffs_base__u64__sat_add); + (void)(wuffs_base__u64__sat_sub); + (void)(wuffs_base__u8__max); + (void)(wuffs_base__u8__min); + (void)(wuffs_base__u8__sat_add); + (void)(wuffs_base__u8__sat_sub); +} + // ---------------- Ranges and Rects // Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the @@ -440,20 +474,18 @@ wuffs_base__range_ii_u32__contains(wuffs_base__range_ii_u32* r, uint32_t x) { return (r->min_incl <= x) && (x <= r->max_incl); } -static inline // - wuffs_base__range_ii_u32 - wuffs_base__range_ii_u32__intersect(wuffs_base__range_ii_u32* r, - wuffs_base__range_ii_u32 s) { +static inline wuffs_base__range_ii_u32 // +wuffs_base__range_ii_u32__intersect(wuffs_base__range_ii_u32* r, + wuffs_base__range_ii_u32 s) { wuffs_base__range_ii_u32 t; t.min_incl = wuffs_base__u32__max(r->min_incl, s.min_incl); t.max_incl = wuffs_base__u32__min(r->max_incl, s.max_incl); return t; } -static inline // - wuffs_base__range_ii_u32 - wuffs_base__range_ii_u32__unite(wuffs_base__range_ii_u32* r, - wuffs_base__range_ii_u32 s) { +static inline wuffs_base__range_ii_u32 // +wuffs_base__range_ii_u32__unite(wuffs_base__range_ii_u32* r, + wuffs_base__range_ii_u32 s) { if (wuffs_base__range_ii_u32__is_empty(r)) { return s; } @@ -1023,6 +1055,50 @@ wuffs_base__rect_ie_u32::height() { #endif // __cplusplus +// ---------------- Bureaucracy re -Wunused-function + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__range_public() + WUFFS_BASE__POTENTIALLY_UNUSED; + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__range_public() { + (void)(wuffs_base__range_ie_u32__contains); + (void)(wuffs_base__range_ie_u32__equals); + (void)(wuffs_base__range_ie_u32__intersect); + (void)(wuffs_base__range_ie_u32__is_empty); + (void)(wuffs_base__range_ie_u32__length); + (void)(wuffs_base__range_ie_u32__unite); + (void)(wuffs_base__range_ie_u64__contains); + (void)(wuffs_base__range_ie_u64__equals); + (void)(wuffs_base__range_ie_u64__intersect); + (void)(wuffs_base__range_ie_u64__is_empty); + (void)(wuffs_base__range_ie_u64__length); + (void)(wuffs_base__range_ie_u64__unite); + (void)(wuffs_base__range_ii_u32__contains); + (void)(wuffs_base__range_ii_u32__equals); + (void)(wuffs_base__range_ii_u32__intersect); + (void)(wuffs_base__range_ii_u32__is_empty); + (void)(wuffs_base__range_ii_u32__unite); + (void)(wuffs_base__range_ii_u64__contains); + (void)(wuffs_base__range_ii_u64__equals); + (void)(wuffs_base__range_ii_u64__intersect); + (void)(wuffs_base__range_ii_u64__is_empty); + (void)(wuffs_base__range_ii_u64__unite); + (void)(wuffs_base__rect_ie_u32__contains); + (void)(wuffs_base__rect_ie_u32__equals); + (void)(wuffs_base__rect_ie_u32__height); + (void)(wuffs_base__rect_ie_u32__intersect); + (void)(wuffs_base__rect_ie_u32__is_empty); + (void)(wuffs_base__rect_ie_u32__unite); + (void)(wuffs_base__rect_ie_u32__width); + (void)(wuffs_base__rect_ii_u32__contains); + (void)(wuffs_base__rect_ii_u32__equals); + (void)(wuffs_base__rect_ii_u32__intersect); + (void)(wuffs_base__rect_ii_u32__is_empty); + (void)(wuffs_base__rect_ii_u32__unite); +} + // ---------------- I/O struct wuffs_base__io_buffer__struct; @@ -1149,6 +1225,21 @@ wuffs_base__io_buffer__struct::writer_io_position() { #endif // __cplusplus +// ---------------- Bureaucracy re -Wunused-function + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__io_public() + WUFFS_BASE__POTENTIALLY_UNUSED; + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__io_public() { + (void)(wuffs_base__io_buffer__compact); + (void)(wuffs_base__io_buffer__reader); + (void)(wuffs_base__io_buffer__reader_io_position); + (void)(wuffs_base__io_buffer__writer); + (void)(wuffs_base__io_buffer__writer_io_position); +} + // ---------------- Memory Allocation // The memory allocation related functions in this section aren't used by Wuffs @@ -1220,6 +1311,20 @@ wuffs_base__malloc_slice_u64(void* (*malloc_func)(size_t), uint64_t num_u64) { return ((wuffs_base__slice_u64){}); } +// ---------------- Bureaucracy re -Wunused-function + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__memory_public() + WUFFS_BASE__POTENTIALLY_UNUSED; + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__memory_public() { + (void)(wuffs_base__malloc_slice_u16); + (void)(wuffs_base__malloc_slice_u32); + (void)(wuffs_base__malloc_slice_u64); + (void)(wuffs_base__malloc_slice_u8); +} + // ---------------- Images // wuffs_base__color_u32_argb_premul is an 8 bit per channel premultiplied @@ -2235,6 +2340,55 @@ wuffs_base__pixel_swizzler::swizzle_packed(wuffs_base__slice_u8 dst, #endif // __cplusplus +// ---------------- Bureaucracy re -Wunused-function + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__image_public() + WUFFS_BASE__POTENTIALLY_UNUSED; + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__image_public() { + (void)(wuffs_base__frame_config__blend); + (void)(wuffs_base__frame_config__bounds); + (void)(wuffs_base__frame_config__disposal); + (void)(wuffs_base__frame_config__duration); + (void)(wuffs_base__frame_config__height); + (void)(wuffs_base__frame_config__index); + (void)(wuffs_base__frame_config__io_position); + (void)(wuffs_base__frame_config__update); + (void)(wuffs_base__frame_config__width); + (void)(wuffs_base__image_config__first_frame_io_position); + (void)(wuffs_base__image_config__first_frame_is_opaque); + (void)(wuffs_base__image_config__invalidate); + (void)(wuffs_base__image_config__is_valid); + (void)(wuffs_base__image_config__set); + (void)(wuffs_base__pixel_buffer__palette); + (void)(wuffs_base__pixel_buffer__pixel_format); + (void)(wuffs_base__pixel_buffer__plane); + (void)(wuffs_base__pixel_buffer__set_from_slice); + (void)(wuffs_base__pixel_config__bounds); + (void)(wuffs_base__pixel_config__height); + (void)(wuffs_base__pixel_config__invalidate); + (void)(wuffs_base__pixel_config__is_valid); + (void)(wuffs_base__pixel_config__pixbuf_len); + (void)(wuffs_base__pixel_config__pixel_format); + (void)(wuffs_base__pixel_config__pixel_subsampling); + (void)(wuffs_base__pixel_config__set); + (void)(wuffs_base__pixel_config__width); + (void)(wuffs_base__pixel_format__bits_per_pixel); + (void)(wuffs_base__pixel_format__is_indexed); + (void)(wuffs_base__pixel_format__is_packed); + (void)(wuffs_base__pixel_format__is_planar); + (void)(wuffs_base__pixel_format__is_valid); + (void)(wuffs_base__pixel_format__num_planes); + (void)(wuffs_base__pixel_subsampling__bias_x); + (void)(wuffs_base__pixel_subsampling__bias_y); + (void)(wuffs_base__pixel_subsampling__shift_x); + (void)(wuffs_base__pixel_subsampling__shift_y); + (void)(wuffs_base__pixel_swizzler__prepare); + (void)(wuffs_base__pixel_swizzler__swizzle_packed); +} + #ifdef __cplusplus } // extern "C" #endif @@ -3765,6 +3919,59 @@ wuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) { return ((wuffs_base__slice_u8){}); } +// ---------------- Bureaucracy re -Wunused-function + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__core_private() + WUFFS_BASE__POTENTIALLY_UNUSED; + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__core_private() { + (void)(wuffs_base__load_u16be); + (void)(wuffs_base__load_u16le); + (void)(wuffs_base__load_u24be); + (void)(wuffs_base__load_u24le); + (void)(wuffs_base__load_u32be); + (void)(wuffs_base__load_u32le); + (void)(wuffs_base__load_u40be); + (void)(wuffs_base__load_u40le); + (void)(wuffs_base__load_u48be); + (void)(wuffs_base__load_u48le); + (void)(wuffs_base__load_u56be); + (void)(wuffs_base__load_u56le); + (void)(wuffs_base__load_u64be); + (void)(wuffs_base__load_u64le); + (void)(wuffs_base__load_u8be); + (void)(wuffs_base__return_empty_struct); + (void)(wuffs_base__slice_u8__copy_from_slice); + (void)(wuffs_base__slice_u8__prefix); + (void)(wuffs_base__slice_u8__suffix); + (void)(wuffs_base__store_u16be); + (void)(wuffs_base__store_u16le); + (void)(wuffs_base__store_u24be); + (void)(wuffs_base__store_u24le); + (void)(wuffs_base__store_u32be); + (void)(wuffs_base__store_u32le); + (void)(wuffs_base__store_u40be); + (void)(wuffs_base__store_u40le); + (void)(wuffs_base__store_u48be); + (void)(wuffs_base__store_u48le); + (void)(wuffs_base__store_u56be); + (void)(wuffs_base__store_u56le); + (void)(wuffs_base__store_u64be); + (void)(wuffs_base__store_u64le); + (void)(wuffs_base__store_u8be); + (void)(wuffs_base__table_u8__row); + (void)(wuffs_base__u16__sat_add_indirect); + (void)(wuffs_base__u16__sat_sub_indirect); + (void)(wuffs_base__u32__sat_add_indirect); + (void)(wuffs_base__u32__sat_sub_indirect); + (void)(wuffs_base__u64__sat_add_indirect); + (void)(wuffs_base__u64__sat_sub_indirect); + (void)(wuffs_base__u8__sat_add_indirect); + (void)(wuffs_base__u8__sat_sub_indirect); +} + // ---------------- Ranges and Rects static inline uint32_t // @@ -3877,6 +4084,30 @@ wuffs_base__utility__make_rect_ie_u32(const wuffs_base__utility* ignored, }); } +// ---------------- Bureaucracy re -Wunused-function + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__range_private() + WUFFS_BASE__POTENTIALLY_UNUSED; + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__range_private() { + (void)(wuffs_base__range_ie_u32__get_max_excl); + (void)(wuffs_base__range_ie_u32__get_min_incl); + (void)(wuffs_base__range_ie_u64__get_max_excl); + (void)(wuffs_base__range_ie_u64__get_min_incl); + (void)(wuffs_base__range_ii_u32__get_max_incl); + (void)(wuffs_base__range_ii_u32__get_min_incl); + (void)(wuffs_base__range_ii_u64__get_max_incl); + (void)(wuffs_base__range_ii_u64__get_min_incl); + (void)(wuffs_base__utility__make_range_ie_u32); + (void)(wuffs_base__utility__make_range_ie_u64); + (void)(wuffs_base__utility__make_range_ii_u32); + (void)(wuffs_base__utility__make_range_ii_u64); + (void)(wuffs_base__utility__make_rect_ie_u32); + (void)(wuffs_base__utility__make_rect_ii_u32); +} + // ---------------- I/O static inline bool // @@ -4138,6 +4369,33 @@ wuffs_base__utility__null_io_writer(const wuffs_base__utility* ignored) { return ((wuffs_base__io_writer){}); } +// ---------------- Bureaucracy re -Wunused-function + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__io_private() + WUFFS_BASE__POTENTIALLY_UNUSED; + +static inline void +wuffs_base__acknowledge_potentially_unused_functions__io_private() { + (void)(wuffs_base__io_buffer__is_valid); + (void)(wuffs_base__io_reader__is_eof); + (void)(wuffs_base__io_reader__is_valid); + (void)(wuffs_base__io_reader__set); + (void)(wuffs_base__io_reader__set_limit); + (void)(wuffs_base__io_reader__set_mark); + (void)(wuffs_base__io_reader__take); + (void)(wuffs_base__io_writer__copy_from_slice); + (void)(wuffs_base__io_writer__copy_n_from_history); + (void)(wuffs_base__io_writer__copy_n_from_history_fast); + (void)(wuffs_base__io_writer__copy_n_from_reader); + (void)(wuffs_base__io_writer__copy_n_from_slice); + (void)(wuffs_base__io_writer__is_valid); + (void)(wuffs_base__io_writer__set); + (void)(wuffs_base__io_writer__set_mark); + (void)(wuffs_base__utility__null_io_reader); + (void)(wuffs_base__utility__null_io_writer); +} + // ---------------- Memory Allocation // ---------------- Images