Make the status type a const char*, not a struct

This commit is contained in:
Nigel Tao committed 2018-08-12 16:05:14 +10:00
1 parent e0311e3bb2
commit b840c80040
24 files changed
+624 -815

No files matched your search

+351 -435
View File
@@ -123,19 +123,13 @@ typedef struct {
// --------
// A status code is either zero (OK), positive (a recoverable suspension or
// pause in processing) or negative (a non-recoverable error). Its bits:
// - bit 31 (the sign bit) indicates unrecoverable-ness: an error.
// - bits 30 .. 24 are a package-namespaced numeric code
// - bits 23 .. 21 are reserved.
// - bits 20 .. 0 are the packageid (a namespace) as a base38 value.
// A status is either NULL (meaning OK or no error) or string message. That
// message is human-readable, for programmers, but it is not for end users. It
// is not localized, and does not contain additional contextual information
// such as a source filename.
//
// Do not manipulate these bits directly; they are private implementation
// details. Use methods such as wuffs_base__status__is_error instead.
typedef struct {
int32_t code;
const char* msg;
} wuffs_base__status;
// Status strings are statically allocated and should never be free'd.
typedef const char* wuffs_base__status;
#define WUFFS_BASE__STATUS_OK 0 // 0x00000000
#define WUFFS_BASE__ERROR_BAD_WUFFS_VERSION -16777216 // 0xFF000000
@@ -165,29 +159,19 @@ extern const char* wuffs_base__suspension__end_of_data;
extern const char* wuffs_base__suspension__short_read;
extern const char* wuffs_base__suspension__short_write;
// TODO: turn WUFFS_BASE__MAKE_STATUS into a macro, and add a msg field.
static inline wuffs_base__status //
WUFFS_BASE__MAKE_STATUS(int32_t code) {
return ((wuffs_base__status){
.code = code,
.msg = NULL,
});
static inline bool //
wuffs_base__status__is_error(wuffs_base__status z) {
return z && (*z != '$');
}
static inline bool //
wuffs_base__status__is_error(wuffs_base__status s) {
return s.code < 0;
wuffs_base__status__is_ok(wuffs_base__status z) {
return z == NULL;
}
static inline bool //
wuffs_base__status__is_ok(wuffs_base__status s) {
return s.code == 0;
}
static inline bool //
wuffs_base__status__is_suspension(wuffs_base__status s) {
return s.code > 0;
wuffs_base__status__is_suspension(wuffs_base__status z) {
return z && (*z == '$');
}
const char* //
@@ -1935,18 +1919,17 @@ wuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b,
wuffs_base__pixel_config* pixcfg,
wuffs_base__slice_u8 pixbuf_memory) {
if (!b) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
*b = ((wuffs_base__pixel_buffer){});
if (!pixcfg) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_ARGUMENT);
return wuffs_base__error__bad_argument;
}
// TODO: don't assume 1 byte per pixel. Don't assume packed.
uint64_t wh = ((uint64_t)pixcfg->private_impl.width) *
((uint64_t)pixcfg->private_impl.height);
if (wh > pixbuf_memory.len) {
return WUFFS_BASE__MAKE_STATUS(
WUFFS_BASE__ERROR_BAD_ARGUMENT_LENGTH_TOO_SHORT);
return wuffs_base__error__bad_argument_length_too_short;
}
b->private_impl.pixcfg = *pixcfg;
wuffs_base__table_u8* tab = &b->private_impl.planes[0];
@@ -1954,7 +1937,7 @@ wuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b,
tab->width = pixcfg->private_impl.width;
tab->height = pixcfg->private_impl.height;
tab->stride = pixcfg->private_impl.width;
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
return NULL;
}
// The palette argument is ignored unless its length is exactly 1024.
@@ -3101,10 +3084,10 @@ static inline void wuffs_base__ignore_check_wuffs_version_status(
case n:;
#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \
if (status.code < 0) { \
goto exit; \
} else if (status.code == 0) { \
if (!status) { \
goto ok; \
} else if (*status != '$') { \
goto exit; \
} \
coro_susp_point = n; \
goto suspend; \
@@ -3937,21 +3920,20 @@ wuffs_adler32__hasher__check_wuffs_version(wuffs_adler32__hasher* self,
size_t sizeof_star_self,
uint64_t wuffs_version) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (sizeof(*self) != sizeof_star_self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER);
return 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);
return wuffs_base__error__bad_wuffs_version;
}
if (self->private_impl.magic != 0) {
return WUFFS_BASE__MAKE_STATUS(
WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE);
return wuffs_base__error__check_wuffs_version_called_twice;
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
return NULL;
}
// ---------------- Function Implementations
@@ -3965,10 +3947,9 @@ wuffs_adler32__hasher__update(wuffs_adler32__hasher* self,
return 0;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return 0;
}
@@ -4469,21 +4450,20 @@ wuffs_crc32__ieee_hasher__check_wuffs_version(wuffs_crc32__ieee_hasher* self,
size_t sizeof_star_self,
uint64_t wuffs_version) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (sizeof(*self) != sizeof_star_self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER);
return 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);
return wuffs_base__error__bad_wuffs_version;
}
if (self->private_impl.magic != 0) {
return WUFFS_BASE__MAKE_STATUS(
WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE);
return wuffs_base__error__check_wuffs_version_called_twice;
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
return NULL;
}
// ---------------- Function Implementations
@@ -4497,10 +4477,9 @@ wuffs_crc32__ieee_hasher__update(wuffs_crc32__ieee_hasher* self,
return 0;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return 0;
}
@@ -4882,21 +4861,20 @@ wuffs_deflate__decoder__check_wuffs_version(wuffs_deflate__decoder* self,
size_t sizeof_star_self,
uint64_t wuffs_version) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (sizeof(*self) != sizeof_star_self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER);
return 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);
return wuffs_base__error__bad_wuffs_version;
}
if (self->private_impl.magic != 0) {
return WUFFS_BASE__MAKE_STATUS(
WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE);
return wuffs_base__error__check_wuffs_version_called_twice;
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
return NULL;
}
// ---------------- Function Implementations
@@ -4908,16 +4886,15 @@ wuffs_deflate__decoder__decode(wuffs_deflate__decoder* self,
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return self->private_impl.status;
}
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
wuffs_base__status v_z;
wuffs_base__slice_u8 v_written;
@@ -4970,11 +4947,10 @@ wuffs_deflate__decoder__decode(wuffs_deflate__decoder* self,
}
if (!wuffs_base__status__is_suspension(v_z)) {
status = v_z;
if (status.code == 0) {
if (!status) {
goto ok;
} else if (status.code > 0) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_BASE__ERROR_CANNOT_RETURN_A_SUSPENSION);
} else if (wuffs_base__status__is_suspension(status)) {
status = wuffs_base__error__cannot_return_a_suspension;
}
goto exit;
}
@@ -5047,7 +5023,7 @@ static wuffs_base__status //
wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self,
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint32_t v_final;
uint32_t v_type;
@@ -5085,7 +5061,7 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
@@ -5108,14 +5084,14 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
goto label_0_continue;
} else if (v_type == 1) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_deflate__decoder__init_fixed_huffman(self);
if (status.code) {
if (status) {
goto suspend;
}
} else if (v_type == 2) {
@@ -5127,11 +5103,11 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
} else {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_BLOCK);
status = wuffs_deflate__error__bad_block;
goto exit;
}
self->private_impl.f_end_of_block = false;
@@ -5143,7 +5119,7 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
if (self->private_impl.f_end_of_block) {
@@ -5157,14 +5133,14 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
if (self->private_impl.f_end_of_block) {
goto label_0_continue;
}
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_END_OF_BLOCK);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_end_of_block;
goto exit;
}
@@ -5195,7 +5171,7 @@ static wuffs_base__status //
wuffs_deflate__decoder__decode_uncompressed(wuffs_deflate__decoder* self,
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint32_t v_length;
uint32_t v_n_copied;
@@ -5246,8 +5222,7 @@ wuffs_deflate__decoder__decode_uncompressed(wuffs_deflate__decoder* self,
if ((self->private_impl.f_n_bits >= 8) ||
((self->private_impl.f_bits >> self->private_impl.f_n_bits) != 0)) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS);
status = wuffs_deflate__error__internal_error_inconsistent_n_bits;
goto exit;
}
self->private_impl.f_n_bits = 0;
@@ -5263,7 +5238,7 @@ wuffs_deflate__decoder__decode_uncompressed(wuffs_deflate__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch =
@@ -5284,8 +5259,7 @@ wuffs_deflate__decoder__decode_uncompressed(wuffs_deflate__decoder* self,
}
if ((((v_length) & ((1 << (16)) - 1)) + ((v_length) >> (32 - (16)))) !=
65535) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INCONSISTENT_STORED_BLOCK_LENGTH);
status = wuffs_deflate__error__inconsistent_stored_block_length;
goto exit;
}
v_length = ((v_length) & ((1 << (16)) - 1));
@@ -5293,15 +5267,15 @@ wuffs_deflate__decoder__decode_uncompressed(wuffs_deflate__decoder* self,
v_n_copied = wuffs_base__io_writer__copy_n_from_reader(
&iop_a_dst, io1_a_dst, v_length, &iop_a_src, io1_a_src);
if (v_length <= v_n_copied) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
status = NULL;
goto ok;
}
v_length -= v_n_copied;
if (((uint64_t)(io1_a_dst - iop_a_dst)) == 0) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE);
status = wuffs_base__suspension__short_write;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3);
} else {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(4);
}
}
@@ -5334,7 +5308,7 @@ exit:
static wuffs_base__status //
wuffs_deflate__decoder__init_fixed_huffman(wuffs_deflate__decoder* self) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint32_t v_i;
@@ -5370,12 +5344,12 @@ wuffs_deflate__decoder__init_fixed_huffman(wuffs_deflate__decoder* self) {
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_deflate__decoder__init_huff(self, 0, 0, 288, 257);
if (status.code) {
if (status) {
goto suspend;
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
status = wuffs_deflate__decoder__init_huff(self, 1, 288, 320, 0);
if (status.code) {
if (status) {
goto suspend;
}
@@ -5400,7 +5374,7 @@ exit:
static wuffs_base__status //
wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint32_t v_bits;
uint32_t v_n_bits;
@@ -5459,7 +5433,7 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
@@ -5469,15 +5443,13 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
}
v_n_lit = (((v_bits) & ((1 << (5)) - 1)) + 257);
if (v_n_lit > 286) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_BAD_LITERAL_LENGTH_CODE_COUNT);
status = wuffs_deflate__error__bad_literal_length_code_count;
goto exit;
}
v_bits >>= 5;
v_n_dist = (((v_bits) & ((1 << (5)) - 1)) + 1);
if (v_n_dist > 30) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_DISTANCE_CODE_COUNT);
status = wuffs_deflate__error__bad_distance_code_count;
goto exit;
}
v_bits >>= 5;
@@ -5490,7 +5462,7 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_1 = *iop_a_src++;
@@ -5510,7 +5482,7 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_deflate__decoder__init_huff(self, 0, 0, 19, 4095);
if (status.code) {
if (status) {
goto suspend;
}
v_mask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
@@ -5529,7 +5501,7 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_2 = *iop_a_src++;
@@ -5539,8 +5511,8 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
}
label_1_break:;
if ((v_table_entry >> 24) != 128) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_table_entry = ((v_table_entry >> 8) & 255);
@@ -5555,8 +5527,7 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
if (v_table_entry == 16) {
v_n_extra_bits = 2;
if (v_i <= 0) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_REPETITION);
status = wuffs_deflate__error__bad_huffman_code_length_repetition;
goto exit;
}
v_rep_symbol = self->private_impl.f_code_lengths[(v_i - 1)];
@@ -5570,15 +5541,15 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
v_rep_symbol = 0;
v_rep_count = 11;
} else {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
while (v_n_bits < v_n_extra_bits) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_3 = *iop_a_src++;
@@ -5591,8 +5562,7 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
v_n_bits -= v_n_extra_bits;
while (v_rep_count > 0) {
if (v_i >= (v_n_lit + v_n_dist)) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_COUNT);
status = wuffs_deflate__error__bad_huffman_code_length_count;
goto exit;
}
self->private_impl.f_code_lengths[v_i] = v_rep_symbol;
@@ -5601,24 +5571,22 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
}
}
if (v_i != (v_n_lit + v_n_dist)) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_COUNT);
status = wuffs_deflate__error__bad_huffman_code_length_count;
goto exit;
}
if (self->private_impl.f_code_lengths[256] == 0) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_MISSING_END_OF_BLOCK_CODE);
status = wuffs_deflate__error__missing_end_of_block_code;
goto exit;
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
status = wuffs_deflate__decoder__init_huff(self, 0, 0, v_n_lit, 257);
if (status.code) {
if (status) {
goto suspend;
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
status = wuffs_deflate__decoder__init_huff(self, 1, v_n_lit,
(v_n_lit + v_n_dist), 0);
if (status.code) {
if (status) {
goto suspend;
}
self->private_impl.f_bits = v_bits;
@@ -5665,7 +5633,7 @@ wuffs_deflate__decoder__init_huff(wuffs_deflate__decoder* self,
uint32_t a_n_codes0,
uint32_t a_n_codes1,
uint32_t a_base_symbol) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint16_t v_counts[16];
uint32_t v_i;
@@ -5697,37 +5665,35 @@ wuffs_deflate__decoder__init_huff(wuffs_deflate__decoder* self,
v_i = a_n_codes0;
while (v_i < a_n_codes1) {
if (v_counts[self->private_impl.f_code_lengths[v_i]] >= 320) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_counts[self->private_impl.f_code_lengths[v_i]] += 1;
v_i += 1;
}
if ((((uint32_t)(v_counts[0])) + a_n_codes0) == a_n_codes1) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_NO_HUFFMAN_CODES);
status = wuffs_deflate__error__no_huffman_codes;
goto exit;
}
v_remaining = 1;
v_i = 1;
while (v_i <= 15) {
if (v_remaining > 1073741824) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_remaining <<= 1;
if (v_remaining < ((uint32_t)(v_counts[v_i]))) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_OVER_SUBSCRIBED);
status = wuffs_deflate__error__bad_huffman_code_over_subscribed;
goto exit;
}
v_remaining -= ((uint32_t)(v_counts[v_i]));
v_i += 1;
}
if (v_remaining != 0) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_UNDER_SUBSCRIBED);
status = wuffs_deflate__error__bad_huffman_code_under_subscribed;
goto exit;
}
memset(v_offsets, 0, sizeof(v_offsets));
@@ -5737,30 +5703,30 @@ wuffs_deflate__decoder__init_huff(wuffs_deflate__decoder* self,
v_offsets[v_i] = ((uint16_t)(v_n_symbols));
v_count = ((uint32_t)(v_counts[v_i]));
if (v_n_symbols > (320 - v_count)) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_n_symbols = (v_n_symbols + v_count);
v_i += 1;
}
if (v_n_symbols > 288) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
memset(v_symbols, 0, sizeof(v_symbols));
v_i = a_n_codes0;
while (v_i < a_n_codes1) {
if (v_i < a_n_codes0) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
if (self->private_impl.f_code_lengths[v_i] != 0) {
if (v_offsets[self->private_impl.f_code_lengths[v_i]] >= 320) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_symbols[v_offsets[self->private_impl.f_code_lengths[v_i]]] =
@@ -5775,8 +5741,7 @@ wuffs_deflate__decoder__init_huff(wuffs_deflate__decoder* self,
goto label_0_break;
}
if (v_min_cl >= 9) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_MINIMUM_CODE_LENGTH);
status = wuffs_deflate__error__bad_huffman_minimum_code_length;
goto exit;
}
v_min_cl += 1;
@@ -5788,7 +5753,7 @@ label_0_break:;
goto label_1_break;
}
if (v_max_cl <= 1) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_NO_HUFFMAN_CODES);
status = wuffs_deflate__error__no_huffman_codes;
goto exit;
}
v_max_cl -= 1;
@@ -5802,13 +5767,13 @@ label_1_break:;
v_i = 0;
if ((v_n_symbols != ((uint32_t)(v_offsets[v_max_cl]))) ||
(v_n_symbols != ((uint32_t)(v_offsets[15])))) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
if ((a_n_codes0 + ((uint32_t)(v_symbols[0]))) >= 320) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_initial_high_bits = 512;
@@ -5825,8 +5790,8 @@ label_1_break:;
v_value = 0;
while (true) {
if ((a_n_codes0 + ((uint32_t)(v_symbols[v_i]))) >= 320) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_cl = ((uint32_t)(self->private_impl.f_code_lengths[(
@@ -5834,8 +5799,8 @@ label_1_break:;
if (v_cl > v_prev_cl) {
v_code <<= (v_cl - v_prev_cl);
if (v_code >= 32768) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
}
@@ -5856,8 +5821,8 @@ label_1_break:;
}
v_remaining -= ((uint32_t)(v_counts[v_j]));
if (v_remaining > 1073741824) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_remaining <<= 1;
@@ -5865,16 +5830,16 @@ label_1_break:;
}
label_2_break:;
if ((v_j <= 9) || (15 < v_j)) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_tmp = (v_j - 9);
v_initial_high_bits = (((uint32_t)(1)) << v_tmp);
v_top = v_next_top;
if ((v_top + (((uint32_t)(1)) << v_tmp)) > 1234) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_next_top = (v_top + (((uint32_t)(1)) << v_tmp));
@@ -5886,8 +5851,8 @@ label_1_break:;
}
}
if ((v_key >= 512) || (v_counts[v_prev_cl] <= 0)) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_counts[v_prev_cl] -= 1;
@@ -5907,8 +5872,8 @@ label_1_break:;
v_value = (wuffs_deflate__dcode_magic_numbers[(v_symbol & 31)] | v_cl);
}
} else {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_high_bits = v_initial_high_bits;
@@ -5916,8 +5881,8 @@ label_1_break:;
while (v_high_bits >= v_delta) {
v_high_bits -= v_delta;
if ((v_top + ((v_high_bits | v_reversed_key) & 511)) >= 1234) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
self->private_impl
@@ -5930,8 +5895,8 @@ label_1_break:;
}
v_code += 1;
if (v_code >= 32768) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
}
@@ -5947,7 +5912,7 @@ static wuffs_base__status //
wuffs_deflate__decoder__decode_huffman_fast(wuffs_deflate__decoder* self,
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint32_t v_bits;
uint32_t v_n_bits;
@@ -5999,8 +5964,7 @@ wuffs_deflate__decoder__decode_huffman_fast(wuffs_deflate__decoder* self,
if ((self->private_impl.f_n_bits >= 8) ||
((self->private_impl.f_bits >> self->private_impl.f_n_bits) != 0)) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS);
status = wuffs_deflate__error__internal_error_inconsistent_n_bits;
goto exit;
}
v_bits = self->private_impl.f_bits;
@@ -6047,8 +6011,8 @@ label_0_continue:;
v_redir_top = ((v_table_entry >> 8) & 65535);
v_redir_mask = ((((uint32_t)(1)) << ((v_table_entry >> 4) & 15)) - 1);
if ((v_redir_top + (v_bits & v_redir_mask)) >= 1234) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_table_entry = self->private_impl
@@ -6066,23 +6030,23 @@ label_0_continue:;
self->private_impl.f_end_of_block = true;
goto label_0_break;
} else if ((v_table_entry >> 28) != 0) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
} else if ((v_table_entry >> 27) != 0) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE);
status = wuffs_deflate__error__bad_huffman_code;
goto exit;
} else {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
} else if ((v_table_entry >> 27) != 0) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE);
status = wuffs_deflate__error__bad_huffman_code;
goto exit;
} else {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_length = ((v_table_entry >> 8) & 32767);
@@ -6105,8 +6069,8 @@ label_0_continue:;
} else {
}
if (v_length > 258) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
if (v_n_bits < 15) {
@@ -6135,8 +6099,8 @@ label_0_continue:;
v_redir_top = ((v_table_entry >> 8) & 65535);
v_redir_mask = ((((uint32_t)(1)) << ((v_table_entry >> 4) & 15)) - 1);
if ((v_redir_top + (v_bits & v_redir_mask)) >= 1234) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_table_entry = self->private_impl
@@ -6148,11 +6112,11 @@ label_0_continue:;
}
if ((v_table_entry >> 24) != 64) {
if ((v_table_entry >> 24) == 8) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE);
status = wuffs_deflate__error__bad_huffman_code;
goto exit;
}
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_dist_minus_1 = ((v_table_entry >> 8) & 32767);
@@ -6194,8 +6158,8 @@ label_0_continue:;
v_length -= v_hdist;
v_hlen = v_hdist;
if (v_length > 258) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
} else {
@@ -6203,7 +6167,7 @@ label_0_continue:;
v_length = 0;
}
if (self->private_impl.f_history_index < v_hdist) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_DISTANCE);
status = wuffs_deflate__error__bad_distance;
goto exit;
}
v_hdist = (self->private_impl.f_history_index - v_hdist);
@@ -6235,8 +6199,7 @@ label_0_continue:;
.len = (size_t)(iop_a_dst - a_dst.private_impl.bounds[0]),
})
.len))) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_DISTANCE);
status = wuffs_deflate__error__internal_error_inconsistent_distance;
goto exit;
}
}
@@ -6253,8 +6216,7 @@ label_0_break:;
if (iop_a_src > io0_a_src) {
(iop_a_src--, wuffs_base__return_empty_struct());
} else {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_I_O);
status = wuffs_deflate__error__internal_error_inconsistent_i_o;
goto exit;
}
}
@@ -6262,8 +6224,7 @@ label_0_break:;
self->private_impl.f_n_bits = v_n_bits;
if ((self->private_impl.f_n_bits >= 8) ||
((self->private_impl.f_bits >> self->private_impl.f_n_bits) != 0)) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS);
status = wuffs_deflate__error__internal_error_inconsistent_n_bits;
goto exit;
}
goto exit;
@@ -6284,7 +6245,7 @@ static wuffs_base__status //
wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint32_t v_bits;
uint32_t v_n_bits;
@@ -6358,8 +6319,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
if ((self->private_impl.f_n_bits >= 8) ||
((self->private_impl.f_bits >> self->private_impl.f_n_bits) != 0)) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS);
status = wuffs_deflate__error__internal_error_inconsistent_n_bits;
goto exit;
}
v_bits = self->private_impl.f_bits;
@@ -6381,7 +6341,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
@@ -6393,7 +6353,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
if ((v_table_entry >> 31) != 0) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
if (iop_a_dst == io1_a_dst) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE);
status = wuffs_base__suspension__short_write;
goto suspend;
}
*iop_a_dst++ = ((uint8_t)(((v_table_entry >> 8) & 255)));
@@ -6407,8 +6367,8 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
v_redir_mask = ((((uint32_t)(1)) << ((v_table_entry >> 4) & 15)) - 1);
while (true) {
if ((v_redir_top + (v_bits & v_redir_mask)) >= 1234) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_table_entry =
@@ -6423,8 +6383,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_1 = *iop_a_src++;
@@ -6436,8 +6395,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
if ((v_table_entry >> 31) != 0) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
if (iop_a_dst == io1_a_dst) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE);
status = wuffs_base__suspension__short_write;
goto suspend;
}
*iop_a_dst++ = ((uint8_t)(((v_table_entry >> 8) & 255)));
@@ -6447,24 +6405,23 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
self->private_impl.f_end_of_block = true;
goto label_0_break;
} else if ((v_table_entry >> 28) != 0) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
} else if ((v_table_entry >> 27) != 0) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE);
status = wuffs_deflate__error__bad_huffman_code;
goto exit;
} else {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
} else if ((v_table_entry >> 27) != 0) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE);
status = wuffs_deflate__error__bad_huffman_code;
goto exit;
} else {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_length = ((v_table_entry >> 8) & 32767);
@@ -6474,8 +6431,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_2 = *iop_a_src++;
@@ -6500,7 +6456,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_3 = *iop_a_src++;
@@ -6514,8 +6470,8 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
v_redir_mask = ((((uint32_t)(1)) << ((v_table_entry >> 4) & 15)) - 1);
while (true) {
if ((v_redir_top + (v_bits & v_redir_mask)) >= 1234) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_table_entry =
@@ -6530,8 +6486,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_4 = *iop_a_src++;
@@ -6543,12 +6498,11 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
}
if ((v_table_entry >> 24) != 64) {
if ((v_table_entry >> 24) == 8) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE);
status = wuffs_deflate__error__bad_huffman_code;
goto exit;
}
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_dist_minus_1 = ((v_table_entry >> 8) & 32767);
@@ -6558,8 +6512,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_5 = *iop_a_src++;
@@ -6599,7 +6552,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
v_length = 0;
}
if (self->private_impl.f_history_index < v_hdist) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_DISTANCE);
status = wuffs_deflate__error__bad_distance;
goto exit;
}
v_hdist = (self->private_impl.f_history_index - v_hdist);
@@ -6621,8 +6574,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
goto label_5_break;
}
}
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE);
status = wuffs_base__suspension__short_write;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9);
}
label_5_break:;
@@ -6640,8 +6592,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
}
v_hlen -= v_n_copied;
v_hdist += v_n_copied;
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE);
status = wuffs_base__suspension__short_write;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(10);
}
label_6_break:;
@@ -6658,7 +6609,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
goto label_7_break;
}
v_length -= v_n_copied;
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE);
status = wuffs_base__suspension__short_write;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(11);
}
label_7_break:;
@@ -6668,8 +6619,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
self->private_impl.f_n_bits = v_n_bits;
if ((self->private_impl.f_n_bits >= 8) ||
((self->private_impl.f_bits >> self->private_impl.f_n_bits) != 0)) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS);
status = wuffs_deflate__error__internal_error_inconsistent_n_bits;
goto exit;
}
@@ -6871,29 +6821,28 @@ wuffs_gif__decoder__check_wuffs_version(wuffs_gif__decoder* self,
size_t sizeof_star_self,
uint64_t wuffs_version) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (sizeof(*self) != sizeof_star_self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER);
return 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);
return wuffs_base__error__bad_wuffs_version;
}
if (self->private_impl.magic != 0) {
return WUFFS_BASE__MAKE_STATUS(
WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE);
return wuffs_base__error__check_wuffs_version_called_twice;
}
{
wuffs_base__status z = wuffs_lzw__decoder__check_wuffs_version(
&self->private_impl.f_lzw, sizeof(self->private_impl.f_lzw),
WUFFS_VERSION);
if (z.code) {
if (z) {
return z;
}
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
return NULL;
}
// ---------------- Function Implementations
@@ -6905,16 +6854,15 @@ wuffs_gif__decoder__decode_image_config(wuffs_gif__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__io_reader a_src) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return self->private_impl.status;
}
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint32_t v_num_loops;
bool v_ffio;
@@ -6931,22 +6879,22 @@ wuffs_gif__decoder__decode_image_config(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence >= 1) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_INVALID_CALL_SEQUENCE);
status = wuffs_base__error__invalid_call_sequence;
goto exit;
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_gif__decoder__decode_header(self, a_src);
if (status.code) {
if (status) {
goto suspend;
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
status = wuffs_gif__decoder__decode_lsd(self, a_src);
if (status.code) {
if (status) {
goto suspend;
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_gif__decoder__decode_up_to_id_part1(self, a_src);
if (status.code) {
if (status) {
goto suspend;
}
v_num_loops = 1;
@@ -6993,10 +6941,9 @@ wuffs_gif__decoder__num_decoded_frame_configs(wuffs_gif__decoder* self) {
return 0;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return 0;
}
@@ -7011,10 +6958,9 @@ wuffs_gif__decoder__num_decoded_frames(wuffs_gif__decoder* self) {
return 0;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return 0;
}
@@ -7029,10 +6975,9 @@ wuffs_gif__decoder__work_buffer_size(wuffs_gif__decoder* self) {
return ((wuffs_base__range_ii_u64){});
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return ((wuffs_base__range_ii_u64){});
}
@@ -7047,16 +6992,15 @@ wuffs_gif__decoder__decode_frame_config(wuffs_gif__decoder* self,
wuffs_base__frame_config* a_dst,
wuffs_base__io_reader a_src) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return self->private_impl.status;
}
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint32_t coro_susp_point =
self->private_impl.c_decode_frame_config[0].coro_susp_point;
@@ -7070,27 +7014,27 @@ wuffs_gif__decoder__decode_frame_config(wuffs_gif__decoder* self,
if (self->private_impl.f_call_sequence == 0) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_gif__decoder__decode_image_config(self, NULL, a_src);
if (status.code) {
if (status) {
goto suspend;
}
} else if (self->private_impl.f_call_sequence != 1) {
if (self->private_impl.f_call_sequence == 2) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
status = wuffs_gif__decoder__skip_frame(self, a_src);
if (status.code) {
if (status) {
goto suspend;
}
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_gif__decoder__decode_up_to_id_part1(self, a_src);
if (status.code) {
if (status) {
goto suspend;
}
}
}
if (self->private_impl.f_end_of_data) {
while (true) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_END_OF_DATA);
status = wuffs_base__suspension__end_of_data;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(4);
}
}
@@ -7142,7 +7086,7 @@ exit:
static wuffs_base__status //
wuffs_gif__decoder__skip_frame(wuffs_gif__decoder* self,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_lw;
@@ -7173,7 +7117,7 @@ wuffs_gif__decoder__skip_frame(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
@@ -7187,7 +7131,7 @@ wuffs_gif__decoder__skip_frame(wuffs_gif__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
self->private_impl.f_seen_graphic_control = false;
@@ -7229,21 +7173,19 @@ wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self,
wuffs_base__io_reader a_src,
wuffs_base__slice_u8 a_work_buffer) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return self->private_impl.status;
}
if (!a_dst) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_ARGUMENT);
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_ARGUMENT);
self->private_impl.status = wuffs_base__error__bad_argument;
return wuffs_base__error__bad_argument;
}
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint32_t coro_susp_point =
self->private_impl.c_decode_frame[0].coro_susp_point;
@@ -7256,13 +7198,13 @@ wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self,
if (self->private_impl.f_call_sequence != 2) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_gif__decoder__decode_frame_config(self, NULL, a_src);
if (status.code) {
if (status) {
goto suspend;
}
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
status = wuffs_gif__decoder__decode_id_part1(self, a_dst, a_src);
if (status.code) {
if (status) {
goto suspend;
}
self->private_impl.f_seen_graphic_control = false;
@@ -7295,7 +7237,7 @@ exit:
static wuffs_base__status //
wuffs_gif__decoder__decode_up_to_id_part1(wuffs_gif__decoder* self,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_block_type;
@@ -7328,7 +7270,7 @@ wuffs_gif__decoder__decode_up_to_id_part1(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
@@ -7343,7 +7285,7 @@ wuffs_gif__decoder__decode_up_to_id_part1(wuffs_gif__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
} else if (v_block_type == 44) {
@@ -7355,7 +7297,7 @@ wuffs_gif__decoder__decode_up_to_id_part1(wuffs_gif__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
goto label_0_break;
@@ -7363,7 +7305,7 @@ wuffs_gif__decoder__decode_up_to_id_part1(wuffs_gif__decoder* self,
self->private_impl.f_end_of_data = true;
goto label_0_break;
} else {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GIF__ERROR_BAD_BLOCK);
status = wuffs_gif__error__bad_block;
goto exit;
}
}
@@ -7395,7 +7337,7 @@ exit:
static wuffs_base__status //
wuffs_gif__decoder__decode_header(wuffs_gif__decoder* self,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_c[6];
uint32_t v_i;
@@ -7432,7 +7374,7 @@ wuffs_gif__decoder__decode_header(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
@@ -7442,7 +7384,7 @@ wuffs_gif__decoder__decode_header(wuffs_gif__decoder* self,
}
if ((v_c[0] != 71) || (v_c[1] != 73) || (v_c[2] != 70) || (v_c[3] != 56) ||
((v_c[4] != 55) && (v_c[4] != 57)) || (v_c[5] != 97)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GIF__ERROR_BAD_HEADER);
status = wuffs_gif__error__bad_header;
goto exit;
}
@@ -7472,7 +7414,7 @@ exit:
static wuffs_base__status //
wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_flags;
uint32_t v_num_palette_entries;
@@ -7518,7 +7460,7 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode_lsd[0].scratch;
@@ -7547,7 +7489,7 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode_lsd[0].scratch;
@@ -7568,7 +7510,7 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_4 = *iop_a_src++;
@@ -7581,7 +7523,7 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self,
((uint64_t)(io1_a_src - iop_a_src))) {
self->private_impl.c_decode_lsd[0].scratch -= io1_a_src - iop_a_src;
iop_a_src = io1_a_src;
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
iop_a_src += self->private_impl.c_decode_lsd[0].scratch;
@@ -7600,8 +7542,7 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode_lsd[0].scratch;
@@ -7668,7 +7609,7 @@ exit:
static wuffs_base__status //
wuffs_gif__decoder__decode_extension(wuffs_gif__decoder* self,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_label;
@@ -7700,7 +7641,7 @@ wuffs_gif__decoder__decode_extension(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
@@ -7715,10 +7656,10 @@ wuffs_gif__decoder__decode_extension(wuffs_gif__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
status = NULL;
goto ok;
} else if (v_label == 255) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
@@ -7729,10 +7670,10 @@ wuffs_gif__decoder__decode_extension(wuffs_gif__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
status = NULL;
goto ok;
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
@@ -7743,7 +7684,7 @@ wuffs_gif__decoder__decode_extension(wuffs_gif__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
@@ -7772,7 +7713,7 @@ exit:
static wuffs_base__status //
wuffs_gif__decoder__skip_blocks(wuffs_gif__decoder* self,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_block_size;
@@ -7805,14 +7746,14 @@ wuffs_gif__decoder__skip_blocks(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
v_block_size = t_0;
}
if (v_block_size == 0) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
status = NULL;
goto ok;
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
@@ -7822,7 +7763,7 @@ wuffs_gif__decoder__skip_blocks(wuffs_gif__decoder* self,
((uint64_t)(io1_a_src - iop_a_src))) {
self->private_impl.c_skip_blocks[0].scratch -= io1_a_src - iop_a_src;
iop_a_src = io1_a_src;
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
iop_a_src += self->private_impl.c_skip_blocks[0].scratch;
@@ -7853,7 +7794,7 @@ exit:
static wuffs_base__status //
wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_c;
uint8_t v_block_size;
@@ -7894,14 +7835,14 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
v_block_size = t_0;
}
if (v_block_size == 0) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
status = NULL;
goto ok;
}
if (v_block_size != 11) {
@@ -7912,7 +7853,7 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self,
((uint64_t)(io1_a_src - iop_a_src))) {
self->private_impl.c_decode_ae[0].scratch -= io1_a_src - iop_a_src;
iop_a_src = io1_a_src;
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
iop_a_src += self->private_impl.c_decode_ae[0].scratch;
@@ -7925,7 +7866,7 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_1 = *iop_a_src++;
@@ -7943,7 +7884,7 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_2 = *iop_a_src++;
@@ -7957,7 +7898,7 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self,
((uint64_t)(io1_a_src - iop_a_src))) {
self->private_impl.c_decode_ae[0].scratch -= io1_a_src - iop_a_src;
iop_a_src = io1_a_src;
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
iop_a_src += self->private_impl.c_decode_ae[0].scratch;
@@ -7966,7 +7907,7 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_3 = *iop_a_src++;
@@ -7980,7 +7921,7 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self,
((uint64_t)(io1_a_src - iop_a_src))) {
self->private_impl.c_decode_ae[0].scratch -= io1_a_src - iop_a_src;
iop_a_src = io1_a_src;
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
iop_a_src += self->private_impl.c_decode_ae[0].scratch;
@@ -7997,8 +7938,7 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode_ae[0].scratch;
@@ -8032,7 +7972,7 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
@@ -8064,7 +8004,7 @@ exit:
static wuffs_base__status //
wuffs_gif__decoder__decode_gc(wuffs_gif__decoder* self,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_c;
uint8_t v_flags;
@@ -8095,26 +8035,26 @@ wuffs_gif__decoder__decode_gc(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_seen_graphic_control) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GIF__ERROR_BAD_GRAPHIC_CONTROL);
status = wuffs_gif__error__bad_graphic_control;
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
v_c = t_0;
}
if (v_c != 4) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GIF__ERROR_BAD_GRAPHIC_CONTROL);
status = wuffs_gif__error__bad_graphic_control;
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_1 = *iop_a_src++;
@@ -8140,7 +8080,7 @@ wuffs_gif__decoder__decode_gc(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode_gc[0].scratch;
@@ -8161,7 +8101,7 @@ wuffs_gif__decoder__decode_gc(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_4 = *iop_a_src++;
@@ -8170,14 +8110,14 @@ wuffs_gif__decoder__decode_gc(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_5 = *iop_a_src++;
v_c = t_5;
}
if (v_c != 0) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GIF__ERROR_BAD_GRAPHIC_CONTROL);
status = wuffs_gif__error__bad_graphic_control;
goto exit;
}
self->private_impl.f_seen_graphic_control = true;
@@ -8208,7 +8148,7 @@ exit:
static wuffs_base__status //
wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_flags;
uint32_t v_num_palette_entries;
@@ -8255,7 +8195,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode_id_part0[0].scratch;
@@ -8284,7 +8224,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode_id_part0[0].scratch;
@@ -8313,7 +8253,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode_id_part0[0].scratch;
@@ -8343,7 +8283,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode_id_part0[0].scratch;
@@ -8373,7 +8313,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_8 = *iop_a_src++;
@@ -8402,8 +8342,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch =
@@ -8472,7 +8411,7 @@ static wuffs_base__status //
wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_lw;
uint64_t v_block_size;
@@ -8551,14 +8490,14 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
v_lw = t_0;
}
if ((v_lw < 2) || (8 < v_lw)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GIF__ERROR_BAD_LITERAL_WIDTH);
status = wuffs_gif__error__bad_literal_width;
goto exit;
}
wuffs_lzw__decoder__set_literal_width(&self->private_impl.f_lzw,
@@ -8568,7 +8507,7 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_1 = *iop_a_src++;
@@ -8626,25 +8565,20 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
a_src = o_0_a_src;
}
if (wuffs_base__status__is_ok(v_z) ||
(v_z.code ==
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE)
.code)) {
(v_z == wuffs_base__suspension__short_write)) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_gif__decoder__copy_to_image_buffer(self, a_dst);
if (status.code) {
if (status) {
goto suspend;
}
if (v_z.code ==
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE)
.code) {
if (v_z == wuffs_base__suspension__short_write) {
goto label_1_continue;
}
self->private_impl.f_previous_lzw_decode_ended_abruptly = false;
goto label_1_break;
}
if ((v_block_size == 0) &&
(v_z.code ==
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ).code)) {
(v_z == wuffs_base__suspension__short_read)) {
goto label_1_break;
}
status = v_z;
@@ -8657,7 +8591,7 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
self->private_impl.f_uncompressed_wi) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
status = wuffs_gif__decoder__copy_to_image_buffer(self, a_dst);
if (status.code) {
if (status) {
goto suspend;
}
}
@@ -8689,7 +8623,7 @@ exit:
static wuffs_base__status //
wuffs_gif__decoder__copy_to_image_buffer(wuffs_gif__decoder* self,
wuffs_base__pixel_buffer* a_pb) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
wuffs_base__slice_u8 v_dst;
wuffs_base__slice_u8 v_src;
@@ -8711,7 +8645,7 @@ label_0_continue:;
self->private_impl.f_uncompressed_ri,
self->private_impl.f_uncompressed_wi);
if (self->private_impl.f_dst_y >= self->private_impl.f_frame_rect_y1) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GIF__ERROR_TOO_MUCH_PIXEL_DATA);
status = wuffs_gif__error__too_much_pixel_data;
goto exit;
}
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
@@ -8756,8 +8690,7 @@ label_0_continue:;
goto label_0_break;
} else if (self->private_impl.f_uncompressed_wi <
self->private_impl.f_uncompressed_ri) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_GIF__ERROR_INTERNAL_ERROR_INCONSISTENT_RI_WI);
status = wuffs_gif__error__internal_error_inconsistent_ri_wi;
goto exit;
}
v_n = (self->private_impl.f_frame_rect_x1 - self->private_impl.f_dst_x);
@@ -8785,8 +8718,7 @@ label_0_continue:;
}
if (self->private_impl.f_uncompressed_ri !=
self->private_impl.f_uncompressed_wi) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_GIF__ERROR_INTERNAL_ERROR_INCONSISTENT_RI_WI);
status = wuffs_gif__error__internal_error_inconsistent_ri_wi;
goto exit;
}
goto label_0_break;
@@ -8886,24 +8818,23 @@ wuffs_gzip__decoder__check_wuffs_version(wuffs_gzip__decoder* self,
size_t sizeof_star_self,
uint64_t wuffs_version) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (sizeof(*self) != sizeof_star_self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER);
return 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);
return wuffs_base__error__bad_wuffs_version;
}
if (self->private_impl.magic != 0) {
return WUFFS_BASE__MAKE_STATUS(
WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE);
return wuffs_base__error__check_wuffs_version_called_twice;
}
{
wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version(
&self->private_impl.f_flate, sizeof(self->private_impl.f_flate),
WUFFS_VERSION);
if (z.code) {
if (z) {
return z;
}
}
@@ -8911,12 +8842,12 @@ wuffs_gzip__decoder__check_wuffs_version(wuffs_gzip__decoder* self,
wuffs_base__status z = wuffs_crc32__ieee_hasher__check_wuffs_version(
&self->private_impl.f_checksum, sizeof(self->private_impl.f_checksum),
WUFFS_VERSION);
if (z.code) {
if (z) {
return z;
}
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
return NULL;
}
// ---------------- Function Implementations
@@ -8929,10 +8860,9 @@ wuffs_gzip__decoder__set_ignore_checksum(wuffs_gzip__decoder* self, bool a_ic) {
return;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return;
}
@@ -8946,16 +8876,15 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return self->private_impl.status;
}
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_c;
uint8_t v_flags;
@@ -9019,47 +8948,46 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
v_c = t_0;
}
if (v_c != 31) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GZIP__ERROR_BAD_HEADER);
status = wuffs_gzip__error__bad_header;
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_1 = *iop_a_src++;
v_c = t_1;
}
if (v_c != 139) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GZIP__ERROR_BAD_HEADER);
status = wuffs_gzip__error__bad_header;
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_2 = *iop_a_src++;
v_c = t_2;
}
if (v_c != 8) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_GZIP__ERROR_BAD_COMPRESSION_METHOD);
status = wuffs_gzip__error__bad_compression_method;
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_3 = *iop_a_src++;
@@ -9072,7 +9000,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
((uint64_t)(io1_a_src - iop_a_src))) {
self->private_impl.c_decode[0].scratch -= io1_a_src - iop_a_src;
iop_a_src = io1_a_src;
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
iop_a_src += self->private_impl.c_decode[0].scratch;
@@ -9088,8 +9016,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode[0].scratch;
@@ -9114,7 +9041,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
((uint64_t)(io1_a_src - iop_a_src))) {
self->private_impl.c_decode[0].scratch -= io1_a_src - iop_a_src;
iop_a_src = io1_a_src;
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
iop_a_src += self->private_impl.c_decode[0].scratch;
@@ -9124,7 +9051,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_6 = *iop_a_src++;
@@ -9141,7 +9068,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_7 = *iop_a_src++;
@@ -9161,13 +9088,13 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
((uint64_t)(io1_a_src - iop_a_src))) {
self->private_impl.c_decode[0].scratch -= io1_a_src - iop_a_src;
iop_a_src = io1_a_src;
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
iop_a_src += self->private_impl.c_decode[0].scratch;
}
if ((v_flags & 224) != 0) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GZIP__ERROR_BAD_ENCODING_FLAGS);
status = wuffs_gzip__error__bad_encoding_flags;
goto exit;
}
v_checksum_got = 0;
@@ -9225,7 +9152,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(17);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode[0].scratch;
@@ -9254,7 +9181,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(19);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode[0].scratch;
@@ -9275,7 +9202,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
if (!self->private_impl.f_ignore_checksum &&
((v_checksum_got != v_checksum_want) ||
(v_decoded_length_got != v_decoded_length_want))) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GZIP__ERROR_BAD_CHECKSUM);
status = wuffs_gzip__error__bad_checksum;
goto exit;
}
@@ -9388,21 +9315,20 @@ wuffs_lzw__decoder__check_wuffs_version(wuffs_lzw__decoder* self,
size_t sizeof_star_self,
uint64_t wuffs_version) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (sizeof(*self) != sizeof_star_self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER);
return 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);
return wuffs_base__error__bad_wuffs_version;
}
if (self->private_impl.magic != 0) {
return WUFFS_BASE__MAKE_STATUS(
WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE);
return wuffs_base__error__check_wuffs_version_called_twice;
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
return NULL;
}
// ---------------- Function Implementations
@@ -9415,15 +9341,13 @@ wuffs_lzw__decoder__set_literal_width(wuffs_lzw__decoder* self, uint32_t a_lw) {
return;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return;
}
if (a_lw < 2 || a_lw > 8) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_ARGUMENT);
self->private_impl.status = wuffs_base__error__bad_argument;
return;
}
@@ -9437,16 +9361,15 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self,
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return self->private_impl.status;
}
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint32_t v_literal_width;
uint32_t v_clear_code;
@@ -9533,7 +9456,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
@@ -9547,7 +9470,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self,
if (v_code < v_clear_code) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
if (iop_a_dst == io1_a_dst) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE);
status = wuffs_base__suspension__short_write;
goto suspend;
}
*iop_a_dst++ = ((uint8_t)(v_code));
@@ -9563,7 +9486,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self,
}
} else if (v_code <= v_end_code) {
if (v_code == v_end_code) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
status = NULL;
goto ok;
}
v_save_code = v_end_code;
@@ -9579,8 +9502,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self,
while (v_c >= v_clear_code) {
self->private_impl.f_stack[v_s] = self->private_impl.f_suffixes[v_c];
if (v_s == 0) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_LZW__ERROR_CYCLICAL_PREFIX_CHAIN);
status = wuffs_lzw__error__cyclical_prefix_chain;
goto exit;
}
v_s -= 1;
@@ -9601,7 +9523,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self,
goto label_0_break;
}
v_s = ((v_s + ((uint32_t)((v_n_copied & 4095)))) & 4095);
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE);
status = wuffs_base__suspension__short_write;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3);
}
label_0_break:;
@@ -9616,7 +9538,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self,
v_prev_code = v_code;
}
} else {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_LZW__ERROR_BAD_CODE);
status = wuffs_lzw__error__bad_code;
goto exit;
}
}
@@ -9751,24 +9673,23 @@ wuffs_zlib__decoder__check_wuffs_version(wuffs_zlib__decoder* self,
size_t sizeof_star_self,
uint64_t wuffs_version) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (sizeof(*self) != sizeof_star_self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER);
return 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);
return wuffs_base__error__bad_wuffs_version;
}
if (self->private_impl.magic != 0) {
return WUFFS_BASE__MAKE_STATUS(
WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE);
return wuffs_base__error__check_wuffs_version_called_twice;
}
{
wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version(
&self->private_impl.f_flate, sizeof(self->private_impl.f_flate),
WUFFS_VERSION);
if (z.code) {
if (z) {
return z;
}
}
@@ -9776,12 +9697,12 @@ wuffs_zlib__decoder__check_wuffs_version(wuffs_zlib__decoder* self,
wuffs_base__status z = wuffs_adler32__hasher__check_wuffs_version(
&self->private_impl.f_checksum, sizeof(self->private_impl.f_checksum),
WUFFS_VERSION);
if (z.code) {
if (z) {
return z;
}
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
return NULL;
}
// ---------------- Function Implementations
@@ -9794,10 +9715,9 @@ wuffs_zlib__decoder__set_ignore_checksum(wuffs_zlib__decoder* self, bool a_ic) {
return;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return;
}
@@ -9811,16 +9731,15 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self,
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return self->private_impl.status;
}
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint16_t v_x;
uint32_t v_checksum_got;
@@ -9883,7 +9802,7 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode[0].scratch;
@@ -9902,22 +9821,19 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self,
v_x = t_1;
}
if (((v_x >> 8) & 15) != 8) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_ZLIB__ERROR_BAD_COMPRESSION_METHOD);
status = wuffs_zlib__error__bad_compression_method;
goto exit;
}
if ((v_x >> 12) > 7) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_ZLIB__ERROR_BAD_COMPRESSION_WINDOW_SIZE);
status = wuffs_zlib__error__bad_compression_window_size;
goto exit;
}
if ((v_x & 32) != 0) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_ZLIB__ERROR_TODO_UNSUPPORTED_PRESET_DICTIONARY);
status = wuffs_zlib__error__todo_unsupported_preset_dictionary;
goto exit;
}
if ((v_x % 31) != 0) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_ZLIB__ERROR_BAD_PARITY_CHECK);
status = wuffs_zlib__error__bad_parity_check;
goto exit;
}
v_checksum_got = 0;
@@ -9966,7 +9882,7 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode[0].scratch;
@@ -9986,7 +9902,7 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self,
}
if (!self->private_impl.f_ignore_checksum &&
(v_checksum_got != v_checksum_want)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_ZLIB__ERROR_BAD_CHECKSUM);
status = wuffs_zlib__error__bad_checksum;
goto exit;
}