diff --git a/cmd/puffs-gen-c/func.go b/cmd/puffs-gen-c/func.go index 330228df..a8c04113 100644 --- a/cmd/puffs-gen-c/func.go +++ b/cmd/puffs-gen-c/func.go @@ -955,6 +955,14 @@ func (g *gen) writeCallSuspendibles(n *a.Expr, depth uint32) error { } g.writes("if (status) { goto suspend; }\n") + } else if isThisMethod(g.tm, n, "decode_dynamic", 2) { + g.printf("status = puffs_%s_%s_decode_dynamic(self, %sdst, %ssrc);\n", + g.pkgName, g.perFunc.funk.Receiver().String(g.tm), aPrefix, aPrefix) + if err := g.writeLoadExprDerivedVars(n); err != nil { + return err + } + g.writes("if (status) { goto suspend; }\n") + } else if isDecode(g.tm, n) { g.printf("status = puffs_%s_lzw_decoder_decode(&self->private_impl.f_lzw, %sdst, %s%s);\n", g.pkgName, aPrefix, vPrefix, n.Args()[1].Arg().Value().String(g.tm)) diff --git a/gen/c/std/flate.c b/gen/c/std/flate.c index 592c3d78..011cbaa1 100644 --- a/gen/c/std/flate.c +++ b/gen/c/std/flate.c @@ -100,13 +100,16 @@ typedef int32_t puffs_flate_status; #define PUFFS_FLATE_SUSPENSION_SHORT_WRITE 7 // 0x00000007 #define PUFFS_FLATE_ERROR_CLOSED_FOR_WRITES -2147483640 // 0x80000008 -#define PUFFS_FLATE_ERROR_BAD_FLATE_BLOCK -1157040128 // 0xbb08f800 +#define PUFFS_FLATE_ERROR_BAD_DISTANCE_CODE_COUNT -1157040128 // 0xbb08f800 +#define PUFFS_FLATE_ERROR_BAD_FLATE_BLOCK -1157040127 // 0xbb08f801 +#define PUFFS_FLATE_ERROR_BAD_LITERALLENGTH_CODE_COUNT \ + -1157040126 // 0xbb08f802 #define PUFFS_FLATE_ERROR_INCONSISTENT_STORED_BLOCK_LENGTH \ - -1157040127 // 0xbb08f801 + -1157040125 // 0xbb08f803 #define PUFFS_FLATE_ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS \ - -1157040126 // 0xbb08f802 -#define PUFFS_FLATE_ERROR_TODO_FIXED_HUFFMAN_BLOCKS -1157040125 // 0xbb08f803 -#define PUFFS_FLATE_ERROR_TODO_DYNAMIC_HUFFMAN_BLOCKS -1157040124 // 0xbb08f804 + -1157040124 // 0xbb08f804 +#define PUFFS_FLATE_ERROR_TODO_FIXED_HUFFMAN_BLOCKS -1157040123 // 0xbb08f805 +#define PUFFS_FLATE_ERROR_TODO_DYNAMIC_HUFFMAN_BLOCKS -1157040122 // 0xbb08f806 bool puffs_flate_status_is_error(puffs_flate_status s); @@ -129,6 +132,9 @@ typedef struct { uint32_t f_bits; uint32_t f_n_bits; + uint32_t f_wip0; + uint32_t f_wip1; + uint32_t f_wip2; struct { uint32_t coro_susp_point; @@ -139,6 +145,14 @@ typedef struct { uint32_t coro_susp_point; uint32_t v_n; } c_decode_uncompressed[1]; + struct { + uint32_t coro_susp_point; + uint32_t v_bits; + uint32_t v_n_bits; + uint32_t v_hlit; + uint32_t v_hdist; + uint32_t v_hclen; + } c_decode_dynamic[1]; } private_impl; } puffs_flate_decoder; @@ -166,6 +180,10 @@ puffs_flate_status puffs_flate_decoder_decode_uncompressed( puffs_base_writer1 a_dst, puffs_base_reader1 a_src); +puffs_flate_status puffs_flate_decoder_decode_dynamic(puffs_flate_decoder* self, + puffs_base_writer1 a_dst, + puffs_base_reader1 a_src); + #ifdef __cplusplus } // extern "C" #endif @@ -224,8 +242,10 @@ const char* puffs_flate_status_strings0[9] = { "flate: closed for writes", }; -const char* puffs_flate_status_strings1[5] = { +const char* puffs_flate_status_strings1[7] = { + "flate: bad distance code count", "flate: bad flate block", + "flate: bad literal/length code count", "flate: inconsistent stored block length", "flate: internal error: inconsistent n_bits", "flate: TODO: fixed Huffman blocks", @@ -242,7 +262,7 @@ const char* puffs_flate_status_string(puffs_flate_status s) { break; case puffs_flate_packageid: a = puffs_flate_status_strings1; - n = 5; + n = 7; break; } uint32_t i = s & 0xff; @@ -378,8 +398,32 @@ puffs_flate_status puffs_flate_decoder_decode(puffs_flate_decoder* self, status = PUFFS_FLATE_ERROR_TODO_FIXED_HUFFMAN_BLOCKS; goto suspend; } else if (v_type == 2) { - status = PUFFS_FLATE_ERROR_TODO_DYNAMIC_HUFFMAN_BLOCKS; - goto suspend; + PUFFS_COROUTINE_SUSPENSION_POINT(3); + if (a_src.buf) { + size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); + a_src.buf->ri += n; + puffs_base_limit1* lim; + for (lim = &a_src.limit; lim; lim = lim->next) { + if (lim->ptr_to_len) { + *lim->ptr_to_len -= n; + } + } + } + status = puffs_flate_decoder_decode_dynamic(self, a_dst, a_src); + if (a_src.buf) { + b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + size_t len = a_src.buf->wi - a_src.buf->ri; + puffs_base_limit1* lim; + for (lim = &a_src.limit; lim; lim = lim->next) { + if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { + len = *lim->ptr_to_len; + } + } + b_rend_src = b_rptr_src + len; + } + if (status) { + goto suspend; + } } else { status = PUFFS_FLATE_ERROR_BAD_FLATE_BLOCK; goto suspend; @@ -568,3 +612,116 @@ short_read_src: : PUFFS_FLATE_SUSPENSION_SHORT_READ; goto suspend; } + +puffs_flate_status puffs_flate_decoder_decode_dynamic( + puffs_flate_decoder* self, + puffs_base_writer1 a_dst, + puffs_base_reader1 a_src) { + if (!self) { + return PUFFS_FLATE_ERROR_BAD_RECEIVER; + } + if (self->private_impl.magic != PUFFS_MAGIC) { + self->private_impl.status = PUFFS_FLATE_ERROR_CONSTRUCTOR_NOT_CALLED; + } + if (self->private_impl.status < 0) { + return self->private_impl.status; + } + puffs_flate_status status = PUFFS_FLATE_STATUS_OK; + + uint32_t v_bits; + uint32_t v_n_bits; + uint32_t v_hlit; + uint32_t v_hdist; + uint32_t v_hclen; + + uint8_t* b_rptr_src = NULL; + uint8_t* b_rend_src = NULL; + if (a_src.buf) { + b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + size_t len = a_src.buf->wi - a_src.buf->ri; + puffs_base_limit1* lim; + for (lim = &a_src.limit; lim; lim = lim->next) { + if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { + len = *lim->ptr_to_len; + } + } + b_rend_src = b_rptr_src + len; + } + + uint32_t coro_susp_point = + self->private_impl.c_decode_dynamic[0].coro_susp_point; + if (coro_susp_point) { + v_bits = self->private_impl.c_decode_dynamic[0].v_bits; + v_n_bits = self->private_impl.c_decode_dynamic[0].v_n_bits; + v_hlit = self->private_impl.c_decode_dynamic[0].v_hlit; + v_hdist = self->private_impl.c_decode_dynamic[0].v_hdist; + v_hclen = self->private_impl.c_decode_dynamic[0].v_hclen; + } + switch (coro_susp_point) { + PUFFS_COROUTINE_SUSPENSION_POINT(0); + + v_bits = self->private_impl.f_bits; + v_n_bits = self->private_impl.f_n_bits; + while (v_n_bits < 14) { + PUFFS_COROUTINE_SUSPENSION_POINT(1); + if (PUFFS_UNLIKELY(b_rptr_src == b_rend_src)) { + goto short_read_src; + } + uint8_t t_0 = *b_rptr_src++; + v_bits |= (((uint32_t)(t_0)) << v_n_bits); + v_n_bits += 8; + } + v_hlit = (((v_bits) & ((1 << (5)) - 1)) + 257); + if (v_hlit > 286) { + status = PUFFS_FLATE_ERROR_BAD_LITERALLENGTH_CODE_COUNT; + goto suspend; + } + v_bits >>= 5; + v_hdist = (((v_bits) & ((1 << (5)) - 1)) + 1); + if (v_hdist > 30) { + status = PUFFS_FLATE_ERROR_BAD_DISTANCE_CODE_COUNT; + goto suspend; + } + v_bits >>= 5; + v_hclen = (((v_bits) & ((1 << (4)) - 1)) + 4); + v_bits >>= 4; + v_n_bits -= 14; + self->private_impl.f_wip0 = v_hlit; + self->private_impl.f_wip1 = v_hdist; + self->private_impl.f_wip2 = v_hclen; + self->private_impl.f_bits = v_bits; + self->private_impl.f_n_bits = v_n_bits; + coro_susp_point = 0; + } + + goto suspend; +suspend: + self->private_impl.c_decode_dynamic[0].coro_susp_point = coro_susp_point; + self->private_impl.c_decode_dynamic[0].v_bits = v_bits; + self->private_impl.c_decode_dynamic[0].v_n_bits = v_n_bits; + self->private_impl.c_decode_dynamic[0].v_hlit = v_hlit; + self->private_impl.c_decode_dynamic[0].v_hdist = v_hdist; + self->private_impl.c_decode_dynamic[0].v_hclen = v_hclen; + + if (a_src.buf) { + size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); + a_src.buf->ri += n; + puffs_base_limit1* lim; + for (lim = &a_src.limit; lim; lim = lim->next) { + if (lim->ptr_to_len) { + *lim->ptr_to_len -= n; + } + } + } + + goto exit; +exit: + self->private_impl.status = status; + return status; + +short_read_src: + status = ((a_src.buf->closed) && (a_src.buf->ri == a_src.buf->wi)) + ? PUFFS_FLATE_ERROR_UNEXPECTED_EOF + : PUFFS_FLATE_SUSPENSION_SHORT_READ; + goto suspend; +} diff --git a/gen/h/std/flate.h b/gen/h/std/flate.h index 29490d54..032bde64 100644 --- a/gen/h/std/flate.h +++ b/gen/h/std/flate.h @@ -100,13 +100,16 @@ typedef int32_t puffs_flate_status; #define PUFFS_FLATE_SUSPENSION_SHORT_WRITE 7 // 0x00000007 #define PUFFS_FLATE_ERROR_CLOSED_FOR_WRITES -2147483640 // 0x80000008 -#define PUFFS_FLATE_ERROR_BAD_FLATE_BLOCK -1157040128 // 0xbb08f800 +#define PUFFS_FLATE_ERROR_BAD_DISTANCE_CODE_COUNT -1157040128 // 0xbb08f800 +#define PUFFS_FLATE_ERROR_BAD_FLATE_BLOCK -1157040127 // 0xbb08f801 +#define PUFFS_FLATE_ERROR_BAD_LITERALLENGTH_CODE_COUNT \ + -1157040126 // 0xbb08f802 #define PUFFS_FLATE_ERROR_INCONSISTENT_STORED_BLOCK_LENGTH \ - -1157040127 // 0xbb08f801 + -1157040125 // 0xbb08f803 #define PUFFS_FLATE_ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS \ - -1157040126 // 0xbb08f802 -#define PUFFS_FLATE_ERROR_TODO_FIXED_HUFFMAN_BLOCKS -1157040125 // 0xbb08f803 -#define PUFFS_FLATE_ERROR_TODO_DYNAMIC_HUFFMAN_BLOCKS -1157040124 // 0xbb08f804 + -1157040124 // 0xbb08f804 +#define PUFFS_FLATE_ERROR_TODO_FIXED_HUFFMAN_BLOCKS -1157040123 // 0xbb08f805 +#define PUFFS_FLATE_ERROR_TODO_DYNAMIC_HUFFMAN_BLOCKS -1157040122 // 0xbb08f806 bool puffs_flate_status_is_error(puffs_flate_status s); @@ -129,6 +132,9 @@ typedef struct { uint32_t f_bits; uint32_t f_n_bits; + uint32_t f_wip0; + uint32_t f_wip1; + uint32_t f_wip2; struct { uint32_t coro_susp_point; @@ -139,6 +145,14 @@ typedef struct { uint32_t coro_susp_point; uint32_t v_n; } c_decode_uncompressed[1]; + struct { + uint32_t coro_susp_point; + uint32_t v_bits; + uint32_t v_n_bits; + uint32_t v_hlit; + uint32_t v_hdist; + uint32_t v_hclen; + } c_decode_dynamic[1]; } private_impl; } puffs_flate_decoder; @@ -166,6 +180,10 @@ puffs_flate_status puffs_flate_decoder_decode_uncompressed( puffs_base_writer1 a_dst, puffs_base_reader1 a_src); +puffs_flate_status puffs_flate_decoder_decode_dynamic(puffs_flate_decoder* self, + puffs_base_writer1 a_dst, + puffs_base_reader1 a_src); + #ifdef __cplusplus } // extern "C" #endif diff --git a/lang/check/bounds.go b/lang/check/bounds.go index 38b23569..505bd2b5 100644 --- a/lang/check/bounds.go +++ b/lang/check/bounds.go @@ -624,7 +624,7 @@ func (q *checker) bcheckExprOther(n *a.Expr, depth uint32) (*big.Int, *big.Int, isInDst(q.tm, n, t.KeyCopyFrom32, 2) || isThisMethod(q.tm, n, "decode_header", 1) || isThisMethod(q.tm, n, "decode_lsd", 1) || isThisMethod(q.tm, n, "decode_extension", 1) || isThisMethod(q.tm, n, "decode_id", 2) || - isThisMethod(q.tm, n, "decode_uncompressed", 2) { + isThisMethod(q.tm, n, "decode_uncompressed", 2) || isThisMethod(q.tm, n, "decode_dynamic", 2) { for _, o := range n.Args() { // TODO: check that the arg range at the caller and the diff --git a/lang/check/type.go b/lang/check/type.go index 8a6e1751..dcdd5ac2 100644 --- a/lang/check/type.go +++ b/lang/check/type.go @@ -342,7 +342,7 @@ func (q *checker) tcheckExprOther(n *a.Expr, depth uint32) error { isInDst(q.tm, n, t.KeyCopyFrom32, 2) || isThisMethod(q.tm, n, "decode_header", 1) || isThisMethod(q.tm, n, "decode_lsd", 1) || isThisMethod(q.tm, n, "decode_extension", 1) || isThisMethod(q.tm, n, "decode_id", 2) || - isThisMethod(q.tm, n, "decode_uncompressed", 2) { + isThisMethod(q.tm, n, "decode_uncompressed", 2) || isThisMethod(q.tm, n, "decode_dynamic", 2) { if err := q.tcheckExpr(n.LHS().Expr(), depth); err != nil { return err diff --git a/std/flate/decode_flate.puffs b/std/flate/decode_flate.puffs index df46e9eb..a667059f 100644 --- a/std/flate/decode_flate.puffs +++ b/std/flate/decode_flate.puffs @@ -5,7 +5,9 @@ packageid "flte" +pub error "bad distance code count" pub error "bad flate block" +pub error "bad literal/length code count" pub error "inconsistent stored block length" pub error "internal error: inconsistent n_bits" @@ -16,6 +18,11 @@ pub struct decoder?( // These fields yield src's bits in Least Significant Bits order. bits u32, n_bits u32, + + // These temporary fields are used to debug work-in-progress code. + wip0 u32, + wip1 u32, + wip2 u32, ) pub func decoder.decode?(dst writer1, src reader1)() { @@ -36,7 +43,7 @@ pub func decoder.decode?(dst writer1, src reader1)() { } else if type == 1 { return error "TODO: fixed Huffman blocks" } else if type == 2 { - return error "TODO: dynamic Huffman blocks" + this.decode_dynamic?(dst:in.dst, src:in.src) } else { return error "bad flate block" } @@ -59,3 +66,36 @@ pub func decoder.decode_uncompressed?(dst writer1, src reader1)() { } in.dst.copy_from32?(r:in.src, n:n.low_bits(n:16)) } + +// decode_dynamic decodes dynamic Huffman codes as per the RFC section 3.2.7. +pub func decoder.decode_dynamic?(dst writer1, src reader1)() { + var bits u32 = this.bits + var n_bits u32 = this.n_bits + while n_bits < 14, + post n_bits >= 14, + { + bits |= (in.src.read_u8?() as u32) << n_bits + n_bits += 8 + } + var hlit u32[257..288] = bits.low_bits(n:5) + 257 + if hlit > 286 { + return error "bad literal/length code count" + } + bits >>= 5 + var hdist u32[1..32] = bits.low_bits(n:5) + 1 + if hdist > 30 { + return error "bad distance code count" + } + bits >>= 5 + var hclen u32[4..19] = bits.low_bits(n:4) + 4 + bits >>= 4 + n_bits -= 14 + + // TODO: implement. + this.wip0 = hlit + this.wip1 = hdist + this.wip2 = hclen + + this.bits = bits + this.n_bits = n_bits +} diff --git a/test/c/std/flate.c b/test/c/std/flate.c index 63cb7d67..1e3cffc3 100644 --- a/test/c/std/flate.c +++ b/test/c/std/flate.c @@ -197,6 +197,51 @@ void test_puffs_flate_decode_split_src() { } } +// test_puffs_flate_work_in_progress is a temporary test harness used while the +// std/flate decoder is a work in progress. +void test_puffs_flate_work_in_progress() { + proc_funcname = __func__; + + puffs_base_buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + puffs_base_buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; + + golden_test* gt = &flate_romeo_gt; + if (!read_file(&src, gt->src_filename)) { + return; + } + src.ri = gt->src_offset0; + src.wi = gt->src_offset1; + + puffs_flate_decoder dec; + puffs_base_writer1 dst_writer = {.buf = &got}; + puffs_base_reader1 src_reader = {.buf = &src}; + + puffs_flate_decoder_constructor(&dec, PUFFS_VERSION, 0); + puffs_flate_status s = + puffs_flate_decoder_decode(&dec, dst_writer, src_reader); + puffs_flate_decoder_destructor(&dec); + + if (s != PUFFS_FLATE_STATUS_OK) { + FAIL("status: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", s, + puffs_flate_status_string(s), PUFFS_FLATE_STATUS_OK, + puffs_flate_status_string(PUFFS_FLATE_STATUS_OK)); + return; + } + + if (dec.private_impl.f_wip0 != 266) { + FAIL("wip0: got %" PRIu32 ", want %" PRIu32, dec.private_impl.f_wip0, 266); + return; + } + if (dec.private_impl.f_wip1 != 20) { + FAIL("wip1: got %" PRIu32 ", want %" PRIu32, dec.private_impl.f_wip1, 20); + return; + } + if (dec.private_impl.f_wip2 != 14) { + FAIL("wip2: got %" PRIu32 ", want %" PRIu32, dec.private_impl.f_wip2, 14); + return; + } +} + // ---------------- Mimic Tests #ifdef PUFFS_MIMIC @@ -335,6 +380,7 @@ proc tests[] = { test_puffs_flate_decode_romeo, // */ test_puffs_flate_decode_split_src, // + test_puffs_flate_work_in_progress, // #ifdef PUFFS_MIMIC