diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 078de0f2..e06f4b6a 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -2622,7 +2622,7 @@ struct wuffs_lzw__decoder__struct { uint32_t f_width; uint32_t f_bits; uint32_t f_n_bits; - uint32_t f_flush_j; + uint32_t f_output_wi; uint32_t f_read_from_return_value; uint8_t f_suffixes[4096][8]; uint16_t f_prefixes[4096]; @@ -7170,7 +7170,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, self->private_impl.f_width = (self->private_impl.f_literal_width + 1); self->private_impl.f_bits = 0; self->private_impl.f_n_bits = 0; - self->private_impl.f_flush_j = 0; + self->private_impl.f_output_wi = 0; v_i = 0; while (v_i < self->private_impl.f_clear_code) { self->private_impl.f_lm1s[v_i] = 0; @@ -7180,7 +7180,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, label_0_continue:; while (true) { wuffs_lzw__decoder__read_from(self, a_src); - if (self->private_impl.f_flush_j > 0) { + if (self->private_impl.f_output_wi > 0) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); status = wuffs_lzw__decoder__write_to(self, a_dst); if (status) { @@ -7234,7 +7234,7 @@ wuffs_lzw__decoder__read_from(wuffs_lzw__decoder* self, uint32_t v_width; uint32_t v_bits; uint32_t v_n_bits; - uint32_t v_j; + uint32_t v_output_wi; uint32_t v_code; uint32_t v_c; uint32_t v_o; @@ -7267,7 +7267,7 @@ wuffs_lzw__decoder__read_from(wuffs_lzw__decoder* self, v_width = self->private_impl.f_width; v_bits = self->private_impl.f_bits; v_n_bits = self->private_impl.f_n_bits; - v_j = self->private_impl.f_flush_j; + v_output_wi = self->private_impl.f_output_wi; while (true) { if (v_n_bits < v_width) { if (((uint64_t)(io1_a_src - iop_a_src)) >= 4) { @@ -7302,8 +7302,8 @@ wuffs_lzw__decoder__read_from(wuffs_lzw__decoder* self, v_bits >>= v_width; v_n_bits -= v_width; if (v_code < v_clear_code) { - self->private_impl.f_output[v_j] = ((uint8_t)(v_code)); - v_j = ((v_j + 1) & 8191); + self->private_impl.f_output[v_output_wi] = ((uint8_t)(v_code)); + v_output_wi = ((v_output_wi + 1) & 8191); if (v_save_code <= 4095) { v_lm1_a = ((self->private_impl.f_lm1s[v_prev_code] + 1) & 4095); self->private_impl.f_lm1s[v_save_code] = v_lm1_a; @@ -7339,10 +7339,12 @@ wuffs_lzw__decoder__read_from(wuffs_lzw__decoder* self, if (v_code == v_save_code) { v_c = v_prev_code; } - v_o = - ((v_j + (((uint32_t)(self->private_impl.f_lm1s[v_c])) & 4294967288)) & + v_o = ((v_output_wi + + (((uint32_t)(self->private_impl.f_lm1s[v_c])) & 4294967288)) & + 8191); + v_output_wi = + ((v_output_wi + 1 + ((uint32_t)(self->private_impl.f_lm1s[v_c]))) & 8191); - v_j = ((v_j + 1 + ((uint32_t)(self->private_impl.f_lm1s[v_c]))) & 8191); v_steps = (((uint32_t)(self->private_impl.f_lm1s[v_c])) >> 3); while (true) { memcpy((self->private_impl.f_output) + (v_o), @@ -7357,8 +7359,8 @@ wuffs_lzw__decoder__read_from(wuffs_lzw__decoder* self, label_1_break:; v_first_byte = self->private_impl.f_suffixes[v_c][0]; if (v_code == v_save_code) { - self->private_impl.f_output[v_j] = v_first_byte; - v_j = ((v_j + 1) & 8191); + self->private_impl.f_output[v_output_wi] = v_first_byte; + v_output_wi = ((v_output_wi + 1) & 8191); } if (v_save_code <= 4095) { v_lm1_b = ((self->private_impl.f_lm1s[v_prev_code] + 1) & 4095); @@ -7387,7 +7389,7 @@ wuffs_lzw__decoder__read_from(wuffs_lzw__decoder* self, self->private_impl.f_read_from_return_value = 3; goto label_0_break; } - if (v_j > 4095) { + if (v_output_wi > 4095) { self->private_impl.f_read_from_return_value = 1; goto label_0_break; } @@ -7410,7 +7412,7 @@ label_0_break:; 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_flush_j = v_j; + self->private_impl.f_output_wi = v_output_wi; if (a_src.private_impl.buf) { a_src.private_impl.buf->meta.ri = iop_a_src - a_src.private_impl.buf->data.ptr; @@ -7462,8 +7464,8 @@ wuffs_lzw__decoder__write_to(wuffs_lzw__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; v_i = 0; - while (self->private_impl.f_flush_j > 0) { - if (v_i > self->private_impl.f_flush_j) { + while (self->private_impl.f_output_wi > 0) { + if (v_i > self->private_impl.f_output_wi) { status = wuffs_lzw__error__internal_error_inconsistent_i_o; goto exit; } @@ -7472,10 +7474,10 @@ wuffs_lzw__decoder__write_to(wuffs_lzw__decoder* self, .ptr = self->private_impl.f_output, .len = 8199, }), - v_i, self->private_impl.f_flush_j); + v_i, self->private_impl.f_output_wi); v_n = wuffs_base__io_writer__copy_from_slice(&iop_a_dst, io1_a_dst, v_s); if (v_n == ((uint64_t)(v_s.len))) { - self->private_impl.f_flush_j = 0; + self->private_impl.f_output_wi = 0; status = NULL; goto ok; } @@ -7522,8 +7524,8 @@ wuffs_lzw__decoder__flush(wuffs_lzw__decoder* self) { .ptr = self->private_impl.f_output, .len = 8199, }), - self->private_impl.f_flush_j); - self->private_impl.f_flush_j = 0; + self->private_impl.f_output_wi); + self->private_impl.f_output_wi = 0; return v_s; } diff --git a/std/lzw/decode_lzw.wuffs b/std/lzw/decode_lzw.wuffs index 1f8672f8..f19d4978 100644 --- a/std/lzw/decode_lzw.wuffs +++ b/std/lzw/decode_lzw.wuffs @@ -33,7 +33,7 @@ pub struct decoder?( width base.u32[..12], bits base.u32, n_bits base.u32[..31], - flush_j base.u32[..8191], + output_wi base.u32[..8191], // read_from return value. The read_from method effectively returns a // base.u32 to show how decode should continue after calling write_to. That @@ -48,7 +48,7 @@ pub struct decoder?( // table in this decoder. See std/lzw/README.md for more detail. lm1s array[4096] base.u16[..4095], - // output[:flush_j] is the buffered output, connecting read_from with + // output[:output_wi] is the buffered output, connecting read_from with // write_to and flush. output array[8192 + 7] base.u8, ) @@ -70,7 +70,7 @@ pub func decoder.decode!??(dst base.io_writer, src base.io_reader) { this.width = this.literal_width + 1 this.bits = 0 this.n_bits = 0 - this.flush_j = 0 + this.output_wi = 0 var i base.u32[..8191] while i < this.clear_code { assert i < 256 via "a < b: a < c; c <= b"(c:this.clear_code) @@ -82,7 +82,7 @@ pub func decoder.decode!??(dst base.io_writer, src base.io_reader) { while true { this.read_from!(src:args.src) - if this.flush_j > 0 { + if this.output_wi > 0 { this.write_to!??(dst:args.dst) } @@ -109,7 +109,7 @@ pri func decoder.read_from!(src base.io_reader) { var width base.u32[..12] = this.width var bits base.u32 = this.bits var n_bits base.u32[..31] = this.n_bits - var j base.u32[..8191] = this.flush_j + var output_wi base.u32[..8191] = this.output_wi while true { if n_bits < width { @@ -152,8 +152,8 @@ pri func decoder.read_from!(src base.io_reader) { if code < clear_code { assert code < 256 via "a < b: a < c; c <= b"(c:clear_code) - this.output[j] = code as base.u8 - j = (j + 1) & 8191 + this.output[output_wi] = code as base.u8 + output_wi = (output_wi + 1) & 8191 if save_code <= 4095 { var lm1_a base.u16[..4095] = (this.lm1s[prev_code] + 1) & 4095 this.lm1s[save_code] = lm1_a @@ -189,17 +189,17 @@ pri func decoder.read_from!(src base.io_reader) { c = prev_code } - // Letting old_j and new_j denote the values of j before and after - // these two lines of code, the decoded bytes will be written to - // output[old_j:new_j]. They will be written back-to-front, 8 bytes - // at a time, starting by writing output[o:o + 8], which will - // contain output[new_j - 1]. + // Letting old_wi and new_wi denote the values of output_wi before + // and after these two lines of code, the decoded bytes will be + // written to output[old_wi:new_wi]. They will be written + // back-to-front, 8 bytes at a time, starting by writing + // output[o:o + 8], which will contain output[new_wi - 1]. // // In the special case that code == save_code, the decoded bytes // contain an extra copy (at the end) of the first byte, and will - // be written to output[old_j:new_j + 1]. - var o base.u32[..8191] = (j + ((this.lm1s[c] as base.u32) & 0xFFFFFFF8)) & 8191 - j = (j + 1 + (this.lm1s[c] as base.u32)) & 8191 + // be written to output[old_wi:new_wi + 1]. + var o base.u32[..8191] = (output_wi + ((this.lm1s[c] as base.u32) & 0xFFFFFFF8)) & 8191 + output_wi = (output_wi + 1 + (this.lm1s[c] as base.u32)) & 8191 var steps base.u32 = (this.lm1s[c] as base.u32) >> 3 while true { @@ -223,8 +223,8 @@ pri func decoder.read_from!(src base.io_reader) { var first_byte base.u8 = this.suffixes[c][0] if code == save_code { - this.output[j] = first_byte - j = (j + 1) & 8191 + this.output[output_wi] = first_byte + output_wi = (output_wi + 1) & 8191 } if save_code <= 4095 { @@ -255,8 +255,8 @@ pri func decoder.read_from!(src base.io_reader) { // Flush the output if it could be too full to contain the entire // decoding of the next code. The longest possible decoding is slightly // less than 4096 and output's length is 8192, so a conservative - // threshold is ensuring that j <= 4095. - if j > 4095 { + // threshold is ensuring that output_wi <= 4095. + if output_wi > 4095 { this.read_from_return_value = 1 break } @@ -281,19 +281,19 @@ pri func decoder.read_from!(src base.io_reader) { this.width = width this.bits = bits this.n_bits = n_bits - this.flush_j = j + this.output_wi = output_wi } pri func decoder.write_to!??(dst base.io_writer) { var i base.u32[..8191] - while this.flush_j > 0 { - if i > this.flush_j { + while this.output_wi > 0 { + if i > this.output_wi { return "?internal error: inconsistent I/O" } - var s slice base.u8 = this.output[i:this.flush_j] + var s slice base.u8 = this.output[i:this.output_wi] var n base.u64 = args.dst.copy_from_slice!(s:s) if n == s.length() { - this.flush_j = 0 + this.output_wi = 0 return ok } i = (i + ((n & 8191) as base.u32)) & 8191 @@ -306,7 +306,7 @@ pri func decoder.write_to!??(dst base.io_writer) { // without regressing benchmarks. pub func decoder.flush!() slice base.u8 { - var s slice base.u8 = this.output[:this.flush_j] - this.flush_j = 0 + var s slice base.u8 = this.output[:this.output_wi] + this.output_wi = 0 return s }