From 68b94fc2066d63caff0baba3358ceab445f1e390 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Wed, 4 Oct 2023 20:28:05 +1100 Subject: [PATCH] std/gif: remove obsolete `use "std/lzw"` line --- release/c/wuffs-unsupported-snapshot.c | 1612 ++++++++++++------------ std/gif/common_consts.wuffs | 4 - 2 files changed, 806 insertions(+), 810 deletions(-) diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 45f12461..888a1d98 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -8029,253 +8029,6 @@ struct wuffs_deflate__decoder__struct { #endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__DEFLATE) || defined(WUFFS_NONMONOLITHIC) -#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__LZW) || defined(WUFFS_NONMONOLITHIC) - -// ---------------- Status Codes - -extern const char wuffs_lzw__error__bad_code[]; -extern const char wuffs_lzw__error__truncated_input[]; - -// ---------------- Public Consts - -#define WUFFS_LZW__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 - -#define WUFFS_LZW__QUIRK_LITERAL_WIDTH_PLUS_ONE 1348378624 - -// ---------------- Struct Declarations - -typedef struct wuffs_lzw__decoder__struct wuffs_lzw__decoder; - -#ifdef __cplusplus -extern "C" { -#endif - -// ---------------- Public Initializer Prototypes - -// For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, -// etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". -// -// Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. -// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. - -wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT -wuffs_lzw__decoder__initialize( - wuffs_lzw__decoder* self, - size_t sizeof_star_self, - uint64_t wuffs_version, - uint32_t options); - -size_t -sizeof__wuffs_lzw__decoder(); - -// ---------------- Allocs - -// These functions allocate and initialize Wuffs structs. They return NULL if -// memory allocation fails. If they return non-NULL, there is no need to call -// wuffs_foo__bar__initialize, but the caller is responsible for eventually -// calling free on the returned pointer. That pointer is effectively a C++ -// std::unique_ptr. - -wuffs_lzw__decoder* -wuffs_lzw__decoder__alloc(); - -static inline wuffs_base__io_transformer* -wuffs_lzw__decoder__alloc_as__wuffs_base__io_transformer() { - return (wuffs_base__io_transformer*)(wuffs_lzw__decoder__alloc()); -} - -// ---------------- Upcasts - -static inline wuffs_base__io_transformer* -wuffs_lzw__decoder__upcast_as__wuffs_base__io_transformer( - wuffs_lzw__decoder* p) { - return (wuffs_base__io_transformer*)p; -} - -// ---------------- Public Function Prototypes - -WUFFS_BASE__GENERATED_C_CODE -WUFFS_BASE__MAYBE_STATIC uint64_t -wuffs_lzw__decoder__get_quirk( - const wuffs_lzw__decoder* self, - uint32_t a_key); - -WUFFS_BASE__GENERATED_C_CODE -WUFFS_BASE__MAYBE_STATIC wuffs_base__status -wuffs_lzw__decoder__set_quirk( - wuffs_lzw__decoder* self, - uint32_t a_key, - uint64_t a_value); - -WUFFS_BASE__GENERATED_C_CODE -WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 -wuffs_lzw__decoder__workbuf_len( - const wuffs_lzw__decoder* self); - -WUFFS_BASE__GENERATED_C_CODE -WUFFS_BASE__MAYBE_STATIC wuffs_base__status -wuffs_lzw__decoder__transform_io( - wuffs_lzw__decoder* self, - wuffs_base__io_buffer* a_dst, - wuffs_base__io_buffer* a_src, - wuffs_base__slice_u8 a_workbuf); - -WUFFS_BASE__GENERATED_C_CODE -WUFFS_BASE__MAYBE_STATIC wuffs_base__slice_u8 -wuffs_lzw__decoder__flush( - wuffs_lzw__decoder* self); - -#ifdef __cplusplus -} // extern "C" -#endif - -// ---------------- Struct Definitions - -// These structs' fields, and the sizeof them, are private implementation -// details that aren't guaranteed to be stable across Wuffs versions. -// -// See https://en.wikipedia.org/wiki/Opaque_pointer#C - -#if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) - -struct wuffs_lzw__decoder__struct { - // Do not access the private_impl's or private_data's fields directly. There - // is no API/ABI compatibility or safety guarantee if you do so. Instead, use - // the wuffs_foo__bar__baz functions. - // - // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct - // can be stack allocated when WUFFS_IMPLEMENTATION is defined. - - struct { - uint32_t magic; - uint32_t active_coroutine; - wuffs_base__vtable vtable_for__wuffs_base__io_transformer; - wuffs_base__vtable null_vtable; - - uint32_t f_pending_literal_width_plus_one; - uint32_t f_literal_width; - uint32_t f_clear_code; - uint32_t f_end_code; - uint32_t f_save_code; - uint32_t f_prev_code; - uint32_t f_width; - uint32_t f_bits; - uint32_t f_n_bits; - uint32_t f_output_ri; - uint32_t f_output_wi; - uint32_t f_read_from_return_value; - uint16_t f_prefixes[4096]; - - uint32_t p_transform_io[1]; - uint32_t p_write_to[1]; - } private_impl; - - struct { - uint8_t f_suffixes[4096][8]; - uint16_t f_lm1s[4096]; - uint8_t f_output[8199]; - } private_data; - -#ifdef __cplusplus -#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) - using unique_ptr = std::unique_ptr; - - // On failure, the alloc_etc functions return nullptr. They don't throw. - - static inline unique_ptr - alloc() { - return unique_ptr(wuffs_lzw__decoder__alloc()); - } - - static inline wuffs_base__io_transformer::unique_ptr - alloc_as__wuffs_base__io_transformer() { - return wuffs_base__io_transformer::unique_ptr( - wuffs_lzw__decoder__alloc_as__wuffs_base__io_transformer()); - } -#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR) - -#if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) - // Disallow constructing or copying an object via standard C++ mechanisms, - // e.g. the "new" operator, as this struct is intentionally opaque. Its total - // size and field layout is not part of the public, stable, memory-safe API. - // Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and - // call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as - // their first argument) rather than tweaking bar.private_impl.qux fields. - // - // In C, we can just leave wuffs_foo__bar as an incomplete type (unless - // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in - // order to provide convenience methods. These forward on "this", so that you - // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)". - wuffs_lzw__decoder__struct() = delete; - wuffs_lzw__decoder__struct(const wuffs_lzw__decoder__struct&) = delete; - wuffs_lzw__decoder__struct& operator=( - const wuffs_lzw__decoder__struct&) = delete; -#endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) - -#if !defined(WUFFS_IMPLEMENTATION) - // As above, the size of the struct is not part of the public API, and unless - // WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap - // allocated, not stack allocated. Its size is not intended to be known at - // compile time, but it is unfortunately divulged as a side effect of - // defining C++ convenience methods. Use "sizeof__T()", calling the function, - // instead of "sizeof T", invoking the operator. To make the two values - // different, so that passing the latter will be rejected by the initialize - // function, we add an arbitrary amount of dead weight. - uint8_t dead_weight[123000000]; // 123 MB. -#endif // !defined(WUFFS_IMPLEMENTATION) - - inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT - initialize( - size_t sizeof_star_self, - uint64_t wuffs_version, - uint32_t options) { - return wuffs_lzw__decoder__initialize( - this, sizeof_star_self, wuffs_version, options); - } - - inline wuffs_base__io_transformer* - upcast_as__wuffs_base__io_transformer() { - return (wuffs_base__io_transformer*)this; - } - - inline uint64_t - get_quirk( - uint32_t a_key) const { - return wuffs_lzw__decoder__get_quirk(this, a_key); - } - - inline wuffs_base__status - set_quirk( - uint32_t a_key, - uint64_t a_value) { - return wuffs_lzw__decoder__set_quirk(this, a_key, a_value); - } - - inline wuffs_base__range_ii_u64 - workbuf_len() const { - return wuffs_lzw__decoder__workbuf_len(this); - } - - inline wuffs_base__status - transform_io( - wuffs_base__io_buffer* a_dst, - wuffs_base__io_buffer* a_src, - wuffs_base__slice_u8 a_workbuf) { - return wuffs_lzw__decoder__transform_io(this, a_dst, a_src, a_workbuf); - } - - inline wuffs_base__slice_u8 - flush() { - return wuffs_lzw__decoder__flush(this); - } - -#endif // __cplusplus -}; // struct wuffs_lzw__decoder__struct - -#endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) - -#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__LZW) || defined(WUFFS_NONMONOLITHIC) - #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__GIF) || defined(WUFFS_NONMONOLITHIC) // ---------------- Status Codes @@ -9761,6 +9514,253 @@ struct wuffs_json__decoder__struct { #endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__JSON) || defined(WUFFS_NONMONOLITHIC) +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__LZW) || defined(WUFFS_NONMONOLITHIC) + +// ---------------- Status Codes + +extern const char wuffs_lzw__error__bad_code[]; +extern const char wuffs_lzw__error__truncated_input[]; + +// ---------------- Public Consts + +#define WUFFS_LZW__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 + +#define WUFFS_LZW__QUIRK_LITERAL_WIDTH_PLUS_ONE 1348378624 + +// ---------------- Struct Declarations + +typedef struct wuffs_lzw__decoder__struct wuffs_lzw__decoder; + +#ifdef __cplusplus +extern "C" { +#endif + +// ---------------- Public Initializer Prototypes + +// For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, +// etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". +// +// Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. +// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. + +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT +wuffs_lzw__decoder__initialize( + wuffs_lzw__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t options); + +size_t +sizeof__wuffs_lzw__decoder(); + +// ---------------- Allocs + +// These functions allocate and initialize Wuffs structs. They return NULL if +// memory allocation fails. If they return non-NULL, there is no need to call +// wuffs_foo__bar__initialize, but the caller is responsible for eventually +// calling free on the returned pointer. That pointer is effectively a C++ +// std::unique_ptr. + +wuffs_lzw__decoder* +wuffs_lzw__decoder__alloc(); + +static inline wuffs_base__io_transformer* +wuffs_lzw__decoder__alloc_as__wuffs_base__io_transformer() { + return (wuffs_base__io_transformer*)(wuffs_lzw__decoder__alloc()); +} + +// ---------------- Upcasts + +static inline wuffs_base__io_transformer* +wuffs_lzw__decoder__upcast_as__wuffs_base__io_transformer( + wuffs_lzw__decoder* p) { + return (wuffs_base__io_transformer*)p; +} + +// ---------------- Public Function Prototypes + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_lzw__decoder__get_quirk( + const wuffs_lzw__decoder* self, + uint32_t a_key); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_lzw__decoder__set_quirk( + wuffs_lzw__decoder* self, + uint32_t a_key, + uint64_t a_value); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 +wuffs_lzw__decoder__workbuf_len( + const wuffs_lzw__decoder* self); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_lzw__decoder__transform_io( + wuffs_lzw__decoder* self, + wuffs_base__io_buffer* a_dst, + wuffs_base__io_buffer* a_src, + wuffs_base__slice_u8 a_workbuf); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__slice_u8 +wuffs_lzw__decoder__flush( + wuffs_lzw__decoder* self); + +#ifdef __cplusplus +} // extern "C" +#endif + +// ---------------- Struct Definitions + +// These structs' fields, and the sizeof them, are private implementation +// details that aren't guaranteed to be stable across Wuffs versions. +// +// See https://en.wikipedia.org/wiki/Opaque_pointer#C + +#if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) + +struct wuffs_lzw__decoder__struct { + // Do not access the private_impl's or private_data's fields directly. There + // is no API/ABI compatibility or safety guarantee if you do so. Instead, use + // the wuffs_foo__bar__baz functions. + // + // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct + // can be stack allocated when WUFFS_IMPLEMENTATION is defined. + + struct { + uint32_t magic; + uint32_t active_coroutine; + wuffs_base__vtable vtable_for__wuffs_base__io_transformer; + wuffs_base__vtable null_vtable; + + uint32_t f_pending_literal_width_plus_one; + uint32_t f_literal_width; + uint32_t f_clear_code; + uint32_t f_end_code; + uint32_t f_save_code; + uint32_t f_prev_code; + uint32_t f_width; + uint32_t f_bits; + uint32_t f_n_bits; + uint32_t f_output_ri; + uint32_t f_output_wi; + uint32_t f_read_from_return_value; + uint16_t f_prefixes[4096]; + + uint32_t p_transform_io[1]; + uint32_t p_write_to[1]; + } private_impl; + + struct { + uint8_t f_suffixes[4096][8]; + uint16_t f_lm1s[4096]; + uint8_t f_output[8199]; + } private_data; + +#ifdef __cplusplus +#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) + using unique_ptr = std::unique_ptr; + + // On failure, the alloc_etc functions return nullptr. They don't throw. + + static inline unique_ptr + alloc() { + return unique_ptr(wuffs_lzw__decoder__alloc()); + } + + static inline wuffs_base__io_transformer::unique_ptr + alloc_as__wuffs_base__io_transformer() { + return wuffs_base__io_transformer::unique_ptr( + wuffs_lzw__decoder__alloc_as__wuffs_base__io_transformer()); + } +#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR) + +#if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) + // Disallow constructing or copying an object via standard C++ mechanisms, + // e.g. the "new" operator, as this struct is intentionally opaque. Its total + // size and field layout is not part of the public, stable, memory-safe API. + // Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and + // call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as + // their first argument) rather than tweaking bar.private_impl.qux fields. + // + // In C, we can just leave wuffs_foo__bar as an incomplete type (unless + // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in + // order to provide convenience methods. These forward on "this", so that you + // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)". + wuffs_lzw__decoder__struct() = delete; + wuffs_lzw__decoder__struct(const wuffs_lzw__decoder__struct&) = delete; + wuffs_lzw__decoder__struct& operator=( + const wuffs_lzw__decoder__struct&) = delete; +#endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) + +#if !defined(WUFFS_IMPLEMENTATION) + // As above, the size of the struct is not part of the public API, and unless + // WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap + // allocated, not stack allocated. Its size is not intended to be known at + // compile time, but it is unfortunately divulged as a side effect of + // defining C++ convenience methods. Use "sizeof__T()", calling the function, + // instead of "sizeof T", invoking the operator. To make the two values + // different, so that passing the latter will be rejected by the initialize + // function, we add an arbitrary amount of dead weight. + uint8_t dead_weight[123000000]; // 123 MB. +#endif // !defined(WUFFS_IMPLEMENTATION) + + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT + initialize( + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t options) { + return wuffs_lzw__decoder__initialize( + this, sizeof_star_self, wuffs_version, options); + } + + inline wuffs_base__io_transformer* + upcast_as__wuffs_base__io_transformer() { + return (wuffs_base__io_transformer*)this; + } + + inline uint64_t + get_quirk( + uint32_t a_key) const { + return wuffs_lzw__decoder__get_quirk(this, a_key); + } + + inline wuffs_base__status + set_quirk( + uint32_t a_key, + uint64_t a_value) { + return wuffs_lzw__decoder__set_quirk(this, a_key, a_value); + } + + inline wuffs_base__range_ii_u64 + workbuf_len() const { + return wuffs_lzw__decoder__workbuf_len(this); + } + + inline wuffs_base__status + transform_io( + wuffs_base__io_buffer* a_dst, + wuffs_base__io_buffer* a_src, + wuffs_base__slice_u8 a_workbuf) { + return wuffs_lzw__decoder__transform_io(this, a_dst, a_src, a_workbuf); + } + + inline wuffs_base__slice_u8 + flush() { + return wuffs_lzw__decoder__flush(this); + } + +#endif // __cplusplus +}; // struct wuffs_lzw__decoder__struct + +#endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) + +#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__LZW) || defined(WUFFS_NONMONOLITHIC) + #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__NETPBM) || defined(WUFFS_NONMONOLITHIC) // ---------------- Status Codes @@ -35043,565 +35043,6 @@ wuffs_deflate__decoder__decode_huffman_slow( #endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__DEFLATE) -#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__LZW) - -// ---------------- Status Codes Implementations - -const char wuffs_lzw__error__bad_code[] = "#lzw: bad code"; -const char wuffs_lzw__error__truncated_input[] = "#lzw: truncated input"; -const char wuffs_lzw__error__internal_error_inconsistent_i_o[] = "#lzw: internal error: inconsistent I/O"; - -// ---------------- Private Consts - -#define WUFFS_LZW__QUIRKS_BASE 1348378624 - -// ---------------- Private Initializer Prototypes - -// ---------------- Private Function Prototypes - -WUFFS_BASE__GENERATED_C_CODE -static wuffs_base__empty_struct -wuffs_lzw__decoder__read_from( - wuffs_lzw__decoder* self, - wuffs_base__io_buffer* a_src); - -WUFFS_BASE__GENERATED_C_CODE -static wuffs_base__status -wuffs_lzw__decoder__write_to( - wuffs_lzw__decoder* self, - wuffs_base__io_buffer* a_dst); - -// ---------------- VTables - -const wuffs_base__io_transformer__func_ptrs -wuffs_lzw__decoder__func_ptrs_for__wuffs_base__io_transformer = { - (uint64_t(*)(const void*, - uint32_t))(&wuffs_lzw__decoder__get_quirk), - (wuffs_base__status(*)(void*, - uint32_t, - uint64_t))(&wuffs_lzw__decoder__set_quirk), - (wuffs_base__status(*)(void*, - wuffs_base__io_buffer*, - wuffs_base__io_buffer*, - wuffs_base__slice_u8))(&wuffs_lzw__decoder__transform_io), - (wuffs_base__range_ii_u64(*)(const void*))(&wuffs_lzw__decoder__workbuf_len), -}; - -// ---------------- Initializer Implementations - -wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT -wuffs_lzw__decoder__initialize( - wuffs_lzw__decoder* self, - size_t sizeof_star_self, - uint64_t wuffs_version, - uint32_t options){ - if (!self) { - return wuffs_base__make_status(wuffs_base__error__bad_receiver); - } - if (sizeof(*self) != sizeof_star_self) { - return wuffs_base__make_status(wuffs_base__error__bad_sizeof_receiver); - } - if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) || - (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) { - return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version); - } - - if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { - // The whole point of this if-check is to detect an uninitialized *self. - // We disable the warning on GCC. Clang-5.0 does not have this warning. -#if !defined(__clang__) && defined(__GNUC__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wmaybe-uninitialized" -#endif - if (self->private_impl.magic != 0) { - return wuffs_base__make_status(wuffs_base__error__initialize_falsely_claimed_already_zeroed); - } -#if !defined(__clang__) && defined(__GNUC__) -#pragma GCC diagnostic pop -#endif - } else { - if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { - memset(self, 0, sizeof(*self)); - options |= WUFFS_INITIALIZE__ALREADY_ZEROED; - } else { - memset(&(self->private_impl), 0, sizeof(self->private_impl)); - } - } - - self->private_impl.magic = WUFFS_BASE__MAGIC; - self->private_impl.vtable_for__wuffs_base__io_transformer.vtable_name = - wuffs_base__io_transformer__vtable_name; - self->private_impl.vtable_for__wuffs_base__io_transformer.function_pointers = - (const void*)(&wuffs_lzw__decoder__func_ptrs_for__wuffs_base__io_transformer); - return wuffs_base__make_status(NULL); -} - -wuffs_lzw__decoder* -wuffs_lzw__decoder__alloc() { - wuffs_lzw__decoder* x = - (wuffs_lzw__decoder*)(calloc(sizeof(wuffs_lzw__decoder), 1)); - if (!x) { - return NULL; - } - if (wuffs_lzw__decoder__initialize( - x, sizeof(wuffs_lzw__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED).repr) { - free(x); - return NULL; - } - return x; -} - -size_t -sizeof__wuffs_lzw__decoder() { - return sizeof(wuffs_lzw__decoder); -} - -// ---------------- Function Implementations - -// -------- func lzw.decoder.get_quirk - -WUFFS_BASE__GENERATED_C_CODE -WUFFS_BASE__MAYBE_STATIC uint64_t -wuffs_lzw__decoder__get_quirk( - const wuffs_lzw__decoder* self, - uint32_t a_key) { - if (!self) { - return 0; - } - if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && - (self->private_impl.magic != WUFFS_BASE__DISABLED)) { - return 0; - } - - if (a_key == 1348378624u) { - return ((uint64_t)(self->private_impl.f_pending_literal_width_plus_one)); - } - return 0u; -} - -// -------- func lzw.decoder.set_quirk - -WUFFS_BASE__GENERATED_C_CODE -WUFFS_BASE__MAYBE_STATIC wuffs_base__status -wuffs_lzw__decoder__set_quirk( - wuffs_lzw__decoder* self, - uint32_t a_key, - uint64_t a_value) { - if (!self) { - return wuffs_base__make_status(wuffs_base__error__bad_receiver); - } - if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - return wuffs_base__make_status( - (self->private_impl.magic == WUFFS_BASE__DISABLED) - ? wuffs_base__error__disabled_by_previous_error - : wuffs_base__error__initialize_not_called); - } - - if (a_key == 1348378624u) { - if (a_value > 9u) { - return wuffs_base__make_status(wuffs_base__error__bad_argument); - } - self->private_impl.f_pending_literal_width_plus_one = ((uint32_t)(a_value)); - return wuffs_base__make_status(NULL); - } - return wuffs_base__make_status(wuffs_base__error__unsupported_option); -} - -// -------- func lzw.decoder.workbuf_len - -WUFFS_BASE__GENERATED_C_CODE -WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 -wuffs_lzw__decoder__workbuf_len( - const wuffs_lzw__decoder* self) { - if (!self) { - return wuffs_base__utility__empty_range_ii_u64(); - } - if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && - (self->private_impl.magic != WUFFS_BASE__DISABLED)) { - return wuffs_base__utility__empty_range_ii_u64(); - } - - return wuffs_base__utility__make_range_ii_u64(0u, 0u); -} - -// -------- func lzw.decoder.transform_io - -WUFFS_BASE__GENERATED_C_CODE -WUFFS_BASE__MAYBE_STATIC wuffs_base__status -wuffs_lzw__decoder__transform_io( - wuffs_lzw__decoder* self, - wuffs_base__io_buffer* a_dst, - wuffs_base__io_buffer* a_src, - wuffs_base__slice_u8 a_workbuf) { - if (!self) { - return wuffs_base__make_status(wuffs_base__error__bad_receiver); - } - if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - return wuffs_base__make_status( - (self->private_impl.magic == WUFFS_BASE__DISABLED) - ? wuffs_base__error__disabled_by_previous_error - : wuffs_base__error__initialize_not_called); - } - if (!a_dst || !a_src) { - self->private_impl.magic = WUFFS_BASE__DISABLED; - return wuffs_base__make_status(wuffs_base__error__bad_argument); - } - if ((self->private_impl.active_coroutine != 0) && - (self->private_impl.active_coroutine != 1)) { - self->private_impl.magic = WUFFS_BASE__DISABLED; - return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls); - } - self->private_impl.active_coroutine = 0; - wuffs_base__status status = wuffs_base__make_status(NULL); - - uint32_t v_i = 0; - - uint32_t coro_susp_point = self->private_impl.p_transform_io[0]; - switch (coro_susp_point) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; - - self->private_impl.f_literal_width = 8u; - if (self->private_impl.f_pending_literal_width_plus_one > 0u) { - self->private_impl.f_literal_width = (self->private_impl.f_pending_literal_width_plus_one - 1u); - } - self->private_impl.f_clear_code = (((uint32_t)(1u)) << self->private_impl.f_literal_width); - self->private_impl.f_end_code = (self->private_impl.f_clear_code + 1u); - self->private_impl.f_save_code = self->private_impl.f_end_code; - self->private_impl.f_prev_code = self->private_impl.f_end_code; - self->private_impl.f_width = (self->private_impl.f_literal_width + 1u); - self->private_impl.f_bits = 0u; - self->private_impl.f_n_bits = 0u; - self->private_impl.f_output_ri = 0u; - self->private_impl.f_output_wi = 0u; - v_i = 0u; - while (v_i < self->private_impl.f_clear_code) { - self->private_data.f_lm1s[v_i] = 0u; - self->private_data.f_suffixes[v_i][0u] = ((uint8_t)(v_i)); - v_i += 1u; - } - while (true) { - wuffs_lzw__decoder__read_from(self, a_src); - if (self->private_impl.f_output_wi > 0u) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); - status = wuffs_lzw__decoder__write_to(self, a_dst); - if (status.repr) { - goto suspend; - } - } - if (self->private_impl.f_read_from_return_value == 0u) { - break; - } else if (self->private_impl.f_read_from_return_value == 1u) { - continue; - } else if (self->private_impl.f_read_from_return_value == 2u) { - status = wuffs_base__make_status(wuffs_base__suspension__short_read); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2); - } else if (self->private_impl.f_read_from_return_value == 3u) { - status = wuffs_base__make_status(wuffs_lzw__error__truncated_input); - goto exit; - } else if (self->private_impl.f_read_from_return_value == 4u) { - status = wuffs_base__make_status(wuffs_lzw__error__bad_code); - goto exit; - } else { - status = wuffs_base__make_status(wuffs_lzw__error__internal_error_inconsistent_i_o); - goto exit; - } - } - - ok: - self->private_impl.p_transform_io[0] = 0; - goto exit; - } - - goto suspend; - suspend: - self->private_impl.p_transform_io[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; - self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 1 : 0; - - goto exit; - exit: - if (wuffs_base__status__is_error(&status)) { - self->private_impl.magic = WUFFS_BASE__DISABLED; - } - return status; -} - -// -------- func lzw.decoder.read_from - -WUFFS_BASE__GENERATED_C_CODE -static wuffs_base__empty_struct -wuffs_lzw__decoder__read_from( - wuffs_lzw__decoder* self, - wuffs_base__io_buffer* a_src) { - uint32_t v_clear_code = 0; - uint32_t v_end_code = 0; - uint32_t v_save_code = 0; - uint32_t v_prev_code = 0; - uint32_t v_width = 0; - uint32_t v_bits = 0; - uint32_t v_n_bits = 0; - uint32_t v_output_wi = 0; - uint32_t v_code = 0; - uint32_t v_c = 0; - uint32_t v_o = 0; - uint32_t v_steps = 0; - uint8_t v_first_byte = 0; - uint16_t v_lm1_b = 0; - uint16_t v_lm1_a = 0; - - const uint8_t* iop_a_src = NULL; - const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; - const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; - const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; - if (a_src && a_src->data.ptr) { - io0_a_src = a_src->data.ptr; - io1_a_src = io0_a_src + a_src->meta.ri; - iop_a_src = io1_a_src; - io2_a_src = io0_a_src + a_src->meta.wi; - } - - v_clear_code = self->private_impl.f_clear_code; - v_end_code = self->private_impl.f_end_code; - v_save_code = self->private_impl.f_save_code; - v_prev_code = self->private_impl.f_prev_code; - v_width = self->private_impl.f_width; - v_bits = self->private_impl.f_bits; - v_n_bits = self->private_impl.f_n_bits; - v_output_wi = self->private_impl.f_output_wi; - while (true) { - if (v_n_bits < v_width) { - if (((uint64_t)(io2_a_src - iop_a_src)) >= 4u) { - v_bits |= ((uint32_t)(wuffs_base__peek_u32le__no_bounds_check(iop_a_src) << v_n_bits)); - iop_a_src += ((31u - v_n_bits) >> 3u); - v_n_bits |= 24u; - } else if (((uint64_t)(io2_a_src - iop_a_src)) <= 0u) { - if (a_src && a_src->meta.closed) { - self->private_impl.f_read_from_return_value = 3u; - } else { - self->private_impl.f_read_from_return_value = 2u; - } - break; - } else { - v_bits |= (((uint32_t)(wuffs_base__peek_u8be__no_bounds_check(iop_a_src))) << v_n_bits); - iop_a_src += 1u; - v_n_bits += 8u; - if (v_n_bits >= v_width) { - } else if (((uint64_t)(io2_a_src - iop_a_src)) <= 0u) { - if (a_src && a_src->meta.closed) { - self->private_impl.f_read_from_return_value = 3u; - } else { - self->private_impl.f_read_from_return_value = 2u; - } - break; - } else { - v_bits |= (((uint32_t)(wuffs_base__peek_u8be__no_bounds_check(iop_a_src))) << v_n_bits); - iop_a_src += 1u; - v_n_bits += 8u; - if (v_n_bits < v_width) { - self->private_impl.f_read_from_return_value = 5u; - break; - } - } - } - } - v_code = ((v_bits) & WUFFS_BASE__LOW_BITS_MASK__U32(v_width)); - v_bits >>= v_width; - v_n_bits -= v_width; - if (v_code < v_clear_code) { - self->private_data.f_output[v_output_wi] = ((uint8_t)(v_code)); - v_output_wi = ((v_output_wi + 1u) & 8191u); - if (v_save_code <= 4095u) { - v_lm1_a = (((uint16_t)(self->private_data.f_lm1s[v_prev_code] + 1u)) & 4095u); - self->private_data.f_lm1s[v_save_code] = v_lm1_a; - if ((v_lm1_a % 8u) != 0u) { - self->private_impl.f_prefixes[v_save_code] = self->private_impl.f_prefixes[v_prev_code]; - memcpy(self->private_data.f_suffixes[v_save_code],self->private_data.f_suffixes[v_prev_code], sizeof(self->private_data.f_suffixes[v_save_code])); - self->private_data.f_suffixes[v_save_code][(v_lm1_a % 8u)] = ((uint8_t)(v_code)); - } else { - self->private_impl.f_prefixes[v_save_code] = ((uint16_t)(v_prev_code)); - self->private_data.f_suffixes[v_save_code][0u] = ((uint8_t)(v_code)); - } - v_save_code += 1u; - if (v_width < 12u) { - v_width += (1u & (v_save_code >> v_width)); - } - v_prev_code = v_code; - } - } else if (v_code <= v_end_code) { - if (v_code == v_end_code) { - self->private_impl.f_read_from_return_value = 0u; - break; - } - v_save_code = v_end_code; - v_prev_code = v_end_code; - v_width = (self->private_impl.f_literal_width + 1u); - } else if (v_code <= v_save_code) { - v_c = v_code; - if (v_code == v_save_code) { - v_c = v_prev_code; - } - v_o = ((v_output_wi + (((uint32_t)(self->private_data.f_lm1s[v_c])) & 4294967288u)) & 8191u); - v_output_wi = ((v_output_wi + 1u + ((uint32_t)(self->private_data.f_lm1s[v_c]))) & 8191u); - v_steps = (((uint32_t)(self->private_data.f_lm1s[v_c])) >> 3u); - while (true) { - memcpy((self->private_data.f_output)+(v_o), (self->private_data.f_suffixes[v_c]), 8u); - if (v_steps <= 0u) { - break; - } - v_steps -= 1u; - v_o = (((uint32_t)(v_o - 8u)) & 8191u); - v_c = ((uint32_t)(self->private_impl.f_prefixes[v_c])); - } - v_first_byte = self->private_data.f_suffixes[v_c][0u]; - if (v_code == v_save_code) { - self->private_data.f_output[v_output_wi] = v_first_byte; - v_output_wi = ((v_output_wi + 1u) & 8191u); - } - if (v_save_code <= 4095u) { - v_lm1_b = (((uint16_t)(self->private_data.f_lm1s[v_prev_code] + 1u)) & 4095u); - self->private_data.f_lm1s[v_save_code] = v_lm1_b; - if ((v_lm1_b % 8u) != 0u) { - self->private_impl.f_prefixes[v_save_code] = self->private_impl.f_prefixes[v_prev_code]; - memcpy(self->private_data.f_suffixes[v_save_code],self->private_data.f_suffixes[v_prev_code], sizeof(self->private_data.f_suffixes[v_save_code])); - self->private_data.f_suffixes[v_save_code][(v_lm1_b % 8u)] = v_first_byte; - } else { - self->private_impl.f_prefixes[v_save_code] = ((uint16_t)(v_prev_code)); - self->private_data.f_suffixes[v_save_code][0u] = ((uint8_t)(v_first_byte)); - } - v_save_code += 1u; - if (v_width < 12u) { - v_width += (1u & (v_save_code >> v_width)); - } - v_prev_code = v_code; - } - } else { - self->private_impl.f_read_from_return_value = 4u; - break; - } - if (v_output_wi > 4095u) { - self->private_impl.f_read_from_return_value = 1u; - break; - } - } - if (self->private_impl.f_read_from_return_value != 2u) { - while (v_n_bits >= 8u) { - v_n_bits -= 8u; - if (iop_a_src > io1_a_src) { - iop_a_src--; - } else { - self->private_impl.f_read_from_return_value = 5u; - break; - } - } - } - self->private_impl.f_save_code = v_save_code; - self->private_impl.f_prev_code = v_prev_code; - self->private_impl.f_width = v_width; - self->private_impl.f_bits = v_bits; - self->private_impl.f_n_bits = v_n_bits; - self->private_impl.f_output_wi = v_output_wi; - if (a_src && a_src->data.ptr) { - a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); - } - - return wuffs_base__make_empty_struct(); -} - -// -------- func lzw.decoder.write_to - -WUFFS_BASE__GENERATED_C_CODE -static wuffs_base__status -wuffs_lzw__decoder__write_to( - wuffs_lzw__decoder* self, - wuffs_base__io_buffer* a_dst) { - wuffs_base__status status = wuffs_base__make_status(NULL); - - wuffs_base__slice_u8 v_s = {0}; - uint64_t v_n = 0; - - uint8_t* iop_a_dst = NULL; - uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL; - uint8_t* io1_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL; - uint8_t* io2_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL; - if (a_dst && a_dst->data.ptr) { - io0_a_dst = a_dst->data.ptr; - io1_a_dst = io0_a_dst + a_dst->meta.wi; - iop_a_dst = io1_a_dst; - io2_a_dst = io0_a_dst + a_dst->data.len; - if (a_dst->meta.closed) { - io2_a_dst = iop_a_dst; - } - } - - uint32_t coro_susp_point = self->private_impl.p_write_to[0]; - switch (coro_susp_point) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; - - while (self->private_impl.f_output_wi > 0u) { - if (self->private_impl.f_output_ri > self->private_impl.f_output_wi) { - status = wuffs_base__make_status(wuffs_lzw__error__internal_error_inconsistent_i_o); - goto exit; - } - v_s = wuffs_base__make_slice_u8_ij(self->private_data.f_output, - self->private_impl.f_output_ri, - self->private_impl.f_output_wi); - v_n = wuffs_base__io_writer__copy_from_slice(&iop_a_dst, io2_a_dst,v_s); - if (v_n == ((uint64_t)(v_s.len))) { - self->private_impl.f_output_ri = 0u; - self->private_impl.f_output_wi = 0u; - status = wuffs_base__make_status(NULL); - goto ok; - } - self->private_impl.f_output_ri = (((uint32_t)(self->private_impl.f_output_ri + ((uint32_t)(v_n)))) & 8191u); - status = wuffs_base__make_status(wuffs_base__suspension__short_write); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1); - } - - ok: - self->private_impl.p_write_to[0] = 0; - goto exit; - } - - goto suspend; - suspend: - self->private_impl.p_write_to[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; - - goto exit; - exit: - if (a_dst && a_dst->data.ptr) { - a_dst->meta.wi = ((size_t)(iop_a_dst - a_dst->data.ptr)); - } - - return status; -} - -// -------- func lzw.decoder.flush - -WUFFS_BASE__GENERATED_C_CODE -WUFFS_BASE__MAYBE_STATIC wuffs_base__slice_u8 -wuffs_lzw__decoder__flush( - wuffs_lzw__decoder* self) { - if (!self) { - return wuffs_base__make_slice_u8(NULL, 0); - } - if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - return wuffs_base__make_slice_u8(NULL, 0); - } - - uint32_t v_ri = 0; - uint32_t v_wi = 0; - - v_ri = self->private_impl.f_output_ri; - v_wi = self->private_impl.f_output_wi; - self->private_impl.f_output_ri = 0u; - self->private_impl.f_output_wi = 0u; - if (v_ri <= v_wi) { - return wuffs_base__make_slice_u8_ij(self->private_data.f_output, v_ri, v_wi); - } - return wuffs_base__make_slice_u8(self->private_data.f_output, 0); -} - -#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__LZW) - #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__GIF) // ---------------- Status Codes Implementations @@ -48170,6 +47611,565 @@ wuffs_json__decoder__decode_trailer( #endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__JSON) +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__LZW) + +// ---------------- Status Codes Implementations + +const char wuffs_lzw__error__bad_code[] = "#lzw: bad code"; +const char wuffs_lzw__error__truncated_input[] = "#lzw: truncated input"; +const char wuffs_lzw__error__internal_error_inconsistent_i_o[] = "#lzw: internal error: inconsistent I/O"; + +// ---------------- Private Consts + +#define WUFFS_LZW__QUIRKS_BASE 1348378624 + +// ---------------- Private Initializer Prototypes + +// ---------------- Private Function Prototypes + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_lzw__decoder__read_from( + wuffs_lzw__decoder* self, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_lzw__decoder__write_to( + wuffs_lzw__decoder* self, + wuffs_base__io_buffer* a_dst); + +// ---------------- VTables + +const wuffs_base__io_transformer__func_ptrs +wuffs_lzw__decoder__func_ptrs_for__wuffs_base__io_transformer = { + (uint64_t(*)(const void*, + uint32_t))(&wuffs_lzw__decoder__get_quirk), + (wuffs_base__status(*)(void*, + uint32_t, + uint64_t))(&wuffs_lzw__decoder__set_quirk), + (wuffs_base__status(*)(void*, + wuffs_base__io_buffer*, + wuffs_base__io_buffer*, + wuffs_base__slice_u8))(&wuffs_lzw__decoder__transform_io), + (wuffs_base__range_ii_u64(*)(const void*))(&wuffs_lzw__decoder__workbuf_len), +}; + +// ---------------- Initializer Implementations + +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT +wuffs_lzw__decoder__initialize( + wuffs_lzw__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t options){ + if (!self) { + return wuffs_base__make_status(wuffs_base__error__bad_receiver); + } + if (sizeof(*self) != sizeof_star_self) { + return wuffs_base__make_status(wuffs_base__error__bad_sizeof_receiver); + } + if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) || + (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) { + return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version); + } + + if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { + // The whole point of this if-check is to detect an uninitialized *self. + // We disable the warning on GCC. Clang-5.0 does not have this warning. +#if !defined(__clang__) && defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wmaybe-uninitialized" +#endif + if (self->private_impl.magic != 0) { + return wuffs_base__make_status(wuffs_base__error__initialize_falsely_claimed_already_zeroed); + } +#if !defined(__clang__) && defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } else { + if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { + memset(self, 0, sizeof(*self)); + options |= WUFFS_INITIALIZE__ALREADY_ZEROED; + } else { + memset(&(self->private_impl), 0, sizeof(self->private_impl)); + } + } + + self->private_impl.magic = WUFFS_BASE__MAGIC; + self->private_impl.vtable_for__wuffs_base__io_transformer.vtable_name = + wuffs_base__io_transformer__vtable_name; + self->private_impl.vtable_for__wuffs_base__io_transformer.function_pointers = + (const void*)(&wuffs_lzw__decoder__func_ptrs_for__wuffs_base__io_transformer); + return wuffs_base__make_status(NULL); +} + +wuffs_lzw__decoder* +wuffs_lzw__decoder__alloc() { + wuffs_lzw__decoder* x = + (wuffs_lzw__decoder*)(calloc(sizeof(wuffs_lzw__decoder), 1)); + if (!x) { + return NULL; + } + if (wuffs_lzw__decoder__initialize( + x, sizeof(wuffs_lzw__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED).repr) { + free(x); + return NULL; + } + return x; +} + +size_t +sizeof__wuffs_lzw__decoder() { + return sizeof(wuffs_lzw__decoder); +} + +// ---------------- Function Implementations + +// -------- func lzw.decoder.get_quirk + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_lzw__decoder__get_quirk( + const wuffs_lzw__decoder* self, + uint32_t a_key) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + if (a_key == 1348378624u) { + return ((uint64_t)(self->private_impl.f_pending_literal_width_plus_one)); + } + return 0u; +} + +// -------- func lzw.decoder.set_quirk + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_lzw__decoder__set_quirk( + wuffs_lzw__decoder* self, + uint32_t a_key, + uint64_t a_value) { + if (!self) { + return wuffs_base__make_status(wuffs_base__error__bad_receiver); + } + if (self->private_impl.magic != WUFFS_BASE__MAGIC) { + return wuffs_base__make_status( + (self->private_impl.magic == WUFFS_BASE__DISABLED) + ? wuffs_base__error__disabled_by_previous_error + : wuffs_base__error__initialize_not_called); + } + + if (a_key == 1348378624u) { + if (a_value > 9u) { + return wuffs_base__make_status(wuffs_base__error__bad_argument); + } + self->private_impl.f_pending_literal_width_plus_one = ((uint32_t)(a_value)); + return wuffs_base__make_status(NULL); + } + return wuffs_base__make_status(wuffs_base__error__unsupported_option); +} + +// -------- func lzw.decoder.workbuf_len + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 +wuffs_lzw__decoder__workbuf_len( + const wuffs_lzw__decoder* self) { + if (!self) { + return wuffs_base__utility__empty_range_ii_u64(); + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return wuffs_base__utility__empty_range_ii_u64(); + } + + return wuffs_base__utility__make_range_ii_u64(0u, 0u); +} + +// -------- func lzw.decoder.transform_io + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_lzw__decoder__transform_io( + wuffs_lzw__decoder* self, + wuffs_base__io_buffer* a_dst, + wuffs_base__io_buffer* a_src, + wuffs_base__slice_u8 a_workbuf) { + if (!self) { + return wuffs_base__make_status(wuffs_base__error__bad_receiver); + } + if (self->private_impl.magic != WUFFS_BASE__MAGIC) { + return wuffs_base__make_status( + (self->private_impl.magic == WUFFS_BASE__DISABLED) + ? wuffs_base__error__disabled_by_previous_error + : wuffs_base__error__initialize_not_called); + } + if (!a_dst || !a_src) { + self->private_impl.magic = WUFFS_BASE__DISABLED; + return wuffs_base__make_status(wuffs_base__error__bad_argument); + } + if ((self->private_impl.active_coroutine != 0) && + (self->private_impl.active_coroutine != 1)) { + self->private_impl.magic = WUFFS_BASE__DISABLED; + return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls); + } + self->private_impl.active_coroutine = 0; + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint32_t v_i = 0; + + uint32_t coro_susp_point = self->private_impl.p_transform_io[0]; + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + self->private_impl.f_literal_width = 8u; + if (self->private_impl.f_pending_literal_width_plus_one > 0u) { + self->private_impl.f_literal_width = (self->private_impl.f_pending_literal_width_plus_one - 1u); + } + self->private_impl.f_clear_code = (((uint32_t)(1u)) << self->private_impl.f_literal_width); + self->private_impl.f_end_code = (self->private_impl.f_clear_code + 1u); + self->private_impl.f_save_code = self->private_impl.f_end_code; + self->private_impl.f_prev_code = self->private_impl.f_end_code; + self->private_impl.f_width = (self->private_impl.f_literal_width + 1u); + self->private_impl.f_bits = 0u; + self->private_impl.f_n_bits = 0u; + self->private_impl.f_output_ri = 0u; + self->private_impl.f_output_wi = 0u; + v_i = 0u; + while (v_i < self->private_impl.f_clear_code) { + self->private_data.f_lm1s[v_i] = 0u; + self->private_data.f_suffixes[v_i][0u] = ((uint8_t)(v_i)); + v_i += 1u; + } + while (true) { + wuffs_lzw__decoder__read_from(self, a_src); + if (self->private_impl.f_output_wi > 0u) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + status = wuffs_lzw__decoder__write_to(self, a_dst); + if (status.repr) { + goto suspend; + } + } + if (self->private_impl.f_read_from_return_value == 0u) { + break; + } else if (self->private_impl.f_read_from_return_value == 1u) { + continue; + } else if (self->private_impl.f_read_from_return_value == 2u) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2); + } else if (self->private_impl.f_read_from_return_value == 3u) { + status = wuffs_base__make_status(wuffs_lzw__error__truncated_input); + goto exit; + } else if (self->private_impl.f_read_from_return_value == 4u) { + status = wuffs_base__make_status(wuffs_lzw__error__bad_code); + goto exit; + } else { + status = wuffs_base__make_status(wuffs_lzw__error__internal_error_inconsistent_i_o); + goto exit; + } + } + + ok: + self->private_impl.p_transform_io[0] = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_transform_io[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 1 : 0; + + goto exit; + exit: + if (wuffs_base__status__is_error(&status)) { + self->private_impl.magic = WUFFS_BASE__DISABLED; + } + return status; +} + +// -------- func lzw.decoder.read_from + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_lzw__decoder__read_from( + wuffs_lzw__decoder* self, + wuffs_base__io_buffer* a_src) { + uint32_t v_clear_code = 0; + uint32_t v_end_code = 0; + uint32_t v_save_code = 0; + uint32_t v_prev_code = 0; + uint32_t v_width = 0; + uint32_t v_bits = 0; + uint32_t v_n_bits = 0; + uint32_t v_output_wi = 0; + uint32_t v_code = 0; + uint32_t v_c = 0; + uint32_t v_o = 0; + uint32_t v_steps = 0; + uint8_t v_first_byte = 0; + uint16_t v_lm1_b = 0; + uint16_t v_lm1_a = 0; + + const uint8_t* iop_a_src = NULL; + const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + if (a_src && a_src->data.ptr) { + io0_a_src = a_src->data.ptr; + io1_a_src = io0_a_src + a_src->meta.ri; + iop_a_src = io1_a_src; + io2_a_src = io0_a_src + a_src->meta.wi; + } + + v_clear_code = self->private_impl.f_clear_code; + v_end_code = self->private_impl.f_end_code; + v_save_code = self->private_impl.f_save_code; + v_prev_code = self->private_impl.f_prev_code; + v_width = self->private_impl.f_width; + v_bits = self->private_impl.f_bits; + v_n_bits = self->private_impl.f_n_bits; + v_output_wi = self->private_impl.f_output_wi; + while (true) { + if (v_n_bits < v_width) { + if (((uint64_t)(io2_a_src - iop_a_src)) >= 4u) { + v_bits |= ((uint32_t)(wuffs_base__peek_u32le__no_bounds_check(iop_a_src) << v_n_bits)); + iop_a_src += ((31u - v_n_bits) >> 3u); + v_n_bits |= 24u; + } else if (((uint64_t)(io2_a_src - iop_a_src)) <= 0u) { + if (a_src && a_src->meta.closed) { + self->private_impl.f_read_from_return_value = 3u; + } else { + self->private_impl.f_read_from_return_value = 2u; + } + break; + } else { + v_bits |= (((uint32_t)(wuffs_base__peek_u8be__no_bounds_check(iop_a_src))) << v_n_bits); + iop_a_src += 1u; + v_n_bits += 8u; + if (v_n_bits >= v_width) { + } else if (((uint64_t)(io2_a_src - iop_a_src)) <= 0u) { + if (a_src && a_src->meta.closed) { + self->private_impl.f_read_from_return_value = 3u; + } else { + self->private_impl.f_read_from_return_value = 2u; + } + break; + } else { + v_bits |= (((uint32_t)(wuffs_base__peek_u8be__no_bounds_check(iop_a_src))) << v_n_bits); + iop_a_src += 1u; + v_n_bits += 8u; + if (v_n_bits < v_width) { + self->private_impl.f_read_from_return_value = 5u; + break; + } + } + } + } + v_code = ((v_bits) & WUFFS_BASE__LOW_BITS_MASK__U32(v_width)); + v_bits >>= v_width; + v_n_bits -= v_width; + if (v_code < v_clear_code) { + self->private_data.f_output[v_output_wi] = ((uint8_t)(v_code)); + v_output_wi = ((v_output_wi + 1u) & 8191u); + if (v_save_code <= 4095u) { + v_lm1_a = (((uint16_t)(self->private_data.f_lm1s[v_prev_code] + 1u)) & 4095u); + self->private_data.f_lm1s[v_save_code] = v_lm1_a; + if ((v_lm1_a % 8u) != 0u) { + self->private_impl.f_prefixes[v_save_code] = self->private_impl.f_prefixes[v_prev_code]; + memcpy(self->private_data.f_suffixes[v_save_code],self->private_data.f_suffixes[v_prev_code], sizeof(self->private_data.f_suffixes[v_save_code])); + self->private_data.f_suffixes[v_save_code][(v_lm1_a % 8u)] = ((uint8_t)(v_code)); + } else { + self->private_impl.f_prefixes[v_save_code] = ((uint16_t)(v_prev_code)); + self->private_data.f_suffixes[v_save_code][0u] = ((uint8_t)(v_code)); + } + v_save_code += 1u; + if (v_width < 12u) { + v_width += (1u & (v_save_code >> v_width)); + } + v_prev_code = v_code; + } + } else if (v_code <= v_end_code) { + if (v_code == v_end_code) { + self->private_impl.f_read_from_return_value = 0u; + break; + } + v_save_code = v_end_code; + v_prev_code = v_end_code; + v_width = (self->private_impl.f_literal_width + 1u); + } else if (v_code <= v_save_code) { + v_c = v_code; + if (v_code == v_save_code) { + v_c = v_prev_code; + } + v_o = ((v_output_wi + (((uint32_t)(self->private_data.f_lm1s[v_c])) & 4294967288u)) & 8191u); + v_output_wi = ((v_output_wi + 1u + ((uint32_t)(self->private_data.f_lm1s[v_c]))) & 8191u); + v_steps = (((uint32_t)(self->private_data.f_lm1s[v_c])) >> 3u); + while (true) { + memcpy((self->private_data.f_output)+(v_o), (self->private_data.f_suffixes[v_c]), 8u); + if (v_steps <= 0u) { + break; + } + v_steps -= 1u; + v_o = (((uint32_t)(v_o - 8u)) & 8191u); + v_c = ((uint32_t)(self->private_impl.f_prefixes[v_c])); + } + v_first_byte = self->private_data.f_suffixes[v_c][0u]; + if (v_code == v_save_code) { + self->private_data.f_output[v_output_wi] = v_first_byte; + v_output_wi = ((v_output_wi + 1u) & 8191u); + } + if (v_save_code <= 4095u) { + v_lm1_b = (((uint16_t)(self->private_data.f_lm1s[v_prev_code] + 1u)) & 4095u); + self->private_data.f_lm1s[v_save_code] = v_lm1_b; + if ((v_lm1_b % 8u) != 0u) { + self->private_impl.f_prefixes[v_save_code] = self->private_impl.f_prefixes[v_prev_code]; + memcpy(self->private_data.f_suffixes[v_save_code],self->private_data.f_suffixes[v_prev_code], sizeof(self->private_data.f_suffixes[v_save_code])); + self->private_data.f_suffixes[v_save_code][(v_lm1_b % 8u)] = v_first_byte; + } else { + self->private_impl.f_prefixes[v_save_code] = ((uint16_t)(v_prev_code)); + self->private_data.f_suffixes[v_save_code][0u] = ((uint8_t)(v_first_byte)); + } + v_save_code += 1u; + if (v_width < 12u) { + v_width += (1u & (v_save_code >> v_width)); + } + v_prev_code = v_code; + } + } else { + self->private_impl.f_read_from_return_value = 4u; + break; + } + if (v_output_wi > 4095u) { + self->private_impl.f_read_from_return_value = 1u; + break; + } + } + if (self->private_impl.f_read_from_return_value != 2u) { + while (v_n_bits >= 8u) { + v_n_bits -= 8u; + if (iop_a_src > io1_a_src) { + iop_a_src--; + } else { + self->private_impl.f_read_from_return_value = 5u; + break; + } + } + } + self->private_impl.f_save_code = v_save_code; + self->private_impl.f_prev_code = v_prev_code; + self->private_impl.f_width = v_width; + self->private_impl.f_bits = v_bits; + self->private_impl.f_n_bits = v_n_bits; + self->private_impl.f_output_wi = v_output_wi; + if (a_src && a_src->data.ptr) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return wuffs_base__make_empty_struct(); +} + +// -------- func lzw.decoder.write_to + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_lzw__decoder__write_to( + wuffs_lzw__decoder* self, + wuffs_base__io_buffer* a_dst) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + wuffs_base__slice_u8 v_s = {0}; + uint64_t v_n = 0; + + uint8_t* iop_a_dst = NULL; + uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + uint8_t* io1_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + uint8_t* io2_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + if (a_dst && a_dst->data.ptr) { + io0_a_dst = a_dst->data.ptr; + io1_a_dst = io0_a_dst + a_dst->meta.wi; + iop_a_dst = io1_a_dst; + io2_a_dst = io0_a_dst + a_dst->data.len; + if (a_dst->meta.closed) { + io2_a_dst = iop_a_dst; + } + } + + uint32_t coro_susp_point = self->private_impl.p_write_to[0]; + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + while (self->private_impl.f_output_wi > 0u) { + if (self->private_impl.f_output_ri > self->private_impl.f_output_wi) { + status = wuffs_base__make_status(wuffs_lzw__error__internal_error_inconsistent_i_o); + goto exit; + } + v_s = wuffs_base__make_slice_u8_ij(self->private_data.f_output, + self->private_impl.f_output_ri, + self->private_impl.f_output_wi); + v_n = wuffs_base__io_writer__copy_from_slice(&iop_a_dst, io2_a_dst,v_s); + if (v_n == ((uint64_t)(v_s.len))) { + self->private_impl.f_output_ri = 0u; + self->private_impl.f_output_wi = 0u; + status = wuffs_base__make_status(NULL); + goto ok; + } + self->private_impl.f_output_ri = (((uint32_t)(self->private_impl.f_output_ri + ((uint32_t)(v_n)))) & 8191u); + status = wuffs_base__make_status(wuffs_base__suspension__short_write); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1); + } + + ok: + self->private_impl.p_write_to[0] = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_write_to[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + + goto exit; + exit: + if (a_dst && a_dst->data.ptr) { + a_dst->meta.wi = ((size_t)(iop_a_dst - a_dst->data.ptr)); + } + + return status; +} + +// -------- func lzw.decoder.flush + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__slice_u8 +wuffs_lzw__decoder__flush( + wuffs_lzw__decoder* self) { + if (!self) { + return wuffs_base__make_slice_u8(NULL, 0); + } + if (self->private_impl.magic != WUFFS_BASE__MAGIC) { + return wuffs_base__make_slice_u8(NULL, 0); + } + + uint32_t v_ri = 0; + uint32_t v_wi = 0; + + v_ri = self->private_impl.f_output_ri; + v_wi = self->private_impl.f_output_wi; + self->private_impl.f_output_ri = 0u; + self->private_impl.f_output_wi = 0u; + if (v_ri <= v_wi) { + return wuffs_base__make_slice_u8_ij(self->private_data.f_output, v_ri, v_wi); + } + return wuffs_base__make_slice_u8(self->private_data.f_output, 0); +} + +#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__LZW) + #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__NETPBM) // ---------------- Status Codes Implementations diff --git a/std/gif/common_consts.wuffs b/std/gif/common_consts.wuffs index 3121dfa1..d78c3867 100644 --- a/std/gif/common_consts.wuffs +++ b/std/gif/common_consts.wuffs @@ -12,10 +12,6 @@ // See the License for the specific language governing permissions and // limitations under the License. -// TODO: remove this no-longer-used `use` line. That affects the topological -// sort of std/etc packages, which makes a large diff for the generated C code. -use "std/lzw" - pub status "#bad LZW code" pub status "#bad extension label" pub status "#bad frame size"