From 6a34375cb354a2e439f6d787af6fe09f99dc6ac2 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Fri, 7 Jul 2017 15:08:40 +1000 Subject: [PATCH] Decode flate stored blocks. --- cmd/puffs-gen-c/func.go | 42 ++++++ gen/c/std/flate.c | 276 ++++++++++++++++++++++++++++++++++- gen/h/std/flate.h | 23 +++ lang/check/bounds.go | 4 +- lang/check/type.go | 6 +- lang/token/list.go | 18 ++- std/flate/decode_flate.puffs | 58 +++++++- test/c/std/flate.c | 21 +++ test/testdata/256.bytes | Bin 0 -> 256 bytes test/testdata/256.bytes.gz | Bin 0 -> 289 bytes test/testdata/README.md | 2 + 11 files changed, 438 insertions(+), 12 deletions(-) create mode 100644 test/testdata/256.bytes create mode 100644 test/testdata/256.bytes.gz diff --git a/cmd/puffs-gen-c/func.go b/cmd/puffs-gen-c/func.go index d23995d5..f8c85286 100644 --- a/cmd/puffs-gen-c/func.go +++ b/cmd/puffs-gen-c/func.go @@ -872,6 +872,40 @@ func (g *gen) writeCallSuspendibles(n *a.Expr, depth uint32) error { } g.writes(";\n") + } else if isInDst(g.tm, n, t.KeyCopyFrom32, 2) { + if g.perFunc.tempW > maxTemp { + return fmt.Errorf("too many temporary variables required") + } + temp := g.perFunc.tempW + g.perFunc.tempW++ + g.perFunc.tempR++ + + g.writes("{\n") + + g.printf("size_t %s%d = ", tPrefix, temp) + x := n.Args()[1].Arg().Value() + if err := g.writeExpr(x, replaceCallSuspendibles, parenthesesMandatory, depth); err != nil { + return err + } + g.writes(";\n") + + const wName = "dst" + g.printf("if (%s%d > %swend_%s - %swptr_%s) {\n", tPrefix, temp, bPrefix, wName, bPrefix, wName) + // TODO: suspend; return SHORT_WRITE. + g.writes("}\n") + + // TODO: don't assume that the first argument is "in.src". + const rName = "src" + g.printf("if (%s%d > %srend_%s - %srptr_%s) {\n", tPrefix, temp, bPrefix, rName, bPrefix, rName) + // TODO: suspend; return SHORT_READ. + g.writes("}\n") + + g.printf("memmove(%swptr_%s, %srptr_%s, %s%d);\n", bPrefix, wName, bPrefix, rName, tPrefix, temp) + g.printf("%swptr_%s += %s%d;\n", bPrefix, wName, tPrefix, temp) + g.printf("%srptr_%s += %s%d;\n", bPrefix, rName, tPrefix, temp) + + g.writes("}\n") + } else if isThisMethod(g.tm, n, "decode_header", 1) { g.printf("status = puffs_%s_%s_decode_header(self, %ssrc);\n", g.pkgName, g.perFunc.funk.Receiver().String(g.tm), aPrefix) @@ -904,6 +938,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_uncompressed", 2) { + g.printf("status = puffs_%s_%s_decode_uncompressed(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 4d732a10..2b700a16 100644 --- a/gen/c/std/flate.c +++ b/gen/c/std/flate.c @@ -100,6 +100,14 @@ typedef int32_t puffs_flate_status; #define PUFFS_FLATE_STATUS_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_INCONSISTENT_STORED_BLOCK_LENGTH \ + -1157040127 // 0xbb08f801 +#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 + bool puffs_flate_status_is_error(puffs_flate_status s); const char* puffs_flate_status_string(puffs_flate_status s); @@ -117,10 +125,20 @@ typedef struct { struct { puffs_flate_status status; uint32_t magic; + uint32_t f_bits; + uint32_t f_n_bits; struct { uint32_t coro_state; + uint32_t v_final; + uint32_t v_type; } c_decode[1]; + struct { + uint32_t coro_state; + uint8_t v_n0; + uint8_t v_n1; + uint8_t v_complement; + } c_decode_uncompressed[1]; } private_impl; } puffs_flate_decoder; @@ -143,6 +161,11 @@ puffs_flate_status puffs_flate_decoder_decode(puffs_flate_decoder* self, puffs_base_writer1 a_dst, puffs_base_reader1 a_src); +puffs_flate_status puffs_flate_decoder_decode_uncompressed( + puffs_flate_decoder* self, + puffs_base_writer1 a_dst, + puffs_base_reader1 a_src); + #ifdef __cplusplus } // extern "C" #endif @@ -197,7 +220,13 @@ const char* puffs_flate_status_strings0[9] = { "flate: closed for writes", }; -const char* puffs_flate_status_strings1[0] = {}; +const char* puffs_flate_status_strings1[5] = { + "flate: bad flate block", + "flate: inconsistent stored block length", + "flate: internal error: inconsistent n_bits", + "flate: TODO: fixed Huffman blocks", + "flate: TODO: dynamic Huffman blocks", +}; const char* puffs_flate_status_string(puffs_flate_status s) { const char** a = NULL; @@ -209,7 +238,7 @@ const char* puffs_flate_status_string(puffs_flate_status s) { break; case puffs_flate_packageid: a = puffs_flate_status_strings1; - n = 0; + n = 5; break; } uint32_t i = s & 0xff; @@ -275,21 +304,264 @@ puffs_flate_status puffs_flate_decoder_decode(puffs_flate_decoder* self, goto exit; } + uint32_t v_final; + uint32_t v_type; + + 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_state = self->private_impl.c_decode[0].coro_state; if (coro_state) { + v_final = self->private_impl.c_decode[0].v_final; + v_type = self->private_impl.c_decode[0].v_type; } switch (coro_state) { PUFFS_COROUTINE_STATE(0); + while (true) { + while (self->private_impl.f_n_bits < 3) { + PUFFS_COROUTINE_STATE(1); + if (PUFFS_UNLIKELY(b_rptr_src == b_rend_src)) { + goto short_read_src; + } + uint8_t t_0 = *b_rptr_src++; + self->private_impl.f_bits |= + (((uint32_t)(t_0)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8; + } + v_final = (self->private_impl.f_bits & 1); + v_type = ((self->private_impl.f_bits >> 1) & 3); + self->private_impl.f_bits >>= 3; + self->private_impl.f_n_bits -= 3; + if (v_type == 0) { + PUFFS_COROUTINE_STATE(2); + 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_uncompressed(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 if (v_type == 1) { + 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; + } else { + status = PUFFS_FLATE_ERROR_BAD_FLATE_BLOCK; + goto suspend; + } + if (v_final != 0) { + status = PUFFS_FLATE_STATUS_OK; + goto suspend; + } + } coro_state = 0; } goto suspend; suspend: self->private_impl.c_decode[0].coro_state = coro_state; + self->private_impl.c_decode[0].v_final = v_final; + self->private_impl.c_decode[0].v_type = v_type; + + 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_STATUS_SHORT_READ; + goto suspend; +} + +puffs_flate_status puffs_flate_decoder_decode_uncompressed( + puffs_flate_decoder* self, + puffs_base_writer1 a_dst, + puffs_base_reader1 a_src) { + if (!self) { + return PUFFS_FLATE_ERROR_BAD_RECEIVER; + } + puffs_flate_status status = self->private_impl.status; + if (status < 0) { + return status; + } + if (self->private_impl.magic != PUFFS_MAGIC) { + status = PUFFS_FLATE_ERROR_CONSTRUCTOR_NOT_CALLED; + goto exit; + } + + uint8_t v_n0; + uint8_t v_n1; + uint8_t v_complement; + + uint8_t* b_wptr_dst = NULL; + uint8_t* b_wend_dst = NULL; + if (a_dst.buf) { + b_wptr_dst = a_dst.buf->ptr + a_dst.buf->wi; + size_t len = a_dst.buf->len - a_dst.buf->wi; + puffs_base_limit1* lim; + for (lim = &a_dst.limit; lim; lim = lim->next) { + if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { + len = *lim->ptr_to_len; + } + } + b_wend_dst = b_wptr_dst + len; + } + 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_state = self->private_impl.c_decode_uncompressed[0].coro_state; + if (coro_state) { + v_n0 = self->private_impl.c_decode_uncompressed[0].v_n0; + v_n1 = self->private_impl.c_decode_uncompressed[0].v_n1; + v_complement = self->private_impl.c_decode_uncompressed[0].v_complement; + } + switch (coro_state) { + PUFFS_COROUTINE_STATE(0); + + if (self->private_impl.f_n_bits >= 8) { + status = PUFFS_FLATE_ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS; + goto suspend; + } + self->private_impl.f_n_bits = 0; + PUFFS_COROUTINE_STATE(1); + if (PUFFS_UNLIKELY(b_rptr_src == b_rend_src)) { + goto short_read_src; + } + uint8_t t_0 = *b_rptr_src++; + v_n0 = t_0; + PUFFS_COROUTINE_STATE(2); + if (PUFFS_UNLIKELY(b_rptr_src == b_rend_src)) { + goto short_read_src; + } + uint8_t t_1 = *b_rptr_src++; + v_n1 = t_1; + v_complement = 0; + PUFFS_COROUTINE_STATE(3); + if (PUFFS_UNLIKELY(b_rptr_src == b_rend_src)) { + goto short_read_src; + } + uint8_t t_2 = *b_rptr_src++; + v_complement = t_2; + if ((255 - v_complement) != v_n0) { + status = PUFFS_FLATE_ERROR_INCONSISTENT_STORED_BLOCK_LENGTH; + goto suspend; + } + PUFFS_COROUTINE_STATE(4); + if (PUFFS_UNLIKELY(b_rptr_src == b_rend_src)) { + goto short_read_src; + } + uint8_t t_3 = *b_rptr_src++; + v_complement = t_3; + if ((255 - v_complement) != v_n1) { + status = PUFFS_FLATE_ERROR_INCONSISTENT_STORED_BLOCK_LENGTH; + goto suspend; + } + PUFFS_COROUTINE_STATE(5); + { + size_t t_4 = ((((uint32_t)(v_n1)) << 8) | ((uint32_t)(v_n0))); + if (t_4 > b_wend_dst - b_wptr_dst) { + } + if (t_4 > b_rend_src - b_rptr_src) { + } + memmove(b_wptr_dst, b_rptr_src, t_4); + b_wptr_dst += t_4; + b_rptr_src += t_4; + } + coro_state = 0; + } + + goto suspend; +suspend: + self->private_impl.c_decode_uncompressed[0].coro_state = coro_state; + self->private_impl.c_decode_uncompressed[0].v_n0 = v_n0; + self->private_impl.c_decode_uncompressed[0].v_n1 = v_n1; + self->private_impl.c_decode_uncompressed[0].v_complement = v_complement; + + if (a_dst.buf) { + size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); + a_dst.buf->wi += n; + puffs_base_limit1* lim; + for (lim = &a_dst.limit; lim; lim = lim->next) { + if (lim->ptr_to_len) { + *lim->ptr_to_len -= n; + } + } + } + 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_STATUS_SHORT_READ; + goto suspend; } diff --git a/gen/h/std/flate.h b/gen/h/std/flate.h index afde1b8f..6d66a52f 100644 --- a/gen/h/std/flate.h +++ b/gen/h/std/flate.h @@ -100,6 +100,14 @@ typedef int32_t puffs_flate_status; #define PUFFS_FLATE_STATUS_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_INCONSISTENT_STORED_BLOCK_LENGTH \ + -1157040127 // 0xbb08f801 +#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 + bool puffs_flate_status_is_error(puffs_flate_status s); const char* puffs_flate_status_string(puffs_flate_status s); @@ -117,10 +125,20 @@ typedef struct { struct { puffs_flate_status status; uint32_t magic; + uint32_t f_bits; + uint32_t f_n_bits; struct { uint32_t coro_state; + uint32_t v_final; + uint32_t v_type; } c_decode[1]; + struct { + uint32_t coro_state; + uint8_t v_n0; + uint8_t v_n1; + uint8_t v_complement; + } c_decode_uncompressed[1]; } private_impl; } puffs_flate_decoder; @@ -143,6 +161,11 @@ puffs_flate_status puffs_flate_decoder_decode(puffs_flate_decoder* self, puffs_base_writer1 a_dst, puffs_base_reader1 a_src); +puffs_flate_status puffs_flate_decoder_decode_uncompressed( + 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 fac9b9fb..919d07eb 100644 --- a/lang/check/bounds.go +++ b/lang/check/bounds.go @@ -620,8 +620,10 @@ func (q *checker) bcheckExprOther(n *a.Expr, depth uint32) (*big.Int, *big.Int, // TODO: delete this hack that only matches "in.src.read_u8?()" etc. if isInSrc(q.tm, n, t.KeyReadU8, 0) || isInSrc(q.tm, n, t.KeySkip32, 1) || isInDst(q.tm, n, t.KeyWrite, 1) || isInDst(q.tm, n, t.KeyWriteU8, 1) || + 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_extension", 1) || isThisMethod(q.tm, n, "decode_id", 2) || + isThisMethod(q.tm, n, "decode_uncompressed", 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 78a2bb5d..23d87a4e 100644 --- a/lang/check/type.go +++ b/lang/check/type.go @@ -236,7 +236,7 @@ func (q *checker) tcheckAssign(n *a.Assign) error { switch n.Operator().Key() { case t.KeyShiftLEq, t.KeyShiftREq: - if rTyp.IsNumType() { + if rTyp.IsNumTypeOrIdeal() { return nil } return fmt.Errorf("check: assignment %q: shift %q, of type %q, does not have numeric type", @@ -338,8 +338,10 @@ func (q *checker) tcheckExprOther(n *a.Expr, depth uint32) error { // TODO: delete this hack that only matches "in.src.read_u8?()" etc. if isInSrc(q.tm, n, t.KeyReadU8, 0) || isInSrc(q.tm, n, t.KeySkip32, 1) || isInDst(q.tm, n, t.KeyWrite, 1) || isInDst(q.tm, n, t.KeyWriteU8, 1) || + 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_extension", 1) || isThisMethod(q.tm, n, "decode_id", 2) || + isThisMethod(q.tm, n, "decode_uncompressed", 2) { if err := q.tcheckExpr(n.LHS().Expr(), depth); err != nil { return err diff --git a/lang/token/list.go b/lang/token/list.go index 4cedd5f6..f15bdf42 100644 --- a/lang/token/list.go +++ b/lang/token/list.go @@ -254,8 +254,10 @@ const ( KeyWriteU64BE = Key(IDWriteU64BE >> KeyShift) KeyWriteU64LE = Key(IDWriteU64LE >> KeyShift) - KeySkip32 = Key(IDSkip32 >> KeyShift) - KeySkip64 = Key(IDSkip64 >> KeyShift) + KeyCopyFrom32 = Key(IDCopyFrom32 >> KeyShift) + KeyCopyFrom64 = Key(IDCopyFrom64 >> KeyShift) + KeySkip32 = Key(IDSkip32 >> KeyShift) + KeySkip64 = Key(IDSkip64 >> KeyShift) KeyXUnaryPlus = Key(IDXUnaryPlus >> KeyShift) KeyXUnaryMinus = Key(IDXUnaryMinus >> KeyShift) @@ -413,8 +415,10 @@ const ( IDWriteU64BE = ID(0xBE<= 3, + { + this.bits |= (in.src.read_u8?() as u32) << this.n_bits + this.n_bits += 8 + } + var final u32 = this.bits & 0x01 + var type u32 = (this.bits >> 1) & 0x03 + this.bits >>= 3 + this.n_bits -= 3 + + if type == 0 { + this.decode_uncompressed?(dst:in.dst, src:in.src) + } else if type == 1 { + return error "TODO: fixed Huffman blocks" + } else if type == 2 { + return error "TODO: dynamic Huffman blocks" + } else { + return error "bad flate block" + } + + if final != 0 { + return + } + } +} + +pub func decoder.decode_uncompressed?(dst writer1, src reader1)() { + if this.n_bits >= 8 { + return error "internal error: inconsistent n_bits" + } + this.n_bits = 0 + + // TODO: a read_u16le method. + var n0 u8 = in.src.read_u8?() + var n1 u8 = in.src.read_u8?() + var complement u8 + complement = in.src.read_u8?() + if (0xFF - complement) != n0 { + return error "inconsistent stored block length" + } + complement = in.src.read_u8?() + if (0xFF - complement) != n1 { + return error "inconsistent stored block length" + } + in.dst.copy_from32?(r:in.src, n:((n1 as u32) << 8) | (n0 as u32)) } diff --git a/test/c/std/flate.c b/test/c/std/flate.c index 9b49e831..425ad26e 100644 --- a/test/c/std/flate.c +++ b/test/c/std/flate.c @@ -39,6 +39,13 @@ const char* proc_filename = "std/flate.c"; // // The empty comments forces clang-format to place one element per line. +golden_test two_five_six_gt = { + .want_filename = "../../testdata/256.bytes", // + .src_filename = "../../testdata/256.bytes.gz", // + .src_offset0 = 20, // + .src_offset1 = 281, // +}; + golden_test midsummer_gt = { .want_filename = "../../testdata/midsummer.txt", // .src_filename = "../../testdata/midsummer.txt.gz", // @@ -76,6 +83,11 @@ const char* puffs_flate_decode(puffs_base_buf1* dst, puffs_base_buf1* src) { return NULL; } +void test_puffs_flate_decode_256_bytes() { + proc_funcname = __func__; + test_buf1_buf1(puffs_flate_decode, &two_five_six_gt); +} + void test_puffs_flate_decode_midsummer() { proc_funcname = __func__; test_buf1_buf1(puffs_flate_decode, &midsummer_gt); @@ -97,6 +109,11 @@ void test_puffs_flate_decode_romeo() { #include "../mimiclib/flate.c" +void test_mimic_flate_decode_256_bytes() { + proc_funcname = __func__; + test_buf1_buf1(mimic_flate_decode, &two_five_six_gt); +} + void test_mimic_flate_decode_midsummer() { proc_funcname = __func__; test_buf1_buf1(mimic_flate_decode, &midsummer_gt); @@ -157,6 +174,7 @@ void bench_mimic_flate_decode_100k() { // The empty comments forces clang-format to place one element per line. proc tests[] = { // Flate Tests + test_puffs_flate_decode_256_bytes, // /* TODO: implement puffs_flate, then uncomment these. test_puffs_flate_decode_midsummer, // test_puffs_flate_decode_pi, // @@ -166,6 +184,7 @@ proc tests[] = { #ifdef PUFFS_MIMIC // Mimic Tests + test_mimic_flate_decode_256_bytes, // test_mimic_flate_decode_midsummer, // test_mimic_flate_decode_pi, // test_mimic_flate_decode_romeo, // @@ -178,9 +197,11 @@ proc tests[] = { // The empty comments forces clang-format to place one element per line. proc benches[] = { // Flate Benches + /* TODO: implement puffs_flate, then uncomment these. bench_puffs_flate_decode_1k, // bench_puffs_flate_decode_10k, // bench_puffs_flate_decode_100k, // + */ #ifdef PUFFS_MIMIC diff --git a/test/testdata/256.bytes b/test/testdata/256.bytes new file mode 100644 index 0000000000000000000000000000000000000000..c86626638e0bc8cf47ca49bb1525b40e9737ee64 GIT binary patch literal 256 zcmZQzWMXDvWn<^yMC+6cQE@6%&_`l#-T_m6KOcR8m$^Ra4i{)Y8_`)zddH zG%_|ZH8Z!cw6eCbwX=6{baHlab#wRd^z!!c_45x13RUz zF>}`JIdkXDU$Ah|;w4L$Enl&6)#^2C*R9{Mant54TeofBv2)k%J$v`!O_Xt#nsK-!_&*# z$Jft4ATTI6Bs45MA~GsECN?fUAu%aAB{eNQBQq;ICpRy@ps=X8q_nKOqOz*GrnauW zp|PpCrM0cSqqD2Kr?;. The *.giflzw files were generated by script/extract-giflzw.go and the *.palette and *.indexes files were generated