Rename the implicit in variable to args

This commit is contained in:
Nigel Tao committed 2018-07-29 10:26:22 +10:00
1 parent 58ded30954
commit ca06083f8a
19 files changed
+254 -252

No files matched your search

+41 -40
View File
@@ -113,7 +113,8 @@ pub struct decoder?(
// code_lengths is used to pass out-of-band data to init_huff.
//
// code_lengths[in.n_codes0 + i] holds the number of bits in the i'th code.
// code_lengths[args.n_codes0 + i] holds the number of bits in the i'th
// code.
code_lengths array[320] base.u8[..15],
// end_of_block is whether decode_huffman_xxx saw an end-of-block code.
@@ -124,15 +125,15 @@ pub struct decoder?(
pub func decoder.decode?(dst base.io_writer, src base.io_reader) {
while true {
in.dst.set_mark!()
var z base.status = try this.decode_blocks?(dst:in.dst, src:in.src)
args.dst.set_mark!()
var z base.status = try this.decode_blocks?(dst:args.dst, src:args.src)
if not z.is_suspension() {
return z
}
// TODO: should "since_mark" be "since_mark!", as the return value lets
// you modify the state of in.dst, so future mutations (via the slice)
// can change the veracity of any in.dst assertions?
var written slice base.u8 = in.dst.since_mark()
// you modify the state of args.dst, so future mutations (via the
// slice) can change the veracity of any args.dst assertions?
var written slice base.u8 = args.dst.since_mark()
// Append written, the decoded output, to the history ringbuffer.
if written.length() >= 0x8000 {
// If written is longer than the ringbuffer, we can ignore the
@@ -180,7 +181,7 @@ pri func decoder.decode_blocks?(dst base.io_writer, src base.io_reader) {
while this.n_bits < 3,
post this.n_bits >= 3,
{
this.bits |= (in.src.read_u8?() as base.u32) << this.n_bits
this.bits |= (args.src.read_u8?() as base.u32) << this.n_bits
this.n_bits += 8
}
final = this.bits & 0x01
@@ -189,22 +190,22 @@ pri func decoder.decode_blocks?(dst base.io_writer, src base.io_reader) {
this.n_bits -= 3
if type == 0 {
this.decode_uncompressed?(dst:in.dst, src:in.src)
this.decode_uncompressed?(dst:args.dst, src:args.src)
continue
} else if type == 1 {
this.init_fixed_huffman?()
} else if type == 2 {
this.init_dynamic_huffman?(src:in.src)
this.init_dynamic_huffman?(src:args.src)
} else {
return error "bad block"
}
this.end_of_block = false
this.decode_huffman_fast?(dst:in.dst, src:in.src)
this.decode_huffman_fast?(dst:args.dst, src:args.src)
if this.end_of_block {
continue
}
this.decode_huffman_slow?(dst:in.dst, src:in.src)
this.decode_huffman_slow?(dst:args.dst, src:args.src)
if this.end_of_block {
continue
}
@@ -224,18 +225,18 @@ pri func decoder.decode_uncompressed?(dst base.io_writer, src base.io_reader) {
this.n_bits = 0
this.bits = 0
var length base.u32 = in.src.read_u32le?()
var length base.u32 = args.src.read_u32le?()
if (length.low_bits(n:16) + length.high_bits(n:16)) != 0xFFFF {
return error "inconsistent stored block length"
}
length = length.low_bits(n:16)
while true {
var n_copied base.u32 = in.dst.copy_n_from_reader!(n:length, r:in.src)
var n_copied base.u32 = args.dst.copy_n_from_reader!(n:length, r:args.src)
if length <= n_copied {
return
}
length -= n_copied
if in.dst.available() == 0 {
if args.dst.available() == 0 {
// TODO: "closed for writes" instead?
yield suspension "short write"
} else {
@@ -278,7 +279,7 @@ pri func decoder.init_dynamic_huffman?(src base.io_reader) {
while n_bits < 14,
post n_bits >= 14,
{
bits |= (in.src.read_u8?() as base.u32) << n_bits
bits |= (args.src.read_u8?() as base.u32) << n_bits
n_bits += 8
}
var n_lit base.u32[257..288] = bits.low_bits(n:5) + 257
@@ -302,7 +303,7 @@ pri func decoder.init_dynamic_huffman?(src base.io_reader) {
inv i < n_clen,
post n_bits >= 3,
{
bits |= (in.src.read_u8?() as base.u32) << n_bits
bits |= (args.src.read_u8?() as base.u32) << n_bits
n_bits += 8
}
assert i < 19 via "a < b: a < c; c <= b"(c:n_clen)
@@ -336,7 +337,7 @@ pri func decoder.init_dynamic_huffman?(src base.io_reader) {
break
}
assert n_bits < 15 via "a < b: a < c; c <= b"(c:table_entry_n_bits)
bits |= (in.src.read_u8?() as base.u32) << n_bits
bits |= (args.src.read_u8?() as base.u32) << n_bits
n_bits += 8
}
// For H-CL, there should be no redirections and all symbols should be
@@ -384,7 +385,7 @@ pri func decoder.init_dynamic_huffman?(src base.io_reader) {
post n_bits >= n_extra_bits,
{
assert n_bits < 7 via "a < b: a < c; c <= b"(c:n_extra_bits)
bits |= (in.src.read_u8?() as base.u32) << n_bits
bits |= (args.src.read_u8?() as base.u32) << n_bits
n_bits += 8
}
rep_count += bits.low_bits(n:n_extra_bits)
@@ -457,9 +458,9 @@ pri func decoder.init_huff?(which base.u32[..1], n_codes0 base.u32[..320], n_cod
// - counts[5] = 2
// - all other counts elements are 0.
var counts array[16] base.u16[..320]
var i base.u32 = in.n_codes0
while i < in.n_codes1 {
assert i < 320 via "a < b: a < c; c <= b"(c:in.n_codes1)
var i base.u32 = args.n_codes0
while i < args.n_codes1 {
assert i < 320 via "a < b: a < c; c <= b"(c:args.n_codes1)
// TODO: this if should be unnecessary. Have some way to assert that,
// for all j, counts[j] <= i, and thus counts[j]++ will not overflow.
if counts[this.code_lengths[i]] >= 320 {
@@ -468,7 +469,7 @@ pri func decoder.init_huff?(which base.u32[..1], n_codes0 base.u32[..320], n_cod
counts[this.code_lengths[i]] += 1
i += 1
}
if ((counts[0] as base.u32) + in.n_codes0) == in.n_codes1 {
if ((counts[0] as base.u32) + args.n_codes0) == args.n_codes1 {
return error "no Huffman codes"
}
@@ -542,20 +543,20 @@ pri func decoder.init_huff?(which base.u32[..1], n_codes0 base.u32[..320], n_cod
// - offsets[4] = 8, formerly 7
// - offsets[5] = 10, formerly 8
var symbols array[320] base.u16[..319]
i = in.n_codes0
while i < in.n_codes1,
i = args.n_codes0
while i < args.n_codes1,
inv n_symbols <= 288,
{
assert i < 320 via "a < b: a < c; c <= b"(c:in.n_codes1)
assert i < 320 via "a < b: a < c; c <= b"(c:args.n_codes1)
// TODO: this if check should be unnecessary.
if i < in.n_codes0 {
if i < args.n_codes0 {
return error "internal error: inconsistent Huffman decoder state"
}
if this.code_lengths[i] != 0 {
if offsets[this.code_lengths[i]] >= 320 {
return error "internal error: inconsistent Huffman decoder state"
}
symbols[offsets[this.code_lengths[i]]] = (i - in.n_codes0) as base.u16
symbols[offsets[this.code_lengths[i]]] = (i - args.n_codes0) as base.u16
offsets[this.code_lengths[i]] += 1
}
i += 1
@@ -592,12 +593,12 @@ pri func decoder.init_huff?(which base.u32[..1], n_codes0 base.u32[..320], n_cod
max_cl -= 1
}
if max_cl <= 9 {
this.n_huffs_bits[in.which] = max_cl
this.n_huffs_bits[args.which] = max_cl
} else {
this.n_huffs_bits[in.which] = 9
this.n_huffs_bits[args.which] = 9
}
// Calculate this.huffs[in.which].
// Calculate this.huffs[args.which].
//
// For the clcode example in this package's README.md:
// - this.huffs[0][0b..000] = 0x80000003 (literal, symbols[0]=0x00, code_length=3)
@@ -614,7 +615,7 @@ pri func decoder.init_huff?(which base.u32[..1], n_codes0 base.u32[..320], n_cod
if (n_symbols != (offsets[max_cl] as base.u32)) or (n_symbols != (offsets[15] as base.u32)) {
return error "internal error: inconsistent Huffman decoder state"
}
if (in.n_codes0 + (symbols[0] as base.u32)) >= 320 {
if (args.n_codes0 + (symbols[0] as base.u32)) >= 320 {
return error "internal error: inconsistent Huffman decoder state"
}
@@ -622,7 +623,7 @@ pri func decoder.init_huff?(which base.u32[..1], n_codes0 base.u32[..320], n_cod
if max_cl < 9 {
initial_high_bits = (1 as base.u32) << max_cl
}
var prev_cl base.u32[..15] = this.code_lengths[in.n_codes0 + (symbols[0] as base.u32)] as base.u32
var prev_cl base.u32[..15] = this.code_lengths[args.n_codes0 + (symbols[0] as base.u32)] as base.u32
var prev_redirect_key base.u32 = 0xFFFFFFFF
var top base.u32[..1234]
var next_top base.u32[..1234] = 512
@@ -634,10 +635,10 @@ pri func decoder.init_huff?(which base.u32[..1], n_codes0 base.u32[..320], n_cod
pre i < 288,
inv n_symbols <= 288,
{
if (in.n_codes0 + (symbols[i] as base.u32)) >= 320 {
if (args.n_codes0 + (symbols[i] as base.u32)) >= 320 {
return error "internal error: inconsistent Huffman decoder state"
}
var cl base.u32[..15] = this.code_lengths[in.n_codes0 + (symbols[i] as base.u32)] as base.u32
var cl base.u32[..15] = this.code_lengths[args.n_codes0 + (symbols[i] as base.u32)] as base.u32
if cl > prev_cl {
code <<= cl - prev_cl
if code >= (1 << 15) {
@@ -694,7 +695,7 @@ pri func decoder.init_huff?(which base.u32[..1], n_codes0 base.u32[..320], n_cod
next_top = top + ((1 as base.u32) << tmp)
redirect_key = (reverse8[redirect_key >> 1] as base.u32) | ((redirect_key & 1) << 8)
this.huffs[in.which][redirect_key] = 0x10000009 | (top << 8) | (tmp << 4)
this.huffs[args.which][redirect_key] = 0x10000009 | (top << 8) | (tmp << 4)
}
}
if (key >= (1 << 9)) or (counts[prev_cl] <= 0) {
@@ -709,13 +710,13 @@ pri func decoder.init_huff?(which base.u32[..1], n_codes0 base.u32[..320], n_cod
if symbol == 256 {
// End-of-block.
value = 0x20000000 | cl
} else if (symbol < 256) and (in.which == 0) {
} else if (symbol < 256) and (args.which == 0) {
// Literal.
value = 0x80000000 | (symbol << 8) | cl
} else if symbol >= in.base_symbol {
} else if symbol >= args.base_symbol {
// Base number + extra bits.
symbol -= in.base_symbol
if in.which == 0 {
symbol -= args.base_symbol
if args.which == 0 {
value = lcode_magic_numbers[symbol & 31] | cl
} else {
value = dcode_magic_numbers[symbol & 31] | cl
@@ -738,7 +739,7 @@ pri func decoder.init_huff?(which base.u32[..1], n_codes0 base.u32[..320], n_cod
if (top + ((high_bits | reversed_key) & 511)) >= 1234 {
return error "internal error: inconsistent Huffman decoder state"
}
this.huffs[in.which][top + ((high_bits | reversed_key) & 511)] = value
this.huffs[args.which][top + ((high_bits | reversed_key) & 511)] = value
}
i += 1
+68 -68
View File
@@ -45,13 +45,13 @@ pri func decoder.decode_huffman_fast?(dst base.io_writer, src base.io_reader) {
// For reading, strictly speaking, we only need 6 bytes (48 bits) of
// available input, because the H-L length/literal code is up to 15 bits
// plus up to 5 extra bits, the H-D distance code is up to 15 bits plus up
// to 13 extra bits and 15 + 5 + 15 + 13 == 48. However, in.src.available()
// assertions are made in terms of bytes, not bits.
// to 13 extra bits and 15 + 5 + 15 + 13 == 48. However,
// args.src.available() assertions are made in terms of bytes, not bits.
//
// In theory, we could write assertions that mixed bytes and bits, such as:
//
// assert ((in.src.available() >= 6) and (n_bits >= 5)) or
// ((in.src.available() >= 4) and (n_bits >= 21))
// assert ((args.src.available() >= 6) and (n_bits >= 5)) or
// ((args.src.available() >= 4) and (n_bits >= 21))
//
// but that looks clumsy and makes the proofs more complicated. Instead, we
// are conservative and work in terms of bytes only. In bytes, each code
@@ -59,24 +59,24 @@ pri func decoder.decode_huffman_fast?(dst base.io_writer, src base.io_reader) {
// for each. There are also up to 13 extra bits, or 2 bytes. Thus, each
// code requires up to 2 + 2 + 2 == 6 bytes, and there are two codes (one
// from H-L and one from H-D). Therefore, we check for at least 12 bytes.
while:loop(in.dst.available() >= 258) and (in.src.available() >= 12) {
while:loop(args.dst.available() >= 258) and (args.src.available() >= 12) {
// Ensure that we have at least 15 bits of input.
if n_bits < 15 {
assert n_bits >= 0 // TODO: this shouldn't be necessary.
bits |= (in.src.peek_u8() as base.u32) << n_bits
in.src.skip_fast!(actual:1, worst_case:1)
bits |= (args.src.peek_u8() as base.u32) << n_bits
args.src.skip_fast!(actual:1, worst_case:1)
n_bits += 8
bits |= (in.src.peek_u8() as base.u32) << n_bits
in.src.skip_fast!(actual:1, worst_case:1)
bits |= (args.src.peek_u8() as base.u32) << n_bits
args.src.skip_fast!(actual:1, worst_case:1)
n_bits += 8
assert n_bits >= 15
} else {
assert in.src.available() >= 10
assert args.src.available() >= 10
}
// These assertions are redundant, but are listed explicitly for
// clarity. They must hold regardless of which branch was taken for the
// if statement above.
assert in.src.available() >= 10
assert args.src.available() >= 10
assert n_bits >= 15
// Decode an lcode symbol from H-L.
@@ -87,11 +87,11 @@ pri func decoder.decode_huffman_fast?(dst base.io_writer, src base.io_reader) {
if (table_entry >> 31) != 0 {
// Literal.
in.dst.write_fast_u8!(x:((table_entry >> 8) & 0xFF) as base.u8)
args.dst.write_fast_u8!(x:((table_entry >> 8) & 0xFF) as base.u8)
continue:loop
} else if (table_entry >> 30) != 0 {
// No-op; code continues past the if-else chain.
assert in.src.available() >= 8
assert args.src.available() >= 8
} else if (table_entry >> 29) != 0 {
// End of block.
this.end_of_block = true
@@ -102,18 +102,18 @@ pri func decoder.decode_huffman_fast?(dst base.io_writer, src base.io_reader) {
// Ensure that we have at least 15 bits of input.
if n_bits < 15 {
assert n_bits >= 0 // TODO: this shouldn't be necessary.
bits |= (in.src.peek_u8() as base.u32) << n_bits
in.src.skip_fast!(actual:1, worst_case:1)
bits |= (args.src.peek_u8() as base.u32) << n_bits
args.src.skip_fast!(actual:1, worst_case:1)
n_bits += 8
bits |= (in.src.peek_u8() as base.u32) << n_bits
in.src.skip_fast!(actual:1, worst_case:1)
bits |= (args.src.peek_u8() as base.u32) << n_bits
args.src.skip_fast!(actual:1, worst_case:1)
n_bits += 8
assert n_bits >= 15
} else {
assert in.src.available() >= 8
assert args.src.available() >= 8
}
// Once again, redundant but explicit assertions.
assert in.src.available() >= 8
assert args.src.available() >= 8
assert n_bits >= 15
var redir_top base.u32[..0xFFFF] = (table_entry >> 8) & 0xFFFF
@@ -128,7 +128,7 @@ pri func decoder.decode_huffman_fast?(dst base.io_writer, src base.io_reader) {
if (table_entry >> 31) != 0 {
// Literal.
in.dst.write_fast_u8!(x:((table_entry >> 8) & 0xFF) as base.u8)
args.dst.write_fast_u8!(x:((table_entry >> 8) & 0xFF) as base.u8)
continue:loop
} else if (table_entry >> 30) != 0 {
// No-op; code continues past the if-else chain.
@@ -145,7 +145,7 @@ pri func decoder.decode_huffman_fast?(dst base.io_writer, src base.io_reader) {
}
// Once again, redundant but explicit assertions.
assert in.src.available() >= 8
assert args.src.available() >= 8
} else if (table_entry >> 27) != 0 {
return error "bad Huffman code"
@@ -160,18 +160,18 @@ pri func decoder.decode_huffman_fast?(dst base.io_writer, src base.io_reader) {
// Ensure that we have at least 15 bits of input.
if n_bits < 15 {
assert n_bits >= 0 // TODO: this shouldn't be necessary.
bits |= (in.src.peek_u8() as base.u32) << n_bits
in.src.skip_fast!(actual:1, worst_case:1)
bits |= (args.src.peek_u8() as base.u32) << n_bits
args.src.skip_fast!(actual:1, worst_case:1)
n_bits += 8
bits |= (in.src.peek_u8() as base.u32) << n_bits
in.src.skip_fast!(actual:1, worst_case:1)
bits |= (args.src.peek_u8() as base.u32) << n_bits
args.src.skip_fast!(actual:1, worst_case:1)
n_bits += 8
assert n_bits >= 15
} else {
assert in.src.available() >= 6
assert args.src.available() >= 6
}
// Once again, redundant but explicit assertions.
assert in.src.available() >= 6
assert args.src.available() >= 6
assert n_bits >= 15
length = (length + bits.low_bits(n:table_entry_n_bits)) & 0x7FFF
@@ -179,7 +179,7 @@ pri func decoder.decode_huffman_fast?(dst base.io_writer, src base.io_reader) {
n_bits -= table_entry_n_bits
} else {
assert in.src.available() >= 6
assert args.src.available() >= 6
}
if length > 258 {
return error "internal error: inconsistent Huffman decoder state"
@@ -188,18 +188,18 @@ pri func decoder.decode_huffman_fast?(dst base.io_writer, src base.io_reader) {
// Ensure that we have at least 15 bits of input.
if n_bits < 15 {
assert n_bits >= 0 // TODO: this shouldn't be necessary.
bits |= (in.src.peek_u8() as base.u32) << n_bits
in.src.skip_fast!(actual:1, worst_case:1)
bits |= (args.src.peek_u8() as base.u32) << n_bits
args.src.skip_fast!(actual:1, worst_case:1)
n_bits += 8
bits |= (in.src.peek_u8() as base.u32) << n_bits
in.src.skip_fast!(actual:1, worst_case:1)
bits |= (args.src.peek_u8() as base.u32) << n_bits
args.src.skip_fast!(actual:1, worst_case:1)
n_bits += 8
assert n_bits >= 15
} else {
assert in.src.available() >= 4
assert args.src.available() >= 4
}
// Once again, redundant but explicit assertions.
assert in.src.available() >= 4
assert args.src.available() >= 4
assert n_bits >= 15
// Decode a dcode symbol from H-D.
@@ -213,18 +213,18 @@ pri func decoder.decode_huffman_fast?(dst base.io_writer, src base.io_reader) {
// Ensure that we have at least 15 bits of input.
if n_bits < 15 {
assert n_bits >= 0 // TODO: this shouldn't be necessary.
bits |= (in.src.peek_u8() as base.u32) << n_bits
in.src.skip_fast!(actual:1, worst_case:1)
bits |= (args.src.peek_u8() as base.u32) << n_bits
args.src.skip_fast!(actual:1, worst_case:1)
n_bits += 8
bits |= (in.src.peek_u8() as base.u32) << n_bits
in.src.skip_fast!(actual:1, worst_case:1)
bits |= (args.src.peek_u8() as base.u32) << n_bits
args.src.skip_fast!(actual:1, worst_case:1)
n_bits += 8
assert n_bits >= 15
} else {
assert in.src.available() >= 2
assert args.src.available() >= 2
}
// Once again, redundant but explicit assertions.
assert in.src.available() >= 2
assert args.src.available() >= 2
assert n_bits >= 15
redir_top = (table_entry >> 8) & 0xFFFF
@@ -237,7 +237,7 @@ pri func decoder.decode_huffman_fast?(dst base.io_writer, src base.io_reader) {
bits >>= table_entry_n_bits
n_bits -= table_entry_n_bits
} else {
assert in.src.available() >= 2
assert args.src.available() >= 2
}
// For H-D, all symbols should be base_number + extra_bits.
@@ -260,11 +260,11 @@ pri func decoder.decode_huffman_fast?(dst base.io_writer, src base.io_reader) {
// Ensure that we have at least 15 bits of input.
if n_bits < 15 {
assert n_bits >= 0 // TODO: this shouldn't be necessary.
bits |= (in.src.peek_u8() as base.u32) << n_bits
in.src.skip_fast!(actual:1, worst_case:1)
bits |= (args.src.peek_u8() as base.u32) << n_bits
args.src.skip_fast!(actual:1, worst_case:1)
n_bits += 8
bits |= (in.src.peek_u8() as base.u32) << n_bits
in.src.skip_fast!(actual:1, worst_case:1)
bits |= (args.src.peek_u8() as base.u32) << n_bits
args.src.skip_fast!(actual:1, worst_case:1)
n_bits += 8
assert n_bits >= 15
}
@@ -282,16 +282,16 @@ pri func decoder.decode_huffman_fast?(dst base.io_writer, src base.io_reader) {
// decode_huffman_slow.
while true,
pre length <= 258,
pre in.dst.available() >= 258,
pre args.dst.available() >= 258,
{
// Copy from this.history.
if ((dist_minus_1 + 1) as base.u64) > in.dst.since_mark().length() {
if ((dist_minus_1 + 1) as base.u64) > args.dst.since_mark().length() {
// Set (hlen, hdist) to be the length-distance pair to copy
// from this.history, and (length, distance) to be the
// remaining length-distance pair to copy from in.dst.
// remaining length-distance pair to copy from args.dst.
var hlen base.u32[..0x7FFF]
var hdist base.u32 =
(((dist_minus_1 + 1) as base.u64) - in.dst.since_mark().length()) as base.u32
(((dist_minus_1 + 1) as base.u64) - args.dst.since_mark().length()) as base.u32
if length > hdist {
assert hdist < length via "a < b: b > a"()
assert hdist < 0x8000 via "a < b: a < c; c <= b"(c:length)
@@ -318,69 +318,69 @@ pri func decoder.decode_huffman_fast?(dst base.io_writer, src base.io_reader) {
//
// This copying is simpler than the decode_huffman_slow version
// because it cannot yield. We have already checked that
// in.dst.available() is large enough.
// args.dst.available() is large enough.
//
// The "while true { etc; break }" is a redundant version of
// "etc", but its presence minimizes the diff between
// decode_huffman_fast and decode_huffman_slow.
while true,
inv length <= 258,
inv in.dst.available() >= 258,
inv args.dst.available() >= 258,
{
// TODO: copy_from_slice32 should probably update the
// "in.dst.available() >= 258" fact. It should certainly
// "args.dst.available() >= 258" fact. It should certainly
// invalidate any fact that was "<=" instead of ">=".
n_copied = in.dst.copy_n_from_slice!(
n_copied = args.dst.copy_n_from_slice!(
n:hlen, s:this.history[hdist & 0x7FFF:])
if hlen <= n_copied {
break
}
hlen -= n_copied
in.dst.copy_n_from_slice!(n:hlen, s:this.history[:])
args.dst.copy_n_from_slice!(n:hlen, s:this.history[:])
break
}
if length == 0 {
// No need to copy from in.dst.
// No need to copy from args.dst.
continue:loop
}
if ((dist_minus_1 + 1) as base.u64) > in.dst.since_mark().length() {
if ((dist_minus_1 + 1) as base.u64) > args.dst.since_mark().length() {
return error "internal error: inconsistent distance"
}
}
// Once again, redundant but explicit assertions.
assert length <= 258
assert ((dist_minus_1 + 1) as base.u64) <= in.dst.since_mark().length()
assert in.dst.available() >= 258
assert ((dist_minus_1 + 1) as base.u64) <= args.dst.since_mark().length()
assert args.dst.available() >= 258
// We can therefore prove:
assert (dist_minus_1 + 1) > 0
assert (length as base.u64) <= 258
assert (length as base.u64) <= in.dst.available() via "a <= b: a <= c; c <= b"(c:258)
assert (length as base.u64) <= args.dst.available() via "a <= b: a <= c; c <= b"(c:258)
// Copy from in.dst.
in.dst.copy_n_from_history_fast!(n:length, distance:(dist_minus_1 + 1))
// Copy from args.dst.
args.dst.copy_n_from_history_fast!(n:length, distance:(dist_minus_1 + 1))
break
}
}
// Ensure n_bits < 8 by rewindng in.src, if we loaded too many of its bytes
// into the bits variable.
// Ensure n_bits < 8 by rewindng args.src, if we loaded too many of its
// bytes into the bits variable.
//
// Note that we can unconditionally call undo_read (without resulting in an
// "invalid I/O operation" error code) only because this whole function can
// never suspend, as all of its I/O operations were checked beforehand for
// sufficient buffer space. Otherwise, resuming from the suspension could
// mean that the (possibly different) in.src is no longer rewindable, even
// if conceptually, this function was responsible for reading the bytes we
// want to rewind.
// mean that the (possibly different) args.src is no longer rewindable,
// even if conceptually, this function was responsible for reading the
// bytes we want to rewind.
while n_bits >= 8,
post n_bits < 8,
{
n_bits -= 8
if in.src.can_undo_byte() {
in.src.undo_byte!()
if args.src.can_undo_byte() {
args.src.undo_byte!()
} else {
return error "internal error: inconsistent I/O"
}
+16 -16
View File
@@ -41,13 +41,13 @@ pri func decoder.decode_huffman_slow?(dst base.io_writer, src base.io_reader) {
break
}
assert n_bits < 15 via "a < b: a < c; c <= b"(c:table_entry_n_bits)
bits |= (in.src.read_u8?() as base.u32) << n_bits
bits |= (args.src.read_u8?() as base.u32) << n_bits
n_bits += 8
}
if (table_entry >> 31) != 0 {
// Literal.
in.dst.write_u8?(x:((table_entry >> 8) & 0xFF) as base.u8)
args.dst.write_u8?(x:((table_entry >> 8) & 0xFF) as base.u8)
continue:loop
} else if (table_entry >> 30) != 0 {
// No-op; code continues past the if-else chain.
@@ -71,13 +71,13 @@ pri func decoder.decode_huffman_slow?(dst base.io_writer, src base.io_reader) {
break
}
assert n_bits < 15 via "a < b: a < c; c <= b"(c:table_entry_n_bits)
bits |= (in.src.read_u8?() as base.u32) << n_bits
bits |= (args.src.read_u8?() as base.u32) << n_bits
n_bits += 8
}
if (table_entry >> 31) != 0 {
// Literal.
in.dst.write_u8?(x:((table_entry >> 8) & 0xFF) as base.u8)
args.dst.write_u8?(x:((table_entry >> 8) & 0xFF) as base.u8)
continue:loop
} else if (table_entry >> 30) != 0 {
// No-op; code continues past the if-else chain.
@@ -107,7 +107,7 @@ pri func decoder.decode_huffman_slow?(dst base.io_writer, src base.io_reader) {
post n_bits >= table_entry_n_bits,
{
assert n_bits < 15 via "a < b: a < c; c <= b"(c:table_entry_n_bits)
bits |= (in.src.read_u8?() as base.u32) << n_bits
bits |= (args.src.read_u8?() as base.u32) << n_bits
n_bits += 8
}
length = (length + bits.low_bits(n:table_entry_n_bits)) & 0x7FFF
@@ -125,7 +125,7 @@ pri func decoder.decode_huffman_slow?(dst base.io_writer, src base.io_reader) {
break
}
assert n_bits < 15 via "a < b: a < c; c <= b"(c:table_entry_n_bits)
bits |= (in.src.read_u8?() as base.u32) << n_bits
bits |= (args.src.read_u8?() as base.u32) << n_bits
n_bits += 8
}
// Check for a redirect.
@@ -144,7 +144,7 @@ pri func decoder.decode_huffman_slow?(dst base.io_writer, src base.io_reader) {
break
}
assert n_bits < 15 via "a < b: a < c; c <= b"(c:table_entry_n_bits)
bits |= (in.src.read_u8?() as base.u32) << n_bits
bits |= (args.src.read_u8?() as base.u32) << n_bits
n_bits += 8
}
}
@@ -170,7 +170,7 @@ pri func decoder.decode_huffman_slow?(dst base.io_writer, src base.io_reader) {
post n_bits >= table_entry_n_bits,
{
assert n_bits < 15 via "a < b: a < c; c <= b"(c:table_entry_n_bits)
bits |= (in.src.read_u8?() as base.u32) << n_bits
bits |= (args.src.read_u8?() as base.u32) << n_bits
n_bits += 8
}
dist_minus_1 = (dist_minus_1 + bits.low_bits(n:table_entry_n_bits)) & 0x7FFF
@@ -181,13 +181,13 @@ pri func decoder.decode_huffman_slow?(dst base.io_writer, src base.io_reader) {
var n_copied base.u32
while true {
// Copy from this.history.
if ((dist_minus_1 + 1) as base.u64) > in.dst.since_mark().length() {
if ((dist_minus_1 + 1) as base.u64) > args.dst.since_mark().length() {
// Set (hlen, hdist) to be the length-distance pair to copy
// from this.history, and (length, distance) to be the
// remaining length-distance pair to copy from in.dst.
// remaining length-distance pair to copy from args.dst.
var hlen base.u32[..0x7FFF]
var hdist base.u32 =
(((dist_minus_1 + 1) as base.u64) - in.dst.since_mark().length()) as base.u32
(((dist_minus_1 + 1) as base.u64) - args.dst.since_mark().length()) as base.u32
if length > hdist {
assert hdist < length via "a < b: b > a"()
assert hdist < 0x8000 via "a < b: a < c; c <= b"(c:length)
@@ -206,7 +206,7 @@ pri func decoder.decode_huffman_slow?(dst base.io_writer, src base.io_reader) {
// Copy from hdist to the end of this.history.
while true {
n_copied = in.dst.copy_n_from_slice!(
n_copied = args.dst.copy_n_from_slice!(
n:hlen, s:this.history[hdist & 0x7FFF:])
if hlen <= n_copied {
hlen = 0
@@ -226,7 +226,7 @@ pri func decoder.decode_huffman_slow?(dst base.io_writer, src base.io_reader) {
// Copy from the start of this.history, if we wrapped around.
if hlen > 0 {
while true {
n_copied = in.dst.copy_n_from_slice!(
n_copied = args.dst.copy_n_from_slice!(
n:hlen, s:this.history[hdist & 0x7FFF:])
if hlen <= n_copied {
hlen = 0
@@ -240,13 +240,13 @@ pri func decoder.decode_huffman_slow?(dst base.io_writer, src base.io_reader) {
}
if length == 0 {
// No need to copy from in.dst.
// No need to copy from args.dst.
continue:loop
}
}
// Copy from in.dst.
n_copied = in.dst.copy_n_from_history!(n:length, distance:(dist_minus_1 + 1))
// Copy from args.dst.
n_copied = args.dst.copy_n_from_history!(n:length, distance:(dist_minus_1 + 1))
if length <= n_copied {
length = 0
break