From 1388f84e5cc1fab6b8bf15cbdda069f5187aec98 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Mon, 4 Dec 2017 10:27:48 +1100 Subject: [PATCH] Rename std/flate to std/deflate --- cmd/wuffs-c/internal/cgen/base-impl.h | 6 +- cmd/wuffs-c/internal/cgen/data.go | 10 +- cmd/wuffs-c/internal/cgen/expr.go | 6 +- cmd/wuffs-c/internal/cgen/statement.go | 4 +- doc/benchmarks.md | 6 +- gen/c/std/{flate.c => deflate.c} | 484 +++++++++--------- gen/c/std/gif.c | 6 +- gen/c/std/zlib.c | 120 ++--- gen/h/std/{flate.h => deflate.h} | 104 ++-- gen/h/std/zlib.h | 110 ++-- lang/check/type.go | 4 +- std/{flate => deflate}/README.md | 0 std/{flate => deflate}/codec_consts.wuffs | 0 .../decode_deflate.wuffs} | 2 - .../decode_huffman_fast.wuffs | 0 .../decode_huffman_slow.wuffs | 0 std/zlib/decode_zlib.wuffs | 4 +- test/c/mimiclib/deflate-gzip-zlib.c | 16 +- test/c/std/{flate.c => deflate.c} | 277 +++++----- test/c/std/zlib.c | 2 +- 20 files changed, 590 insertions(+), 571 deletions(-) rename gen/c/std/{flate.c => deflate.c} (84%) rename gen/h/std/{flate.h => deflate.h} (68%) rename std/{flate => deflate}/README.md (100%) rename std/{flate => deflate}/codec_consts.wuffs (100%) rename std/{flate/decode_flate.wuffs => deflate/decode_deflate.wuffs} (99%) rename std/{flate => deflate}/decode_huffman_fast.wuffs (100%) rename std/{flate => deflate}/decode_huffman_slow.wuffs (100%) rename test/c/std/{flate.c => deflate.c} (68%) diff --git a/cmd/wuffs-c/internal/cgen/base-impl.h b/cmd/wuffs-c/internal/cgen/base-impl.h index 4b929ca1..21253a92 100644 --- a/cmd/wuffs-c/internal/cgen/base-impl.h +++ b/cmd/wuffs-c/internal/cgen/base-impl.h @@ -197,9 +197,9 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32( } else { n = length; } - // TODO: unrolling by 3 seems best for the std/flate benchmarks, but that is - // mostly because 3 is the minimum length for the flate format. This function - // implementation shouldn't overfit to that one format. Perhaps the + // TODO: unrolling by 3 seems best for the std/deflate benchmarks, but that + // is mostly because 3 is the minimum length for the deflate format. This + // function implementation shouldn't overfit to that one format. Perhaps the // copy_from_history32 Wuffs method should also take an unroll hint argument, // and the cgen can look if that argument is the constant expression '3'. // diff --git a/cmd/wuffs-c/internal/cgen/data.go b/cmd/wuffs-c/internal/cgen/data.go index 3832255f..7239db67 100644 --- a/cmd/wuffs-c/internal/cgen/data.go +++ b/cmd/wuffs-c/internal/cgen/data.go @@ -30,11 +30,11 @@ const baseImpl = "" + "nts\n// can be an expression that we shouldn't evaluate more than once.\n//\n// They are in base-impl.h and hence copy/pasted into every generated C file,\n// instead of being in some \"base.c\" file, since a design goal is that users of\n// the generated C code can often just #include a single .c file, such as\n// \"gif.c\", without having to additionally include or otherwise build and link\n// a \"base.c\" file.\n//\n// They are static, so that linking multiple wuffs .o files won't complain about\n// duplicate function definitions.\n//\n// They are explicitly marked inline, even if modern compilers don't use the\n// inline attribute to guide optimizations such as inlining, to avoid the\n// -Wunused-function warning, and we like to compile with -Wall -Werror.\n\nstatic inline uint16_t wuffs_base__load_u16be(uint8_t* p) {\n return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0);\n}\n\nstatic inline uint16_t wuffs_base__load_u16le(uint8_t* p) {\n return ((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8);\n}\n\nstatic inline uint32_t wuf" + "fs_base__load_u32be(uint8_t* p) {\n return ((uint32_t)(p[0]) << 24) | ((uint32_t)(p[1]) << 16) |\n ((uint32_t)(p[2]) << 8) | ((uint32_t)(p[3]) << 0);\n}\n\nstatic inline uint32_t wuffs_base__load_u32le(uint8_t* p) {\n return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24);\n}\n\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i(\n wuffs_base__slice_u8 s,\n uint64_t i) {\n if ((i <= SIZE_MAX) && (i <= s.len)) {\n return ((wuffs_base__slice_u8){\n .ptr = s.ptr + i,\n .len = s.len - i,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_j(\n wuffs_base__slice_u8 s,\n uint64_t j) {\n if ((j <= SIZE_MAX) && (j <= s.len)) {\n return ((wuffs_base__slice_u8){.ptr = s.ptr, .len = j});\n }\n return ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_ij(\n wuffs_base__slice_u8 s,\n uint64_t i,\n uin" + "t64_t j) {\n if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) {\n return ((wuffs_base__slice_u8){\n .ptr = s.ptr + i,\n .len = j - i,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\n// wuffs_base__slice_u8__prefix returns up to the first up_to bytes of s.\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__prefix(\n wuffs_base__slice_u8 s,\n uint64_t up_to) {\n if ((uint64_t)(s.len) > up_to) {\n s.len = up_to;\n }\n return s;\n}\n\n// wuffs_base__slice_u8__suffix returns up to the last up_to bytes of s.\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8_suffix(\n wuffs_base__slice_u8 s,\n uint64_t up_to) {\n if ((uint64_t)(s.len) > up_to) {\n s.ptr += (uint64_t)(s.len) - up_to;\n s.len = up_to;\n }\n return s;\n}\n\n// wuffs_base__slice_u8__copy_from_slice calls memmove(dst.ptr, src.ptr,\n// length) where length is the minimum of dst.len and src.len.\n//\n// Passing a wuffs_base__slice_u8 with all fields NULL or zero (a valid, empty\n// slice) is valid and results in a no-op.\ns" + - "tatic inline uint64_t wuffs_base__slice_u8__copy_from_slice(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src) {\n size_t length = dst.len < src.len ? dst.len : src.len;\n if (length > 0) {\n memmove(dst.ptr, src.ptr, length);\n }\n return length;\n}\n\nstatic inline uint32_t wuffs_base__writer1__copy_from_history32(\n uint8_t** ptr_ptr,\n uint8_t* start, // May be NULL, meaning an unmarked writer1.\n uint8_t* end,\n uint32_t distance,\n uint32_t length) {\n if (!start || !distance) {\n return 0;\n }\n uint8_t* ptr = *ptr_ptr;\n if ((size_t)(ptr - start) < (size_t)(distance)) {\n return 0;\n }\n start = ptr - distance;\n size_t n = end - ptr;\n if ((size_t)(length) > n) {\n length = n;\n } else {\n n = length;\n }\n // TODO: unrolling by 3 seems best for the std/flate benchmarks, but that is\n // mostly because 3 is the minimum length for the flate format. This function\n // implementation shouldn't overfit to that one format. Perhaps the\n // copy_from_history32 Wuffs method shoul" + - "d also take an unroll hint argument,\n // and the cgen can look if that argument is the constant expression '3'.\n //\n // See also wuffs_base__writer1__copy_from_history32__bco below.\n //\n // Alternatively, or additionally, have a sloppy_copy_from_history32 method\n // that copies 8 bytes at a time, possibly writing more than length bytes?\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\n// wuffs_base__writer1__copy_from_history32__bco is a Bounds Check Optimized\n// version of the wuffs_base__writer1__copy_from_history32 function above. The\n// caller needs to prove that:\n// - start != NULL\n// - distance != 0\n// - distance <= (*ptr_ptr - start)\n// - length <= (end - *ptr_ptr)\nstatic inline uint32_t wuffs_base__writer1__copy_from_history32__bco(\n uint8_t** ptr_ptr,\n uint8_t* start,\n uint8_t* end,\n uint32_t distance,\n uint32_t length) {\n uint8_t* " + - "ptr = *ptr_ptr;\n start = ptr - distance;\n uint32_t n = length;\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\nstatic inline uint32_t wuffs_base__writer1__copy_from_reader32(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n uint8_t** ptr_rptr,\n uint8_t* rend,\n uint32_t length) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = length;\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n uint8_t* rptr = *ptr_rptr;\n if (n > rend - rptr) {\n n = rend - rptr;\n }\n if (n > 0) {\n memmove(wptr, rptr, n);\n *ptr_wptr += n;\n *ptr_rptr += n;\n }\n return n;\n}\n\nstatic inline uint64_t wuffs_base__writer1__copy_from_slice(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n wuffs_base__slice_u8 src) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = src.len;\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n if (n > 0) {\n memmove(wptr, src.ptr, n);\n *ptr_wptr += n;\n }\n return n;\n}\n" + - "\nstatic inline uint32_t wuffs_base__writer1__copy_from_slice32(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n wuffs_base__slice_u8 src,\n uint32_t length) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = src.len;\n if (n > length) {\n n = length;\n }\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n if (n > 0) {\n memmove(wptr, src.ptr, n);\n *ptr_wptr += n;\n }\n return n;\n}\n\n// Note that the *__limit and *__mark methods are private (in base-impl.h) not\n// public (in base-header.h). We assume that, at the boundary between user code\n// and Wuffs code, the reader1 and writer1's private_impl fields (including\n// limit and mark) are NULL. Otherwise, some internal assumptions break down.\n// For example, limits could be represented as pointers, even though\n// conceptually they are counts, but that pointer-to-count correspondence\n// becomes invalid if a buffer is re-used (e.g. on resuming a coroutine).\n//\n// Admittedly, some of the Wuffs test code calls these methods, but that test\n// code is still Wuffs code" + - ", not user code. Other Wuffs test code modifies\n// private_impl fields directly.\n\nstatic inline wuffs_base__reader1 wuffs_base__reader1__limit(\n wuffs_base__reader1* o,\n uint64_t* ptr_to_len) {\n wuffs_base__reader1 ret = *o;\n ret.private_impl.limit.ptr_to_len = ptr_to_len;\n ret.private_impl.limit.next = &o->private_impl.limit;\n return ret;\n}\n\nstatic inline wuffs_base__empty_struct wuffs_base__reader1__mark(\n wuffs_base__reader1* o,\n uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n\n// TODO: static inline wuffs_base__writer1 wuffs_base__writer1__limit()\n\nstatic inline wuffs_base__empty_struct wuffs_base__writer1__mark(\n wuffs_base__writer1* o,\n uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n\n#endif // WUFFS_BASE_IMPL_H\n" + + "tatic inline uint64_t wuffs_base__slice_u8__copy_from_slice(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src) {\n size_t length = dst.len < src.len ? dst.len : src.len;\n if (length > 0) {\n memmove(dst.ptr, src.ptr, length);\n }\n return length;\n}\n\nstatic inline uint32_t wuffs_base__writer1__copy_from_history32(\n uint8_t** ptr_ptr,\n uint8_t* start, // May be NULL, meaning an unmarked writer1.\n uint8_t* end,\n uint32_t distance,\n uint32_t length) {\n if (!start || !distance) {\n return 0;\n }\n uint8_t* ptr = *ptr_ptr;\n if ((size_t)(ptr - start) < (size_t)(distance)) {\n return 0;\n }\n start = ptr - distance;\n size_t n = end - ptr;\n if ((size_t)(length) > n) {\n length = n;\n } else {\n n = length;\n }\n // TODO: unrolling by 3 seems best for the std/deflate benchmarks, but that\n // is mostly because 3 is the minimum length for the deflate format. This\n // function implementation shouldn't overfit to that one format. Perhaps the\n // copy_from_history32 Wuffs method s" + + "hould also take an unroll hint argument,\n // and the cgen can look if that argument is the constant expression '3'.\n //\n // See also wuffs_base__writer1__copy_from_history32__bco below.\n //\n // Alternatively, or additionally, have a sloppy_copy_from_history32 method\n // that copies 8 bytes at a time, possibly writing more than length bytes?\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\n// wuffs_base__writer1__copy_from_history32__bco is a Bounds Check Optimized\n// version of the wuffs_base__writer1__copy_from_history32 function above. The\n// caller needs to prove that:\n// - start != NULL\n// - distance != 0\n// - distance <= (*ptr_ptr - start)\n// - length <= (end - *ptr_ptr)\nstatic inline uint32_t wuffs_base__writer1__copy_from_history32__bco(\n uint8_t** ptr_ptr,\n uint8_t* start,\n uint8_t* end,\n uint32_t distance,\n uint32_t length) {\n uint8" + + "_t* ptr = *ptr_ptr;\n start = ptr - distance;\n uint32_t n = length;\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\nstatic inline uint32_t wuffs_base__writer1__copy_from_reader32(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n uint8_t** ptr_rptr,\n uint8_t* rend,\n uint32_t length) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = length;\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n uint8_t* rptr = *ptr_rptr;\n if (n > rend - rptr) {\n n = rend - rptr;\n }\n if (n > 0) {\n memmove(wptr, rptr, n);\n *ptr_wptr += n;\n *ptr_rptr += n;\n }\n return n;\n}\n\nstatic inline uint64_t wuffs_base__writer1__copy_from_slice(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n wuffs_base__slice_u8 src) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = src.len;\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n if (n > 0) {\n memmove(wptr, src.ptr, n);\n *ptr_wptr += n;\n }\n return n" + + ";\n}\n\nstatic inline uint32_t wuffs_base__writer1__copy_from_slice32(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n wuffs_base__slice_u8 src,\n uint32_t length) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = src.len;\n if (n > length) {\n n = length;\n }\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n if (n > 0) {\n memmove(wptr, src.ptr, n);\n *ptr_wptr += n;\n }\n return n;\n}\n\n// Note that the *__limit and *__mark methods are private (in base-impl.h) not\n// public (in base-header.h). We assume that, at the boundary between user code\n// and Wuffs code, the reader1 and writer1's private_impl fields (including\n// limit and mark) are NULL. Otherwise, some internal assumptions break down.\n// For example, limits could be represented as pointers, even though\n// conceptually they are counts, but that pointer-to-count correspondence\n// becomes invalid if a buffer is re-used (e.g. on resuming a coroutine).\n//\n// Admittedly, some of the Wuffs test code calls these methods, but that test\n// code is still Wuffs " + + "code, not user code. Other Wuffs test code modifies\n// private_impl fields directly.\n\nstatic inline wuffs_base__reader1 wuffs_base__reader1__limit(\n wuffs_base__reader1* o,\n uint64_t* ptr_to_len) {\n wuffs_base__reader1 ret = *o;\n ret.private_impl.limit.ptr_to_len = ptr_to_len;\n ret.private_impl.limit.next = &o->private_impl.limit;\n return ret;\n}\n\nstatic inline wuffs_base__empty_struct wuffs_base__reader1__mark(\n wuffs_base__reader1* o,\n uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n\n// TODO: static inline wuffs_base__writer1 wuffs_base__writer1__limit()\n\nstatic inline wuffs_base__empty_struct wuffs_base__writer1__mark(\n wuffs_base__writer1* o,\n uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n\n#endif // WUFFS_BASE_IMPL_H\n" + "" type template_args_short_read struct { diff --git a/cmd/wuffs-c/internal/cgen/expr.go b/cmd/wuffs-c/internal/cgen/expr.go index afba53f7..3f7d7f9a 100644 --- a/cmd/wuffs-c/internal/cgen/expr.go +++ b/cmd/wuffs-c/internal/cgen/expr.go @@ -565,11 +565,11 @@ func (g *gen) writeCTypeName(b *buffer, n *a.TypeExpr, varNamePrefix string, var prefix := g.pkgPrefix if otherPkgID := innermost.Decorator(); otherPkgID != 0 { otherPkg := g.tm.ByID(otherPkgID) - // TODO: map the "flate" in "flate.decoder" to the "flate" in `use - // "std/flate"`, and use the latter "flate". + // TODO: map the "deflate" in "deflate.decoder" to the "deflate" in + // `use "std/deflate"`, and use the latter "deflate". // // This is pretty academic at the moment, since they're the same - // "flate", but in the future, we might be able to rename used + // "deflate", but in the future, we might be able to rename used // packages, e.g. `use "foo/bar" as "baz"`, so "baz.qux" would map // to generating "wuffs_bar__qux". // diff --git a/cmd/wuffs-c/internal/cgen/statement.go b/cmd/wuffs-c/internal/cgen/statement.go index 99b1b247..f6ca86f9 100644 --- a/cmd/wuffs-c/internal/cgen/statement.go +++ b/cmd/wuffs-c/internal/cgen/statement.go @@ -643,11 +643,11 @@ func (g *gen) writeCallSuspendibles(b *buffer, n *a.Expr, depth uint32) error { temp := g.currFunk.tempW g.currFunk.tempW++ - // TODO: don't hard-code the receiver being from the "flate" + // TODO: don't hard-code the receiver being from the "deflate" // package. // // TODO: don't hard-code a_dst or a_src. - b.printf("%sstatus %s%d = wuffs_flate__flate_decoder__decode("+ + b.printf("%sstatus %s%d = wuffs_deflate__flate_decoder__decode("+ "&self->private_impl.f_flate, %sdst, %ssrc);\n", g.pkgPrefix, tPrefix, temp, aPrefix, aPrefix) diff --git a/doc/benchmarks.md b/doc/benchmarks.md index 3354e2b0..743be819 100644 --- a/doc/benchmarks.md +++ b/doc/benchmarks.md @@ -24,11 +24,11 @@ bcheckOptimizeXxx methods." ## Reproducing The benchmark programs aim to be runnable "out of the box" without any -configuration or installation. For example, to run the `std/flate` benchmarks: +configuration or installation. For example, to run the `std/zlib` benchmarks: git clone https://github.com/google/wuffs.git cd wuffs/test/c/std - gcc -O3 flate.c + gcc -O3 zlib.c ./a.out -bench rm a.out @@ -75,7 +75,7 @@ power management can be controlled with: sudo cpupower frequency-set --governor performance -# Flate (including gzip and zlib) +# Deflate (including gzip and zlib) The 1k, 10k, etc. numbers are approximately how many bytes there in the decoded output. diff --git a/gen/c/std/flate.c b/gen/c/std/deflate.c similarity index 84% rename from gen/c/std/flate.c rename to gen/c/std/deflate.c index 56b51bfa..2b334b3e 100644 --- a/gen/c/std/flate.c +++ b/gen/c/std/deflate.c @@ -1,5 +1,5 @@ -#ifndef WUFFS_FLATE_H -#define WUFFS_FLATE_H +#ifndef WUFFS_DEFLATE_H +#define WUFFS_DEFLATE_H // Code generated by wuffs-c. DO NOT EDIT. @@ -122,55 +122,57 @@ extern "C" { // - bits 0-7 are a package-namespaced numeric code // // Do not manipulate these bits directly. Use the API functions such as -// wuffs_flate__status__is_error instead. -typedef int32_t wuffs_flate__status; +// wuffs_deflate__status__is_error instead. +typedef int32_t wuffs_deflate__status; -#define wuffs_flate__packageid 967230 // 0x000EC23E +#define wuffs_deflate__packageid 967230 // 0x000EC23E -#define WUFFS_FLATE__STATUS_OK 0 // 0x00000000 -#define WUFFS_FLATE__ERROR_BAD_WUFFS_VERSION -2147483647 // 0x80000001 -#define WUFFS_FLATE__ERROR_BAD_RECEIVER -2147483646 // 0x80000002 -#define WUFFS_FLATE__ERROR_BAD_ARGUMENT -2147483645 // 0x80000003 -#define WUFFS_FLATE__ERROR_INITIALIZER_NOT_CALLED -2147483644 // 0x80000004 -#define WUFFS_FLATE__ERROR_INVALID_I_O_OPERATION -2147483643 // 0x80000005 -#define WUFFS_FLATE__ERROR_CLOSED_FOR_WRITES -2147483642 // 0x80000006 -#define WUFFS_FLATE__ERROR_UNEXPECTED_EOF -2147483641 // 0x80000007 -#define WUFFS_FLATE__SUSPENSION_SHORT_READ 8 // 0x00000008 -#define WUFFS_FLATE__SUSPENSION_SHORT_WRITE 9 // 0x00000009 -#define WUFFS_FLATE__ERROR_CANNOT_RETURN_A_SUSPENSION -2147483638 // 0x8000000A +#define WUFFS_DEFLATE__STATUS_OK 0 // 0x00000000 +#define WUFFS_DEFLATE__ERROR_BAD_WUFFS_VERSION -2147483647 // 0x80000001 +#define WUFFS_DEFLATE__ERROR_BAD_RECEIVER -2147483646 // 0x80000002 +#define WUFFS_DEFLATE__ERROR_BAD_ARGUMENT -2147483645 // 0x80000003 +#define WUFFS_DEFLATE__ERROR_INITIALIZER_NOT_CALLED -2147483644 // 0x80000004 +#define WUFFS_DEFLATE__ERROR_INVALID_I_O_OPERATION -2147483643 // 0x80000005 +#define WUFFS_DEFLATE__ERROR_CLOSED_FOR_WRITES -2147483642 // 0x80000006 +#define WUFFS_DEFLATE__ERROR_UNEXPECTED_EOF -2147483641 // 0x80000007 +#define WUFFS_DEFLATE__SUSPENSION_SHORT_READ 8 // 0x00000008 +#define WUFFS_DEFLATE__SUSPENSION_SHORT_WRITE 9 // 0x00000009 +#define WUFFS_DEFLATE__ERROR_CANNOT_RETURN_A_SUSPENSION \ + -2147483638 // 0x8000000A -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE_OVER_SUBSCRIBED \ +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_OVER_SUBSCRIBED \ -1157040128 // 0xBB08F800 -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE_UNDER_SUBSCRIBED \ +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_UNDER_SUBSCRIBED \ -1157040127 // 0xBB08F801 -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_COUNT \ +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_COUNT \ -1157040126 // 0xBB08F802 -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_REPETITION \ - -1157040125 // 0xBB08F803 -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE -1157040124 // 0xBB08F804 -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_MINIMUM_CODE_LENGTH \ - -1157040123 // 0xBB08F805 -#define WUFFS_FLATE__ERROR_BAD_DISTANCE -1157040122 // 0xBB08F806 -#define WUFFS_FLATE__ERROR_BAD_DISTANCE_CODE_COUNT -1157040121 // 0xBB08F807 -#define WUFFS_FLATE__ERROR_BAD_FLATE_BLOCK -1157040120 // 0xBB08F808 -#define WUFFS_FLATE__ERROR_BAD_LITERAL_LENGTH_CODE_COUNT \ +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_REPETITION \ + -1157040125 // 0xBB08F803 +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE -1157040124 // 0xBB08F804 +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_MINIMUM_CODE_LENGTH \ + -1157040123 // 0xBB08F805 +#define WUFFS_DEFLATE__ERROR_BAD_DISTANCE -1157040122 // 0xBB08F806 +#define WUFFS_DEFLATE__ERROR_BAD_DISTANCE_CODE_COUNT -1157040121 // 0xBB08F807 +#define WUFFS_DEFLATE__ERROR_BAD_FLATE_BLOCK -1157040120 // 0xBB08F808 +#define WUFFS_DEFLATE__ERROR_BAD_LITERAL_LENGTH_CODE_COUNT \ -1157040119 // 0xBB08F809 -#define WUFFS_FLATE__ERROR_INCONSISTENT_STORED_BLOCK_LENGTH \ +#define WUFFS_DEFLATE__ERROR_INCONSISTENT_STORED_BLOCK_LENGTH \ -1157040118 // 0xBB08F80A -#define WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE \ +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE \ -1157040117 // 0xBB08F80B -#define WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_END_OF_BLOCK \ +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_END_OF_BLOCK \ -1157040116 // 0xBB08F80C -#define WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_DISTANCE \ +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_DISTANCE \ -1157040115 // 0xBB08F80D -#define WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS \ - -1157040114 // 0xBB08F80E -#define WUFFS_FLATE__ERROR_MISSING_END_OF_BLOCK_CODE -1157040113 // 0xBB08F80F -#define WUFFS_FLATE__ERROR_NO_HUFFMAN_CODES -1157040112 // 0xBB08F810 +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS \ + -1157040114 // 0xBB08F80E +#define WUFFS_DEFLATE__ERROR_MISSING_END_OF_BLOCK_CODE \ + -1157040113 // 0xBB08F80F +#define WUFFS_DEFLATE__ERROR_NO_HUFFMAN_CODES -1157040112 // 0xBB08F810 -bool wuffs_flate__status__is_error(wuffs_flate__status s); +bool wuffs_deflate__status__is_error(wuffs_deflate__status s); -const char* wuffs_flate__status__string(wuffs_flate__status s); +const char* wuffs_deflate__status__string(wuffs_deflate__status s); // ---------------- Public Consts @@ -179,13 +181,13 @@ const char* wuffs_flate__status__string(wuffs_flate__status s); typedef struct { // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. Instead, use the - // wuffs_flate__flate_decoder__etc functions. + // wuffs_deflate__flate_decoder__etc functions. // // In C++, these fields would be "private", but C does not support that. // // It is a struct, not a struct*, so that it can be stack allocated. struct { - wuffs_flate__status status; + wuffs_deflate__status status; uint32_t magic; uint32_t f_bits; @@ -199,7 +201,7 @@ typedef struct { struct { uint32_t coro_susp_point; - wuffs_flate__status v_z; + wuffs_deflate__status v_z; uint64_t v_n_copied; uint32_t v_already_full; } c_decode[1]; @@ -250,23 +252,25 @@ typedef struct { uint32_t v_hdist; } c_decode_huffman_slow[1]; } private_impl; -} wuffs_flate__flate_decoder; +} wuffs_deflate__flate_decoder; // ---------------- Public Initializer Prototypes -// wuffs_flate__flate_decoder__initialize is an initializer function. +// wuffs_deflate__flate_decoder__initialize is an initializer function. // -// It should be called before any other wuffs_flate__flate_decoder__* function. +// It should be called before any other wuffs_deflate__flate_decoder__* +// function. // // Pass WUFFS_VERSION and 0 for wuffs_version and for_internal_use_only. -void wuffs_flate__flate_decoder__initialize(wuffs_flate__flate_decoder* self, - uint32_t wuffs_version, - uint32_t for_internal_use_only); +void wuffs_deflate__flate_decoder__initialize( + wuffs_deflate__flate_decoder* self, + uint32_t wuffs_version, + uint32_t for_internal_use_only); // ---------------- Public Function Prototypes -wuffs_flate__status wuffs_flate__flate_decoder__decode( - wuffs_flate__flate_decoder* self, +wuffs_deflate__status wuffs_deflate__flate_decoder__decode( + wuffs_deflate__flate_decoder* self, wuffs_base__writer1 a_dst, wuffs_base__reader1 a_src); @@ -274,7 +278,7 @@ wuffs_flate__status wuffs_flate__flate_decoder__decode( } // extern "C" #endif -#endif // WUFFS_FLATE_H +#endif // WUFFS_DEFLATE_H // C HEADER ENDS HERE. @@ -475,9 +479,9 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32( } else { n = length; } - // TODO: unrolling by 3 seems best for the std/flate benchmarks, but that is - // mostly because 3 is the minimum length for the flate format. This function - // implementation shouldn't overfit to that one format. Perhaps the + // TODO: unrolling by 3 seems best for the std/deflate benchmarks, but that + // is mostly because 3 is the minimum length for the deflate format. This + // function implementation shouldn't overfit to that one format. Perhaps the // copy_from_history32 Wuffs method should also take an unroll hint argument, // and the cgen can look if that argument is the constant expression '3'. // @@ -625,68 +629,68 @@ static inline wuffs_base__empty_struct wuffs_base__writer1__mark( // ---------------- Status Codes Implementations -bool wuffs_flate__status__is_error(wuffs_flate__status s) { +bool wuffs_deflate__status__is_error(wuffs_deflate__status s) { return s < 0; } -const char* wuffs_flate__status__strings0[11] = { - "flate: ok", - "flate: bad wuffs version", - "flate: bad receiver", - "flate: bad argument", - "flate: initializer not called", - "flate: invalid I/O operation", - "flate: closed for writes", - "flate: unexpected EOF", - "flate: short read", - "flate: short write", - "flate: cannot return a suspension", +const char* wuffs_deflate__status__strings0[11] = { + "deflate: ok", + "deflate: bad wuffs version", + "deflate: bad receiver", + "deflate: bad argument", + "deflate: initializer not called", + "deflate: invalid I/O operation", + "deflate: closed for writes", + "deflate: unexpected EOF", + "deflate: short read", + "deflate: short write", + "deflate: cannot return a suspension", }; -const char* wuffs_flate__status__strings1[17] = { - "flate: bad Huffman code (over-subscribed)", - "flate: bad Huffman code (under-subscribed)", - "flate: bad Huffman code length count", - "flate: bad Huffman code length repetition", - "flate: bad Huffman code", - "flate: bad Huffman minimum code length", - "flate: bad distance", - "flate: bad distance code count", - "flate: bad flate block", - "flate: bad literal/length code count", - "flate: inconsistent stored block length", - "flate: internal error: inconsistent Huffman decoder state", - "flate: internal error: inconsistent Huffman end_of_block", - "flate: internal error: inconsistent distance", - "flate: internal error: inconsistent n_bits", - "flate: missing end-of-block code", - "flate: no Huffman codes", +const char* wuffs_deflate__status__strings1[17] = { + "deflate: bad Huffman code (over-subscribed)", + "deflate: bad Huffman code (under-subscribed)", + "deflate: bad Huffman code length count", + "deflate: bad Huffman code length repetition", + "deflate: bad Huffman code", + "deflate: bad Huffman minimum code length", + "deflate: bad distance", + "deflate: bad distance code count", + "deflate: bad flate block", + "deflate: bad literal/length code count", + "deflate: inconsistent stored block length", + "deflate: internal error: inconsistent Huffman decoder state", + "deflate: internal error: inconsistent Huffman end_of_block", + "deflate: internal error: inconsistent distance", + "deflate: internal error: inconsistent n_bits", + "deflate: missing end-of-block code", + "deflate: no Huffman codes", }; -const char* wuffs_flate__status__string(wuffs_flate__status s) { +const char* wuffs_deflate__status__string(wuffs_deflate__status s) { const char** a = NULL; uint32_t n = 0; switch ((s >> 10) & 0x1FFFFF) { case 0: - a = wuffs_flate__status__strings0; + a = wuffs_deflate__status__strings0; n = 11; break; - case wuffs_flate__packageid: - a = wuffs_flate__status__strings1; + case wuffs_deflate__packageid: + a = wuffs_deflate__status__strings1; n = 17; break; } uint32_t i = s & 0xFF; - return i < n ? a[i] : "flate: unknown status"; + return i < n ? a[i] : "deflate: unknown status"; } // ---------------- Private Consts -static const uint8_t wuffs_flate__code_order[19] = { +static const uint8_t wuffs_deflate__code_order[19] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15, }; -static const uint8_t wuffs_flate__reverse8[256] = { +static const uint8_t wuffs_deflate__reverse8[256] = { 0, 128, 64, 192, 32, 160, 96, 224, 16, 144, 80, 208, 48, 176, 112, 240, 8, 136, 72, 200, 40, 168, 104, 232, 24, 152, 88, 216, 56, 184, 120, 248, 4, 132, 68, 196, 36, 164, 100, 228, 20, 148, 84, 212, 52, 180, 116, 244, @@ -705,7 +709,7 @@ static const uint8_t wuffs_flate__reverse8[256] = { 15, 143, 79, 207, 47, 175, 111, 239, 31, 159, 95, 223, 63, 191, 127, 255, }; -static const uint32_t wuffs_flate__lcode_magic_numbers[32] = { +static const uint32_t wuffs_deflate__lcode_magic_numbers[32] = { 1073742592, 1073742848, 1073743104, 1073743360, 1073743616, 1073743872, 1073744128, 1073744384, 1073744656, 1073745168, 1073745680, 1073746192, 1073746720, 1073747744, 1073748768, 1073749792, 1073750832, 1073752880, @@ -714,7 +718,7 @@ static const uint32_t wuffs_flate__lcode_magic_numbers[32] = { 134217728, 134217728, }; -static const uint32_t wuffs_flate__dcode_magic_numbers[32] = { +static const uint32_t wuffs_deflate__dcode_magic_numbers[32] = { 1073742080, 1073742336, 1073742592, 1073742848, 1073743120, 1073743632, 1073744160, 1073745184, 1073746224, 1073748272, 1073750336, 1073754432, 1073758544, 1073766736, 1073774944, 1073791328, 1073807728, 1073840496, @@ -727,50 +731,51 @@ static const uint32_t wuffs_flate__dcode_magic_numbers[32] = { // ---------------- Private Function Prototypes -static wuffs_flate__status wuffs_flate__flate_decoder__decode_blocks( - wuffs_flate__flate_decoder* self, +static wuffs_deflate__status wuffs_deflate__flate_decoder__decode_blocks( + wuffs_deflate__flate_decoder* self, wuffs_base__writer1 a_dst, wuffs_base__reader1 a_src); -static wuffs_flate__status wuffs_flate__flate_decoder__decode_uncompressed( - wuffs_flate__flate_decoder* self, +static wuffs_deflate__status wuffs_deflate__flate_decoder__decode_uncompressed( + wuffs_deflate__flate_decoder* self, wuffs_base__writer1 a_dst, wuffs_base__reader1 a_src); -static wuffs_flate__status wuffs_flate__flate_decoder__init_fixed_huffman( - wuffs_flate__flate_decoder* self); +static wuffs_deflate__status wuffs_deflate__flate_decoder__init_fixed_huffman( + wuffs_deflate__flate_decoder* self); -static wuffs_flate__status wuffs_flate__flate_decoder__init_dynamic_huffman( - wuffs_flate__flate_decoder* self, +static wuffs_deflate__status wuffs_deflate__flate_decoder__init_dynamic_huffman( + wuffs_deflate__flate_decoder* self, wuffs_base__reader1 a_src); -static wuffs_flate__status wuffs_flate__flate_decoder__init_huff( - wuffs_flate__flate_decoder* self, +static wuffs_deflate__status wuffs_deflate__flate_decoder__init_huff( + wuffs_deflate__flate_decoder* self, uint32_t a_which, uint32_t a_n_codes0, uint32_t a_n_codes1, uint32_t a_base_symbol); -static wuffs_flate__status wuffs_flate__flate_decoder__decode_huffman_fast( - wuffs_flate__flate_decoder* self, +static wuffs_deflate__status wuffs_deflate__flate_decoder__decode_huffman_fast( + wuffs_deflate__flate_decoder* self, wuffs_base__writer1 a_dst, wuffs_base__reader1 a_src); -static wuffs_flate__status wuffs_flate__flate_decoder__decode_huffman_slow( - wuffs_flate__flate_decoder* self, +static wuffs_deflate__status wuffs_deflate__flate_decoder__decode_huffman_slow( + wuffs_deflate__flate_decoder* self, wuffs_base__writer1 a_dst, wuffs_base__reader1 a_src); // ---------------- Initializer Implementations -void wuffs_flate__flate_decoder__initialize(wuffs_flate__flate_decoder* self, - uint32_t wuffs_version, - uint32_t for_internal_use_only) { +void wuffs_deflate__flate_decoder__initialize( + wuffs_deflate__flate_decoder* self, + uint32_t wuffs_version, + uint32_t for_internal_use_only) { if (!self) { return; } if (wuffs_version != WUFFS_VERSION) { - self->private_impl.status = WUFFS_FLATE__ERROR_BAD_WUFFS_VERSION; + self->private_impl.status = WUFFS_DEFLATE__ERROR_BAD_WUFFS_VERSION; return; } if (for_internal_use_only != WUFFS_BASE__ALREADY_ZEROED) { @@ -781,22 +786,22 @@ void wuffs_flate__flate_decoder__initialize(wuffs_flate__flate_decoder* self, // ---------------- Function Implementations -wuffs_flate__status wuffs_flate__flate_decoder__decode( - wuffs_flate__flate_decoder* self, +wuffs_deflate__status wuffs_deflate__flate_decoder__decode( + wuffs_deflate__flate_decoder* self, wuffs_base__writer1 a_dst, wuffs_base__reader1 a_src) { if (!self) { - return WUFFS_FLATE__ERROR_BAD_RECEIVER; + return WUFFS_DEFLATE__ERROR_BAD_RECEIVER; } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - self->private_impl.status = WUFFS_FLATE__ERROR_INITIALIZER_NOT_CALLED; + self->private_impl.status = WUFFS_DEFLATE__ERROR_INITIALIZER_NOT_CALLED; } if (self->private_impl.status < 0) { return self->private_impl.status; } - wuffs_flate__status status = WUFFS_FLATE__STATUS_OK; + wuffs_deflate__status status = WUFFS_DEFLATE__STATUS_OK; - wuffs_flate__status v_z; + wuffs_deflate__status v_z; wuffs_base__slice_u8 v_written; uint64_t v_n_copied; uint32_t v_already_full; @@ -844,8 +849,8 @@ wuffs_flate__status wuffs_flate__flate_decoder__decode( } } } - wuffs_flate__status t_0 = - wuffs_flate__flate_decoder__decode_blocks(self, a_dst, a_src); + wuffs_deflate__status t_0 = + wuffs_deflate__flate_decoder__decode_blocks(self, a_dst, a_src); if (a_dst.buf) { b_wptr_dst = a_dst.buf->ptr + a_dst.buf->wi; } @@ -856,7 +861,7 @@ wuffs_flate__status wuffs_flate__flate_decoder__decode( if (status == 0) { goto ok; } else if (status > 0) { - status = WUFFS_FLATE__ERROR_CANNOT_RETURN_A_SUSPENSION; + status = WUFFS_DEFLATE__ERROR_CANNOT_RETURN_A_SUSPENSION; } goto exit; } @@ -933,11 +938,11 @@ exit: return status; } -static wuffs_flate__status wuffs_flate__flate_decoder__decode_blocks( - wuffs_flate__flate_decoder* self, +static wuffs_deflate__status wuffs_deflate__flate_decoder__decode_blocks( + wuffs_deflate__flate_decoder* self, wuffs_base__writer1 a_dst, wuffs_base__reader1 a_src) { - wuffs_flate__status status = WUFFS_FLATE__STATUS_OK; + wuffs_deflate__status status = WUFFS_DEFLATE__STATUS_OK; uint32_t v_final; uint32_t v_type; @@ -998,8 +1003,8 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_blocks( } } } - status = - wuffs_flate__flate_decoder__decode_uncompressed(self, a_dst, a_src); + status = wuffs_deflate__flate_decoder__decode_uncompressed(self, a_dst, + a_src); if (a_src.buf) { b_rptr_src = a_src.buf->ptr + a_src.buf->ri; } @@ -1009,7 +1014,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_blocks( goto label_0_continue; } else if (v_type == 1) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); - status = wuffs_flate__flate_decoder__init_fixed_huffman(self); + status = wuffs_deflate__flate_decoder__init_fixed_huffman(self); if (status) { goto suspend; } @@ -1025,7 +1030,8 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_blocks( } } } - status = wuffs_flate__flate_decoder__init_dynamic_huffman(self, a_src); + status = + wuffs_deflate__flate_decoder__init_dynamic_huffman(self, a_src); if (a_src.buf) { b_rptr_src = a_src.buf->ptr + a_src.buf->ri; } @@ -1033,7 +1039,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_blocks( goto suspend; } } else { - status = WUFFS_FLATE__ERROR_BAD_FLATE_BLOCK; + status = WUFFS_DEFLATE__ERROR_BAD_FLATE_BLOCK; goto exit; } self->private_impl.f_end_of_block = false; @@ -1049,7 +1055,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_blocks( } } status = - wuffs_flate__flate_decoder__decode_huffman_fast(self, a_dst, a_src); + wuffs_deflate__flate_decoder__decode_huffman_fast(self, a_dst, a_src); if (a_src.buf) { b_rptr_src = a_src.buf->ptr + a_src.buf->ri; } @@ -1071,7 +1077,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_blocks( } } status = - wuffs_flate__flate_decoder__decode_huffman_slow(self, a_dst, a_src); + wuffs_deflate__flate_decoder__decode_huffman_slow(self, a_dst, a_src); if (a_src.buf) { b_rptr_src = a_src.buf->ptr + a_src.buf->ri; } @@ -1082,7 +1088,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_blocks( goto label_0_continue; } status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_END_OF_BLOCK; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_END_OF_BLOCK; goto exit; } @@ -1116,18 +1122,18 @@ exit: short_read_src: if (a_src.buf && a_src.buf->closed && !a_src.private_impl.limit.ptr_to_len) { - status = WUFFS_FLATE__ERROR_UNEXPECTED_EOF; + status = WUFFS_DEFLATE__ERROR_UNEXPECTED_EOF; goto exit; } - status = WUFFS_FLATE__SUSPENSION_SHORT_READ; + status = WUFFS_DEFLATE__SUSPENSION_SHORT_READ; goto suspend; } -static wuffs_flate__status wuffs_flate__flate_decoder__decode_uncompressed( - wuffs_flate__flate_decoder* self, +static wuffs_deflate__status wuffs_deflate__flate_decoder__decode_uncompressed( + wuffs_deflate__flate_decoder* self, wuffs_base__writer1 a_dst, wuffs_base__reader1 a_src) { - wuffs_flate__status status = WUFFS_FLATE__STATUS_OK; + wuffs_deflate__status status = WUFFS_DEFLATE__STATUS_OK; uint32_t v_length; uint32_t v_n_copied; @@ -1177,7 +1183,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_uncompressed( if ((self->private_impl.f_n_bits >= 8) || ((self->private_impl.f_bits >> self->private_impl.f_n_bits) != 0)) { - status = WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS; + status = WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS; goto exit; } self->private_impl.f_n_bits = 0; @@ -1214,7 +1220,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_uncompressed( } if ((((v_length) & ((1 << (16)) - 1)) + ((v_length) >> (32 - (16)))) != 65535) { - status = WUFFS_FLATE__ERROR_INCONSISTENT_STORED_BLOCK_LENGTH; + status = WUFFS_DEFLATE__ERROR_INCONSISTENT_STORED_BLOCK_LENGTH; goto exit; } v_length = ((v_length) & ((1 << (16)) - 1)); @@ -1227,10 +1233,10 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_uncompressed( } v_length -= v_n_copied; if (((uint64_t)(b_wend_dst - b_wptr_dst)) == 0) { - status = WUFFS_FLATE__SUSPENSION_SHORT_WRITE; + status = WUFFS_DEFLATE__SUSPENSION_SHORT_WRITE; WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3); } else { - status = WUFFS_FLATE__SUSPENSION_SHORT_READ; + status = WUFFS_DEFLATE__SUSPENSION_SHORT_READ; WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(4); } } @@ -1278,16 +1284,16 @@ exit: short_read_src: if (a_src.buf && a_src.buf->closed && !a_src.private_impl.limit.ptr_to_len) { - status = WUFFS_FLATE__ERROR_UNEXPECTED_EOF; + status = WUFFS_DEFLATE__ERROR_UNEXPECTED_EOF; goto exit; } - status = WUFFS_FLATE__SUSPENSION_SHORT_READ; + status = WUFFS_DEFLATE__SUSPENSION_SHORT_READ; goto suspend; } -static wuffs_flate__status wuffs_flate__flate_decoder__init_fixed_huffman( - wuffs_flate__flate_decoder* self) { - wuffs_flate__status status = WUFFS_FLATE__STATUS_OK; +static wuffs_deflate__status wuffs_deflate__flate_decoder__init_fixed_huffman( + wuffs_deflate__flate_decoder* self) { + wuffs_deflate__status status = WUFFS_DEFLATE__STATUS_OK; uint32_t v_i; @@ -1321,12 +1327,12 @@ static wuffs_flate__status wuffs_flate__flate_decoder__init_fixed_huffman( v_i += 1; } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); - status = wuffs_flate__flate_decoder__init_huff(self, 0, 0, 288, 257); + status = wuffs_deflate__flate_decoder__init_huff(self, 0, 0, 288, 257); if (status) { goto suspend; } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); - status = wuffs_flate__flate_decoder__init_huff(self, 1, 288, 320, 0); + status = wuffs_deflate__flate_decoder__init_huff(self, 1, 288, 320, 0); if (status) { goto suspend; } @@ -1346,10 +1352,10 @@ exit: return status; } -static wuffs_flate__status wuffs_flate__flate_decoder__init_dynamic_huffman( - wuffs_flate__flate_decoder* self, +static wuffs_deflate__status wuffs_deflate__flate_decoder__init_dynamic_huffman( + wuffs_deflate__flate_decoder* self, wuffs_base__reader1 a_src) { - wuffs_flate__status status = WUFFS_FLATE__STATUS_OK; + wuffs_deflate__status status = WUFFS_DEFLATE__STATUS_OK; uint32_t v_bits; uint32_t v_n_bits; @@ -1416,13 +1422,13 @@ static wuffs_flate__status wuffs_flate__flate_decoder__init_dynamic_huffman( } v_n_lit = (((v_bits) & ((1 << (5)) - 1)) + 257); if (v_n_lit > 286) { - status = WUFFS_FLATE__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_FLATE__ERROR_BAD_DISTANCE_CODE_COUNT; + status = WUFFS_DEFLATE__ERROR_BAD_DISTANCE_CODE_COUNT; goto exit; } v_bits >>= 5; @@ -1442,18 +1448,18 @@ static wuffs_flate__status wuffs_flate__flate_decoder__init_dynamic_huffman( } v_n_bits += 8; } - self->private_impl.f_code_lengths[wuffs_flate__code_order[v_i]] = + self->private_impl.f_code_lengths[wuffs_deflate__code_order[v_i]] = ((uint8_t)((v_bits & 7))); v_bits >>= 3; v_n_bits -= 3; v_i += 1; } while (v_i < 19) { - self->private_impl.f_code_lengths[wuffs_flate__code_order[v_i]] = 0; + self->private_impl.f_code_lengths[wuffs_deflate__code_order[v_i]] = 0; v_i += 1; } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); - status = wuffs_flate__flate_decoder__init_huff(self, 0, 0, 19, 4095); + status = wuffs_deflate__flate_decoder__init_huff(self, 0, 0, 19, 4095); if (status) { goto suspend; } @@ -1483,7 +1489,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__init_dynamic_huffman( label_1_break:; if ((v_table_entry >> 24) != 128) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } v_table_entry = ((v_table_entry >> 8) & 255); @@ -1498,7 +1504,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__init_dynamic_huffman( if (v_table_entry == 16) { v_n_extra_bits = 2; if (v_i <= 0) { - status = WUFFS_FLATE__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]; @@ -1513,7 +1519,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__init_dynamic_huffman( v_rep_count = 11; } else { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } while (v_n_bits < v_n_extra_bits) { @@ -1532,7 +1538,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__init_dynamic_huffman( v_n_bits -= v_n_extra_bits; while (v_rep_count > 0) { if (v_i >= (v_n_lit + v_n_dist)) { - status = WUFFS_FLATE__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; @@ -1541,21 +1547,21 @@ static wuffs_flate__status wuffs_flate__flate_decoder__init_dynamic_huffman( } } if (v_i != (v_n_lit + v_n_dist)) { - status = WUFFS_FLATE__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_FLATE__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_flate__flate_decoder__init_huff(self, 0, 0, v_n_lit, 257); + status = wuffs_deflate__flate_decoder__init_huff(self, 0, 0, v_n_lit, 257); if (status) { goto suspend; } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); - status = wuffs_flate__flate_decoder__init_huff(self, 1, v_n_lit, - (v_n_lit + v_n_dist), 0); + status = wuffs_deflate__flate_decoder__init_huff(self, 1, v_n_lit, + (v_n_lit + v_n_dist), 0); if (status) { goto suspend; } @@ -1604,20 +1610,20 @@ exit: short_read_src: if (a_src.buf && a_src.buf->closed && !a_src.private_impl.limit.ptr_to_len) { - status = WUFFS_FLATE__ERROR_UNEXPECTED_EOF; + status = WUFFS_DEFLATE__ERROR_UNEXPECTED_EOF; goto exit; } - status = WUFFS_FLATE__SUSPENSION_SHORT_READ; + status = WUFFS_DEFLATE__SUSPENSION_SHORT_READ; goto suspend; } -static wuffs_flate__status wuffs_flate__flate_decoder__init_huff( - wuffs_flate__flate_decoder* self, +static wuffs_deflate__status wuffs_deflate__flate_decoder__init_huff( + wuffs_deflate__flate_decoder* self, uint32_t a_which, uint32_t a_n_codes0, uint32_t a_n_codes1, uint32_t a_base_symbol) { - wuffs_flate__status status = WUFFS_FLATE__STATUS_OK; + wuffs_deflate__status status = WUFFS_DEFLATE__STATUS_OK; uint16_t v_counts[16]; uint32_t v_i; @@ -1650,14 +1656,14 @@ static wuffs_flate__status wuffs_flate__flate_decoder__init_huff( while (v_i < a_n_codes1) { if (v_counts[self->private_impl.f_code_lengths[v_i]] >= 320) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + 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_FLATE__ERROR_NO_HUFFMAN_CODES; + status = WUFFS_DEFLATE__ERROR_NO_HUFFMAN_CODES; goto exit; } v_remaining = 1; @@ -1665,19 +1671,19 @@ static wuffs_flate__status wuffs_flate__flate_decoder__init_huff( while (v_i <= 15) { if (v_remaining > 1073741824) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + 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_FLATE__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_FLATE__ERROR_BAD_HUFFMAN_CODE_UNDER_SUBSCRIBED; + status = WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_UNDER_SUBSCRIBED; goto exit; } memset(v_offsets, 0, sizeof(v_offsets)); @@ -1688,7 +1694,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__init_huff( v_count = ((uint32_t)(v_counts[v_i])); if (v_n_symbols > (320 - v_count)) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } v_n_symbols = (v_n_symbols + v_count); @@ -1696,7 +1702,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__init_huff( } if (v_n_symbols > 288) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } memset(v_symbols, 0, sizeof(v_symbols)); @@ -1704,13 +1710,13 @@ static wuffs_flate__status wuffs_flate__flate_decoder__init_huff( while (v_i < a_n_codes1) { if (v_i < a_n_codes0) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + 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_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } v_symbols[v_offsets[self->private_impl.f_code_lengths[v_i]]] = @@ -1725,7 +1731,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__init_huff( goto label_0_break; } if (v_min_cl >= 9) { - status = WUFFS_FLATE__ERROR_BAD_HUFFMAN_MINIMUM_CODE_LENGTH; + status = WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_MINIMUM_CODE_LENGTH; goto exit; } v_min_cl += 1; @@ -1737,7 +1743,7 @@ label_0_break:; goto label_1_break; } if (v_max_cl <= 1) { - status = WUFFS_FLATE__ERROR_NO_HUFFMAN_CODES; + status = WUFFS_DEFLATE__ERROR_NO_HUFFMAN_CODES; goto exit; } v_max_cl -= 1; @@ -1752,12 +1758,12 @@ label_1_break:; if ((v_n_symbols != ((uint32_t)(v_offsets[v_max_cl]))) || (v_n_symbols != ((uint32_t)(v_offsets[15])))) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } if ((a_n_codes0 + ((uint32_t)(v_symbols[0]))) >= 320) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } v_initial_high_bits = 512; @@ -1776,7 +1782,7 @@ label_1_break:; while (true) { if ((a_n_codes0 + ((uint32_t)(v_symbols[v_i]))) >= 320) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } v_cl = ((uint32_t)( @@ -1786,7 +1792,7 @@ label_1_break:; v_code <<= (v_cl - v_prev_cl); if (v_code >= 32768) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } } @@ -1808,7 +1814,7 @@ label_1_break:; v_remaining -= ((uint32_t)(v_counts[v_j])); if (v_remaining > 1073741824) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } v_remaining <<= 1; @@ -1817,7 +1823,7 @@ label_1_break:; label_2_break:; if ((v_j <= 9) || (15 < v_j)) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } v_tmp = (v_j - 9); @@ -1825,12 +1831,12 @@ label_1_break:; v_top = v_next_top; if ((v_top + (((uint32_t)(1)) << v_tmp)) > 1234) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } v_next_top = (v_top + (((uint32_t)(1)) << v_tmp)); v_redirect_key = - (((uint32_t)(wuffs_flate__reverse8[v_redirect_key >> 1])) | + (((uint32_t)(wuffs_deflate__reverse8[v_redirect_key >> 1])) | ((v_redirect_key & 1) << 8)); self->private_impl.f_huffs[a_which][v_redirect_key] = (268435465 | (v_top << 8) | (v_tmp << 4)); @@ -1838,12 +1844,12 @@ label_1_break:; } if ((v_key >= 512) || (v_counts[v_prev_cl] <= 0)) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } v_counts[v_prev_cl] -= 1; - v_reversed_key = - (((uint32_t)(wuffs_flate__reverse8[v_key >> 1])) | ((v_key & 1) << 8)); + v_reversed_key = (((uint32_t)(wuffs_deflate__reverse8[v_key >> 1])) | + ((v_key & 1) << 8)); v_reversed_key >>= (9 - v_cl); v_symbol = ((uint32_t)(v_symbols[v_i])); if (v_symbol == 256) { @@ -1853,13 +1859,13 @@ label_1_break:; } else if (v_symbol >= a_base_symbol) { v_symbol -= a_base_symbol; if (a_which == 0) { - v_value = (wuffs_flate__lcode_magic_numbers[v_symbol & 31] | v_cl); + v_value = (wuffs_deflate__lcode_magic_numbers[v_symbol & 31] | v_cl); } else { - v_value = (wuffs_flate__dcode_magic_numbers[v_symbol & 31] | v_cl); + v_value = (wuffs_deflate__dcode_magic_numbers[v_symbol & 31] | v_cl); } } else { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } v_high_bits = v_initial_high_bits; @@ -1868,7 +1874,7 @@ label_1_break:; v_high_bits -= v_delta; if ((v_top + ((v_high_bits | v_reversed_key) & 511)) >= 1234) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } self->private_impl @@ -1882,7 +1888,7 @@ label_1_break:; v_code += 1; if (v_code >= 32768) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } } @@ -1891,11 +1897,11 @@ exit: return status; } -static wuffs_flate__status wuffs_flate__flate_decoder__decode_huffman_fast( - wuffs_flate__flate_decoder* self, +static wuffs_deflate__status wuffs_deflate__flate_decoder__decode_huffman_fast( + wuffs_deflate__flate_decoder* self, wuffs_base__writer1 a_dst, wuffs_base__reader1 a_src) { - wuffs_flate__status status = WUFFS_FLATE__STATUS_OK; + wuffs_deflate__status status = WUFFS_DEFLATE__STATUS_OK; uint32_t v_bits; uint32_t v_n_bits; @@ -1946,12 +1952,12 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_huffman_fast( } if (!(a_dst.private_impl.mark != NULL)) { - status = WUFFS_FLATE__ERROR_BAD_ARGUMENT; + status = WUFFS_DEFLATE__ERROR_BAD_ARGUMENT; goto exit; } if ((self->private_impl.f_n_bits >= 8) || ((self->private_impl.f_bits >> self->private_impl.f_n_bits) != 0)) { - status = WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS; + status = WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS; goto exit; } v_bits = self->private_impl.f_bits; @@ -2005,7 +2011,7 @@ label_0_continue:; v_redir_mask = ((((uint32_t)(1)) << ((v_table_entry >> 4) & 15)) - 1); if ((v_redir_top + (v_bits & v_redir_mask)) >= 1234) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } v_table_entry = @@ -2022,22 +2028,22 @@ label_0_continue:; goto label_0_break; } else if ((v_table_entry >> 28) != 0) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } else if ((v_table_entry >> 27) != 0) { - status = WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE; + status = WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE; goto exit; } else { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } } else if ((v_table_entry >> 27) != 0) { - status = WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE; + status = WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE; goto exit; } else { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } v_length = ((v_table_entry >> 8) & 32767); @@ -2065,7 +2071,7 @@ label_0_continue:; } if (v_length > 258) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } if (v_n_bits < 15) { @@ -2103,7 +2109,7 @@ label_0_continue:; v_redir_mask = ((((uint32_t)(1)) << ((v_table_entry >> 4) & 15)) - 1); if ((v_redir_top + (v_bits & v_redir_mask)) >= 1234) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } v_table_entry = @@ -2115,11 +2121,11 @@ label_0_continue:; } if ((v_table_entry >> 24) != 64) { if ((v_table_entry >> 24) == 8) { - status = WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE; + status = WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE; goto exit; } status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } v_distance = ((v_table_entry >> 8) & 32767); @@ -2145,7 +2151,7 @@ label_0_continue:; } if (v_distance <= 0) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } v_n_copied = 0; @@ -2175,7 +2181,7 @@ label_0_continue:; v_hlen = v_hdist; if (v_length > 258) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } } else { @@ -2183,7 +2189,7 @@ label_0_continue:; v_length = 0; } if (self->private_impl.f_history_index < v_hdist) { - status = WUFFS_FLATE__ERROR_BAD_DISTANCE; + status = WUFFS_DEFLATE__ERROR_BAD_DISTANCE; goto exit; } v_hdist = ((self->private_impl.f_history_index - v_hdist) & 32767); @@ -2219,7 +2225,7 @@ label_0_continue:; : 0, }) .len))) { - status = WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_DISTANCE; + status = WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_DISTANCE; goto exit; } } @@ -2234,7 +2240,7 @@ label_0_break:; while (v_n_bits >= 8) { v_n_bits -= 8; if (b_rptr_src == b_rstart_src) { - status = WUFFS_FLATE__ERROR_INVALID_I_O_OPERATION; + status = WUFFS_DEFLATE__ERROR_INVALID_I_O_OPERATION; goto exit; } b_rptr_src--; @@ -2243,7 +2249,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_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS; + status = WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS; goto exit; } exit: @@ -2275,11 +2281,11 @@ exit: return status; } -static wuffs_flate__status wuffs_flate__flate_decoder__decode_huffman_slow( - wuffs_flate__flate_decoder* self, +static wuffs_deflate__status wuffs_deflate__flate_decoder__decode_huffman_slow( + wuffs_deflate__flate_decoder* self, wuffs_base__writer1 a_dst, wuffs_base__reader1 a_src) { - wuffs_flate__status status = WUFFS_FLATE__STATUS_OK; + wuffs_deflate__status status = WUFFS_DEFLATE__STATUS_OK; uint32_t v_bits; uint32_t v_n_bits; @@ -2352,7 +2358,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_huffman_slow( if ((self->private_impl.f_n_bits >= 8) || ((self->private_impl.f_bits >> self->private_impl.f_n_bits) != 0)) { - status = WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS; + status = WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS; goto exit; } v_bits = self->private_impl.f_bits; @@ -2385,7 +2391,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_huffman_slow( if ((v_table_entry >> 31) != 0) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); if (b_wptr_dst == b_wend_dst) { - status = WUFFS_FLATE__SUSPENSION_SHORT_WRITE; + status = WUFFS_DEFLATE__SUSPENSION_SHORT_WRITE; goto suspend; } *b_wptr_dst++ = ((v_table_entry >> 8) & 255); @@ -2400,7 +2406,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_huffman_slow( while (true) { if ((v_redir_top + (v_bits & v_redir_mask)) >= 1234) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } v_table_entry = @@ -2426,7 +2432,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_huffman_slow( if ((v_table_entry >> 31) != 0) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); if (b_wptr_dst == b_wend_dst) { - status = WUFFS_FLATE__SUSPENSION_SHORT_WRITE; + status = WUFFS_DEFLATE__SUSPENSION_SHORT_WRITE; goto suspend; } *b_wptr_dst++ = ((v_table_entry >> 8) & 255); @@ -2437,22 +2443,22 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_huffman_slow( goto label_0_break; } else if ((v_table_entry >> 28) != 0) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } else if ((v_table_entry >> 27) != 0) { - status = WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE; + status = WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE; goto exit; } else { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } } else if ((v_table_entry >> 27) != 0) { - status = WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE; + status = WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE; goto exit; } else { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } v_length = ((v_table_entry >> 8) & 32767); @@ -2500,7 +2506,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_huffman_slow( while (true) { if ((v_redir_top + (v_bits & v_redir_mask)) >= 1234) { status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } v_table_entry = @@ -2526,11 +2532,11 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_huffman_slow( } if ((v_table_entry >> 24) != 64) { if ((v_table_entry >> 24) == 8) { - status = WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE; + status = WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE; goto exit; } status = - WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; goto exit; } v_distance = ((v_table_entry >> 8) & 32767); @@ -2583,7 +2589,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_huffman_slow( v_length = 0; } if (self->private_impl.f_history_index < v_hdist) { - status = WUFFS_FLATE__ERROR_BAD_DISTANCE; + status = WUFFS_DEFLATE__ERROR_BAD_DISTANCE; goto exit; } v_hdist = ((self->private_impl.f_history_index - v_hdist) & 32767); @@ -2606,7 +2612,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_huffman_slow( goto label_5_break; } } - status = WUFFS_FLATE__SUSPENSION_SHORT_WRITE; + status = WUFFS_DEFLATE__SUSPENSION_SHORT_WRITE; WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9); } label_5_break:; @@ -2625,7 +2631,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_huffman_slow( } v_hlen -= v_n_copied; v_hdist = ((v_hdist + (v_n_copied & 32767)) & 32767); - status = WUFFS_FLATE__SUSPENSION_SHORT_WRITE; + status = WUFFS_DEFLATE__SUSPENSION_SHORT_WRITE; WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(10); } label_6_break:; @@ -2642,7 +2648,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_huffman_slow( goto label_7_break; } v_length -= v_n_copied; - status = WUFFS_FLATE__SUSPENSION_SHORT_WRITE; + status = WUFFS_DEFLATE__SUSPENSION_SHORT_WRITE; WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(11); } label_7_break:; @@ -2652,7 +2658,7 @@ static wuffs_flate__status wuffs_flate__flate_decoder__decode_huffman_slow( 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_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS; + status = WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS; goto exit; } @@ -2710,9 +2716,9 @@ exit: short_read_src: if (a_src.buf && a_src.buf->closed && !a_src.private_impl.limit.ptr_to_len) { - status = WUFFS_FLATE__ERROR_UNEXPECTED_EOF; + status = WUFFS_DEFLATE__ERROR_UNEXPECTED_EOF; goto exit; } - status = WUFFS_FLATE__SUSPENSION_SHORT_READ; + status = WUFFS_DEFLATE__SUSPENSION_SHORT_READ; goto suspend; } diff --git a/gen/c/std/gif.c b/gen/c/std/gif.c index 280888e5..a681ce9d 100644 --- a/gen/c/std/gif.c +++ b/gen/c/std/gif.c @@ -481,9 +481,9 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32( } else { n = length; } - // TODO: unrolling by 3 seems best for the std/flate benchmarks, but that is - // mostly because 3 is the minimum length for the flate format. This function - // implementation shouldn't overfit to that one format. Perhaps the + // TODO: unrolling by 3 seems best for the std/deflate benchmarks, but that + // is mostly because 3 is the minimum length for the deflate format. This + // function implementation shouldn't overfit to that one format. Perhaps the // copy_from_history32 Wuffs method should also take an unroll hint argument, // and the cgen can look if that argument is the constant expression '3'. // diff --git a/gen/c/std/zlib.c b/gen/c/std/zlib.c index 29bd7e3d..2689d067 100644 --- a/gen/c/std/zlib.c +++ b/gen/c/std/zlib.c @@ -109,10 +109,10 @@ typedef struct { // ---------------- Use Declarations -// ---------------- BEGIN USE "std/flate" +// ---------------- BEGIN USE "std/deflate" -#ifndef WUFFS_FLATE_H -#define WUFFS_FLATE_H +#ifndef WUFFS_DEFLATE_H +#define WUFFS_DEFLATE_H // Code generated by wuffs-c. DO NOT EDIT. @@ -131,55 +131,57 @@ extern "C" { // - bits 0-7 are a package-namespaced numeric code // // Do not manipulate these bits directly. Use the API functions such as -// wuffs_flate__status__is_error instead. -typedef int32_t wuffs_flate__status; +// wuffs_deflate__status__is_error instead. +typedef int32_t wuffs_deflate__status; -#define wuffs_flate__packageid 967230 // 0x000EC23E +#define wuffs_deflate__packageid 967230 // 0x000EC23E -#define WUFFS_FLATE__STATUS_OK 0 // 0x00000000 -#define WUFFS_FLATE__ERROR_BAD_WUFFS_VERSION -2147483647 // 0x80000001 -#define WUFFS_FLATE__ERROR_BAD_RECEIVER -2147483646 // 0x80000002 -#define WUFFS_FLATE__ERROR_BAD_ARGUMENT -2147483645 // 0x80000003 -#define WUFFS_FLATE__ERROR_INITIALIZER_NOT_CALLED -2147483644 // 0x80000004 -#define WUFFS_FLATE__ERROR_INVALID_I_O_OPERATION -2147483643 // 0x80000005 -#define WUFFS_FLATE__ERROR_CLOSED_FOR_WRITES -2147483642 // 0x80000006 -#define WUFFS_FLATE__ERROR_UNEXPECTED_EOF -2147483641 // 0x80000007 -#define WUFFS_FLATE__SUSPENSION_SHORT_READ 8 // 0x00000008 -#define WUFFS_FLATE__SUSPENSION_SHORT_WRITE 9 // 0x00000009 -#define WUFFS_FLATE__ERROR_CANNOT_RETURN_A_SUSPENSION -2147483638 // 0x8000000A +#define WUFFS_DEFLATE__STATUS_OK 0 // 0x00000000 +#define WUFFS_DEFLATE__ERROR_BAD_WUFFS_VERSION -2147483647 // 0x80000001 +#define WUFFS_DEFLATE__ERROR_BAD_RECEIVER -2147483646 // 0x80000002 +#define WUFFS_DEFLATE__ERROR_BAD_ARGUMENT -2147483645 // 0x80000003 +#define WUFFS_DEFLATE__ERROR_INITIALIZER_NOT_CALLED -2147483644 // 0x80000004 +#define WUFFS_DEFLATE__ERROR_INVALID_I_O_OPERATION -2147483643 // 0x80000005 +#define WUFFS_DEFLATE__ERROR_CLOSED_FOR_WRITES -2147483642 // 0x80000006 +#define WUFFS_DEFLATE__ERROR_UNEXPECTED_EOF -2147483641 // 0x80000007 +#define WUFFS_DEFLATE__SUSPENSION_SHORT_READ 8 // 0x00000008 +#define WUFFS_DEFLATE__SUSPENSION_SHORT_WRITE 9 // 0x00000009 +#define WUFFS_DEFLATE__ERROR_CANNOT_RETURN_A_SUSPENSION \ + -2147483638 // 0x8000000A -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE_OVER_SUBSCRIBED \ +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_OVER_SUBSCRIBED \ -1157040128 // 0xBB08F800 -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE_UNDER_SUBSCRIBED \ +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_UNDER_SUBSCRIBED \ -1157040127 // 0xBB08F801 -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_COUNT \ +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_COUNT \ -1157040126 // 0xBB08F802 -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_REPETITION \ - -1157040125 // 0xBB08F803 -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE -1157040124 // 0xBB08F804 -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_MINIMUM_CODE_LENGTH \ - -1157040123 // 0xBB08F805 -#define WUFFS_FLATE__ERROR_BAD_DISTANCE -1157040122 // 0xBB08F806 -#define WUFFS_FLATE__ERROR_BAD_DISTANCE_CODE_COUNT -1157040121 // 0xBB08F807 -#define WUFFS_FLATE__ERROR_BAD_FLATE_BLOCK -1157040120 // 0xBB08F808 -#define WUFFS_FLATE__ERROR_BAD_LITERAL_LENGTH_CODE_COUNT \ +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_REPETITION \ + -1157040125 // 0xBB08F803 +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE -1157040124 // 0xBB08F804 +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_MINIMUM_CODE_LENGTH \ + -1157040123 // 0xBB08F805 +#define WUFFS_DEFLATE__ERROR_BAD_DISTANCE -1157040122 // 0xBB08F806 +#define WUFFS_DEFLATE__ERROR_BAD_DISTANCE_CODE_COUNT -1157040121 // 0xBB08F807 +#define WUFFS_DEFLATE__ERROR_BAD_FLATE_BLOCK -1157040120 // 0xBB08F808 +#define WUFFS_DEFLATE__ERROR_BAD_LITERAL_LENGTH_CODE_COUNT \ -1157040119 // 0xBB08F809 -#define WUFFS_FLATE__ERROR_INCONSISTENT_STORED_BLOCK_LENGTH \ +#define WUFFS_DEFLATE__ERROR_INCONSISTENT_STORED_BLOCK_LENGTH \ -1157040118 // 0xBB08F80A -#define WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE \ +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE \ -1157040117 // 0xBB08F80B -#define WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_END_OF_BLOCK \ +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_END_OF_BLOCK \ -1157040116 // 0xBB08F80C -#define WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_DISTANCE \ +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_DISTANCE \ -1157040115 // 0xBB08F80D -#define WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS \ - -1157040114 // 0xBB08F80E -#define WUFFS_FLATE__ERROR_MISSING_END_OF_BLOCK_CODE -1157040113 // 0xBB08F80F -#define WUFFS_FLATE__ERROR_NO_HUFFMAN_CODES -1157040112 // 0xBB08F810 +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS \ + -1157040114 // 0xBB08F80E +#define WUFFS_DEFLATE__ERROR_MISSING_END_OF_BLOCK_CODE \ + -1157040113 // 0xBB08F80F +#define WUFFS_DEFLATE__ERROR_NO_HUFFMAN_CODES -1157040112 // 0xBB08F810 -bool wuffs_flate__status__is_error(wuffs_flate__status s); +bool wuffs_deflate__status__is_error(wuffs_deflate__status s); -const char* wuffs_flate__status__string(wuffs_flate__status s); +const char* wuffs_deflate__status__string(wuffs_deflate__status s); // ---------------- Public Consts @@ -188,13 +190,13 @@ const char* wuffs_flate__status__string(wuffs_flate__status s); typedef struct { // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. Instead, use the - // wuffs_flate__flate_decoder__etc functions. + // wuffs_deflate__flate_decoder__etc functions. // // In C++, these fields would be "private", but C does not support that. // // It is a struct, not a struct*, so that it can be stack allocated. struct { - wuffs_flate__status status; + wuffs_deflate__status status; uint32_t magic; uint32_t f_bits; @@ -208,7 +210,7 @@ typedef struct { struct { uint32_t coro_susp_point; - wuffs_flate__status v_z; + wuffs_deflate__status v_z; uint64_t v_n_copied; uint32_t v_already_full; } c_decode[1]; @@ -259,23 +261,25 @@ typedef struct { uint32_t v_hdist; } c_decode_huffman_slow[1]; } private_impl; -} wuffs_flate__flate_decoder; +} wuffs_deflate__flate_decoder; // ---------------- Public Initializer Prototypes -// wuffs_flate__flate_decoder__initialize is an initializer function. +// wuffs_deflate__flate_decoder__initialize is an initializer function. // -// It should be called before any other wuffs_flate__flate_decoder__* function. +// It should be called before any other wuffs_deflate__flate_decoder__* +// function. // // Pass WUFFS_VERSION and 0 for wuffs_version and for_internal_use_only. -void wuffs_flate__flate_decoder__initialize(wuffs_flate__flate_decoder* self, - uint32_t wuffs_version, - uint32_t for_internal_use_only); +void wuffs_deflate__flate_decoder__initialize( + wuffs_deflate__flate_decoder* self, + uint32_t wuffs_version, + uint32_t for_internal_use_only); // ---------------- Public Function Prototypes -wuffs_flate__status wuffs_flate__flate_decoder__decode( - wuffs_flate__flate_decoder* self, +wuffs_deflate__status wuffs_deflate__flate_decoder__decode( + wuffs_deflate__flate_decoder* self, wuffs_base__writer1 a_dst, wuffs_base__reader1 a_src); @@ -283,9 +287,9 @@ wuffs_flate__status wuffs_flate__flate_decoder__decode( } // extern "C" #endif -#endif // WUFFS_FLATE_H +#endif // WUFFS_DEFLATE_H -// ---------------- END USE "std/flate" +// ---------------- END USE "std/deflate" #ifdef __cplusplus extern "C" { @@ -363,7 +367,7 @@ typedef struct { wuffs_zlib__status status; uint32_t magic; - wuffs_flate__flate_decoder f_flate; + wuffs_deflate__flate_decoder f_flate; wuffs_zlib__adler32 f_adler; struct { @@ -598,9 +602,9 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32( } else { n = length; } - // TODO: unrolling by 3 seems best for the std/flate benchmarks, but that is - // mostly because 3 is the minimum length for the flate format. This function - // implementation shouldn't overfit to that one format. Perhaps the + // TODO: unrolling by 3 seems best for the std/deflate benchmarks, but that + // is mostly because 3 is the minimum length for the deflate format. This + // function implementation shouldn't overfit to that one format. Perhaps the // copy_from_history32 Wuffs method should also take an unroll hint argument, // and the cgen can look if that argument is the constant expression '3'. // @@ -837,7 +841,7 @@ void wuffs_zlib__decoder__initialize(wuffs_zlib__decoder* self, memset(self, 0, sizeof(*self)); } self->private_impl.magic = WUFFS_BASE__MAGIC; - wuffs_flate__flate_decoder__initialize( + wuffs_deflate__flate_decoder__initialize( &self->private_impl.f_flate, WUFFS_VERSION, WUFFS_BASE__ALREADY_ZEROED); wuffs_zlib__adler32__initialize(&self->private_impl.f_adler, WUFFS_VERSION, WUFFS_BASE__ALREADY_ZEROED); @@ -975,7 +979,7 @@ wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, } } } - wuffs_zlib__status t_2 = wuffs_flate__flate_decoder__decode( + wuffs_zlib__status t_2 = wuffs_deflate__flate_decoder__decode( &self->private_impl.f_flate, a_dst, a_src); if (a_dst.buf) { b_wptr_dst = a_dst.buf->ptr + a_dst.buf->wi; diff --git a/gen/h/std/flate.h b/gen/h/std/deflate.h similarity index 68% rename from gen/h/std/flate.h rename to gen/h/std/deflate.h index 9c14fbb0..77337544 100644 --- a/gen/h/std/flate.h +++ b/gen/h/std/deflate.h @@ -1,5 +1,5 @@ -#ifndef WUFFS_FLATE_H -#define WUFFS_FLATE_H +#ifndef WUFFS_DEFLATE_H +#define WUFFS_DEFLATE_H // Code generated by wuffs-c. DO NOT EDIT. @@ -122,55 +122,57 @@ extern "C" { // - bits 0-7 are a package-namespaced numeric code // // Do not manipulate these bits directly. Use the API functions such as -// wuffs_flate__status__is_error instead. -typedef int32_t wuffs_flate__status; +// wuffs_deflate__status__is_error instead. +typedef int32_t wuffs_deflate__status; -#define wuffs_flate__packageid 967230 // 0x000EC23E +#define wuffs_deflate__packageid 967230 // 0x000EC23E -#define WUFFS_FLATE__STATUS_OK 0 // 0x00000000 -#define WUFFS_FLATE__ERROR_BAD_WUFFS_VERSION -2147483647 // 0x80000001 -#define WUFFS_FLATE__ERROR_BAD_RECEIVER -2147483646 // 0x80000002 -#define WUFFS_FLATE__ERROR_BAD_ARGUMENT -2147483645 // 0x80000003 -#define WUFFS_FLATE__ERROR_INITIALIZER_NOT_CALLED -2147483644 // 0x80000004 -#define WUFFS_FLATE__ERROR_INVALID_I_O_OPERATION -2147483643 // 0x80000005 -#define WUFFS_FLATE__ERROR_CLOSED_FOR_WRITES -2147483642 // 0x80000006 -#define WUFFS_FLATE__ERROR_UNEXPECTED_EOF -2147483641 // 0x80000007 -#define WUFFS_FLATE__SUSPENSION_SHORT_READ 8 // 0x00000008 -#define WUFFS_FLATE__SUSPENSION_SHORT_WRITE 9 // 0x00000009 -#define WUFFS_FLATE__ERROR_CANNOT_RETURN_A_SUSPENSION -2147483638 // 0x8000000A +#define WUFFS_DEFLATE__STATUS_OK 0 // 0x00000000 +#define WUFFS_DEFLATE__ERROR_BAD_WUFFS_VERSION -2147483647 // 0x80000001 +#define WUFFS_DEFLATE__ERROR_BAD_RECEIVER -2147483646 // 0x80000002 +#define WUFFS_DEFLATE__ERROR_BAD_ARGUMENT -2147483645 // 0x80000003 +#define WUFFS_DEFLATE__ERROR_INITIALIZER_NOT_CALLED -2147483644 // 0x80000004 +#define WUFFS_DEFLATE__ERROR_INVALID_I_O_OPERATION -2147483643 // 0x80000005 +#define WUFFS_DEFLATE__ERROR_CLOSED_FOR_WRITES -2147483642 // 0x80000006 +#define WUFFS_DEFLATE__ERROR_UNEXPECTED_EOF -2147483641 // 0x80000007 +#define WUFFS_DEFLATE__SUSPENSION_SHORT_READ 8 // 0x00000008 +#define WUFFS_DEFLATE__SUSPENSION_SHORT_WRITE 9 // 0x00000009 +#define WUFFS_DEFLATE__ERROR_CANNOT_RETURN_A_SUSPENSION \ + -2147483638 // 0x8000000A -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE_OVER_SUBSCRIBED \ +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_OVER_SUBSCRIBED \ -1157040128 // 0xBB08F800 -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE_UNDER_SUBSCRIBED \ +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_UNDER_SUBSCRIBED \ -1157040127 // 0xBB08F801 -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_COUNT \ +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_COUNT \ -1157040126 // 0xBB08F802 -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_REPETITION \ - -1157040125 // 0xBB08F803 -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE -1157040124 // 0xBB08F804 -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_MINIMUM_CODE_LENGTH \ - -1157040123 // 0xBB08F805 -#define WUFFS_FLATE__ERROR_BAD_DISTANCE -1157040122 // 0xBB08F806 -#define WUFFS_FLATE__ERROR_BAD_DISTANCE_CODE_COUNT -1157040121 // 0xBB08F807 -#define WUFFS_FLATE__ERROR_BAD_FLATE_BLOCK -1157040120 // 0xBB08F808 -#define WUFFS_FLATE__ERROR_BAD_LITERAL_LENGTH_CODE_COUNT \ +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_REPETITION \ + -1157040125 // 0xBB08F803 +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE -1157040124 // 0xBB08F804 +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_MINIMUM_CODE_LENGTH \ + -1157040123 // 0xBB08F805 +#define WUFFS_DEFLATE__ERROR_BAD_DISTANCE -1157040122 // 0xBB08F806 +#define WUFFS_DEFLATE__ERROR_BAD_DISTANCE_CODE_COUNT -1157040121 // 0xBB08F807 +#define WUFFS_DEFLATE__ERROR_BAD_FLATE_BLOCK -1157040120 // 0xBB08F808 +#define WUFFS_DEFLATE__ERROR_BAD_LITERAL_LENGTH_CODE_COUNT \ -1157040119 // 0xBB08F809 -#define WUFFS_FLATE__ERROR_INCONSISTENT_STORED_BLOCK_LENGTH \ +#define WUFFS_DEFLATE__ERROR_INCONSISTENT_STORED_BLOCK_LENGTH \ -1157040118 // 0xBB08F80A -#define WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE \ +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE \ -1157040117 // 0xBB08F80B -#define WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_END_OF_BLOCK \ +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_END_OF_BLOCK \ -1157040116 // 0xBB08F80C -#define WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_DISTANCE \ +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_DISTANCE \ -1157040115 // 0xBB08F80D -#define WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS \ - -1157040114 // 0xBB08F80E -#define WUFFS_FLATE__ERROR_MISSING_END_OF_BLOCK_CODE -1157040113 // 0xBB08F80F -#define WUFFS_FLATE__ERROR_NO_HUFFMAN_CODES -1157040112 // 0xBB08F810 +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS \ + -1157040114 // 0xBB08F80E +#define WUFFS_DEFLATE__ERROR_MISSING_END_OF_BLOCK_CODE \ + -1157040113 // 0xBB08F80F +#define WUFFS_DEFLATE__ERROR_NO_HUFFMAN_CODES -1157040112 // 0xBB08F810 -bool wuffs_flate__status__is_error(wuffs_flate__status s); +bool wuffs_deflate__status__is_error(wuffs_deflate__status s); -const char* wuffs_flate__status__string(wuffs_flate__status s); +const char* wuffs_deflate__status__string(wuffs_deflate__status s); // ---------------- Public Consts @@ -179,13 +181,13 @@ const char* wuffs_flate__status__string(wuffs_flate__status s); typedef struct { // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. Instead, use the - // wuffs_flate__flate_decoder__etc functions. + // wuffs_deflate__flate_decoder__etc functions. // // In C++, these fields would be "private", but C does not support that. // // It is a struct, not a struct*, so that it can be stack allocated. struct { - wuffs_flate__status status; + wuffs_deflate__status status; uint32_t magic; uint32_t f_bits; @@ -199,7 +201,7 @@ typedef struct { struct { uint32_t coro_susp_point; - wuffs_flate__status v_z; + wuffs_deflate__status v_z; uint64_t v_n_copied; uint32_t v_already_full; } c_decode[1]; @@ -250,23 +252,25 @@ typedef struct { uint32_t v_hdist; } c_decode_huffman_slow[1]; } private_impl; -} wuffs_flate__flate_decoder; +} wuffs_deflate__flate_decoder; // ---------------- Public Initializer Prototypes -// wuffs_flate__flate_decoder__initialize is an initializer function. +// wuffs_deflate__flate_decoder__initialize is an initializer function. // -// It should be called before any other wuffs_flate__flate_decoder__* function. +// It should be called before any other wuffs_deflate__flate_decoder__* +// function. // // Pass WUFFS_VERSION and 0 for wuffs_version and for_internal_use_only. -void wuffs_flate__flate_decoder__initialize(wuffs_flate__flate_decoder* self, - uint32_t wuffs_version, - uint32_t for_internal_use_only); +void wuffs_deflate__flate_decoder__initialize( + wuffs_deflate__flate_decoder* self, + uint32_t wuffs_version, + uint32_t for_internal_use_only); // ---------------- Public Function Prototypes -wuffs_flate__status wuffs_flate__flate_decoder__decode( - wuffs_flate__flate_decoder* self, +wuffs_deflate__status wuffs_deflate__flate_decoder__decode( + wuffs_deflate__flate_decoder* self, wuffs_base__writer1 a_dst, wuffs_base__reader1 a_src); @@ -274,4 +278,4 @@ wuffs_flate__status wuffs_flate__flate_decoder__decode( } // extern "C" #endif -#endif // WUFFS_FLATE_H +#endif // WUFFS_DEFLATE_H diff --git a/gen/h/std/zlib.h b/gen/h/std/zlib.h index 28fc0cda..7ec20cd0 100644 --- a/gen/h/std/zlib.h +++ b/gen/h/std/zlib.h @@ -109,10 +109,10 @@ typedef struct { // ---------------- Use Declarations -// ---------------- BEGIN USE "std/flate" +// ---------------- BEGIN USE "std/deflate" -#ifndef WUFFS_FLATE_H -#define WUFFS_FLATE_H +#ifndef WUFFS_DEFLATE_H +#define WUFFS_DEFLATE_H // Code generated by wuffs-c. DO NOT EDIT. @@ -131,55 +131,57 @@ extern "C" { // - bits 0-7 are a package-namespaced numeric code // // Do not manipulate these bits directly. Use the API functions such as -// wuffs_flate__status__is_error instead. -typedef int32_t wuffs_flate__status; +// wuffs_deflate__status__is_error instead. +typedef int32_t wuffs_deflate__status; -#define wuffs_flate__packageid 967230 // 0x000EC23E +#define wuffs_deflate__packageid 967230 // 0x000EC23E -#define WUFFS_FLATE__STATUS_OK 0 // 0x00000000 -#define WUFFS_FLATE__ERROR_BAD_WUFFS_VERSION -2147483647 // 0x80000001 -#define WUFFS_FLATE__ERROR_BAD_RECEIVER -2147483646 // 0x80000002 -#define WUFFS_FLATE__ERROR_BAD_ARGUMENT -2147483645 // 0x80000003 -#define WUFFS_FLATE__ERROR_INITIALIZER_NOT_CALLED -2147483644 // 0x80000004 -#define WUFFS_FLATE__ERROR_INVALID_I_O_OPERATION -2147483643 // 0x80000005 -#define WUFFS_FLATE__ERROR_CLOSED_FOR_WRITES -2147483642 // 0x80000006 -#define WUFFS_FLATE__ERROR_UNEXPECTED_EOF -2147483641 // 0x80000007 -#define WUFFS_FLATE__SUSPENSION_SHORT_READ 8 // 0x00000008 -#define WUFFS_FLATE__SUSPENSION_SHORT_WRITE 9 // 0x00000009 -#define WUFFS_FLATE__ERROR_CANNOT_RETURN_A_SUSPENSION -2147483638 // 0x8000000A +#define WUFFS_DEFLATE__STATUS_OK 0 // 0x00000000 +#define WUFFS_DEFLATE__ERROR_BAD_WUFFS_VERSION -2147483647 // 0x80000001 +#define WUFFS_DEFLATE__ERROR_BAD_RECEIVER -2147483646 // 0x80000002 +#define WUFFS_DEFLATE__ERROR_BAD_ARGUMENT -2147483645 // 0x80000003 +#define WUFFS_DEFLATE__ERROR_INITIALIZER_NOT_CALLED -2147483644 // 0x80000004 +#define WUFFS_DEFLATE__ERROR_INVALID_I_O_OPERATION -2147483643 // 0x80000005 +#define WUFFS_DEFLATE__ERROR_CLOSED_FOR_WRITES -2147483642 // 0x80000006 +#define WUFFS_DEFLATE__ERROR_UNEXPECTED_EOF -2147483641 // 0x80000007 +#define WUFFS_DEFLATE__SUSPENSION_SHORT_READ 8 // 0x00000008 +#define WUFFS_DEFLATE__SUSPENSION_SHORT_WRITE 9 // 0x00000009 +#define WUFFS_DEFLATE__ERROR_CANNOT_RETURN_A_SUSPENSION \ + -2147483638 // 0x8000000A -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE_OVER_SUBSCRIBED \ +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_OVER_SUBSCRIBED \ -1157040128 // 0xBB08F800 -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE_UNDER_SUBSCRIBED \ +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_UNDER_SUBSCRIBED \ -1157040127 // 0xBB08F801 -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_COUNT \ +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_COUNT \ -1157040126 // 0xBB08F802 -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_REPETITION \ - -1157040125 // 0xBB08F803 -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_CODE -1157040124 // 0xBB08F804 -#define WUFFS_FLATE__ERROR_BAD_HUFFMAN_MINIMUM_CODE_LENGTH \ - -1157040123 // 0xBB08F805 -#define WUFFS_FLATE__ERROR_BAD_DISTANCE -1157040122 // 0xBB08F806 -#define WUFFS_FLATE__ERROR_BAD_DISTANCE_CODE_COUNT -1157040121 // 0xBB08F807 -#define WUFFS_FLATE__ERROR_BAD_FLATE_BLOCK -1157040120 // 0xBB08F808 -#define WUFFS_FLATE__ERROR_BAD_LITERAL_LENGTH_CODE_COUNT \ +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_REPETITION \ + -1157040125 // 0xBB08F803 +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE -1157040124 // 0xBB08F804 +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_MINIMUM_CODE_LENGTH \ + -1157040123 // 0xBB08F805 +#define WUFFS_DEFLATE__ERROR_BAD_DISTANCE -1157040122 // 0xBB08F806 +#define WUFFS_DEFLATE__ERROR_BAD_DISTANCE_CODE_COUNT -1157040121 // 0xBB08F807 +#define WUFFS_DEFLATE__ERROR_BAD_FLATE_BLOCK -1157040120 // 0xBB08F808 +#define WUFFS_DEFLATE__ERROR_BAD_LITERAL_LENGTH_CODE_COUNT \ -1157040119 // 0xBB08F809 -#define WUFFS_FLATE__ERROR_INCONSISTENT_STORED_BLOCK_LENGTH \ +#define WUFFS_DEFLATE__ERROR_INCONSISTENT_STORED_BLOCK_LENGTH \ -1157040118 // 0xBB08F80A -#define WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE \ +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE \ -1157040117 // 0xBB08F80B -#define WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_END_OF_BLOCK \ +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_END_OF_BLOCK \ -1157040116 // 0xBB08F80C -#define WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_DISTANCE \ +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_DISTANCE \ -1157040115 // 0xBB08F80D -#define WUFFS_FLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS \ - -1157040114 // 0xBB08F80E -#define WUFFS_FLATE__ERROR_MISSING_END_OF_BLOCK_CODE -1157040113 // 0xBB08F80F -#define WUFFS_FLATE__ERROR_NO_HUFFMAN_CODES -1157040112 // 0xBB08F810 +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS \ + -1157040114 // 0xBB08F80E +#define WUFFS_DEFLATE__ERROR_MISSING_END_OF_BLOCK_CODE \ + -1157040113 // 0xBB08F80F +#define WUFFS_DEFLATE__ERROR_NO_HUFFMAN_CODES -1157040112 // 0xBB08F810 -bool wuffs_flate__status__is_error(wuffs_flate__status s); +bool wuffs_deflate__status__is_error(wuffs_deflate__status s); -const char* wuffs_flate__status__string(wuffs_flate__status s); +const char* wuffs_deflate__status__string(wuffs_deflate__status s); // ---------------- Public Consts @@ -188,13 +190,13 @@ const char* wuffs_flate__status__string(wuffs_flate__status s); typedef struct { // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. Instead, use the - // wuffs_flate__flate_decoder__etc functions. + // wuffs_deflate__flate_decoder__etc functions. // // In C++, these fields would be "private", but C does not support that. // // It is a struct, not a struct*, so that it can be stack allocated. struct { - wuffs_flate__status status; + wuffs_deflate__status status; uint32_t magic; uint32_t f_bits; @@ -208,7 +210,7 @@ typedef struct { struct { uint32_t coro_susp_point; - wuffs_flate__status v_z; + wuffs_deflate__status v_z; uint64_t v_n_copied; uint32_t v_already_full; } c_decode[1]; @@ -259,23 +261,25 @@ typedef struct { uint32_t v_hdist; } c_decode_huffman_slow[1]; } private_impl; -} wuffs_flate__flate_decoder; +} wuffs_deflate__flate_decoder; // ---------------- Public Initializer Prototypes -// wuffs_flate__flate_decoder__initialize is an initializer function. +// wuffs_deflate__flate_decoder__initialize is an initializer function. // -// It should be called before any other wuffs_flate__flate_decoder__* function. +// It should be called before any other wuffs_deflate__flate_decoder__* +// function. // // Pass WUFFS_VERSION and 0 for wuffs_version and for_internal_use_only. -void wuffs_flate__flate_decoder__initialize(wuffs_flate__flate_decoder* self, - uint32_t wuffs_version, - uint32_t for_internal_use_only); +void wuffs_deflate__flate_decoder__initialize( + wuffs_deflate__flate_decoder* self, + uint32_t wuffs_version, + uint32_t for_internal_use_only); // ---------------- Public Function Prototypes -wuffs_flate__status wuffs_flate__flate_decoder__decode( - wuffs_flate__flate_decoder* self, +wuffs_deflate__status wuffs_deflate__flate_decoder__decode( + wuffs_deflate__flate_decoder* self, wuffs_base__writer1 a_dst, wuffs_base__reader1 a_src); @@ -283,9 +287,9 @@ wuffs_flate__status wuffs_flate__flate_decoder__decode( } // extern "C" #endif -#endif // WUFFS_FLATE_H +#endif // WUFFS_DEFLATE_H -// ---------------- END USE "std/flate" +// ---------------- END USE "std/deflate" #ifdef __cplusplus extern "C" { @@ -363,7 +367,7 @@ typedef struct { wuffs_zlib__status status; uint32_t magic; - wuffs_flate__flate_decoder f_flate; + wuffs_deflate__flate_decoder f_flate; wuffs_zlib__adler32 f_adler; struct { diff --git a/lang/check/type.go b/lang/check/type.go index b7971654..46b0a868 100644 --- a/lang/check/type.go +++ b/lang/check/type.go @@ -1115,8 +1115,8 @@ swtch: } default: - // TODO: don't hard-code flate.flate_decoder as an acceptable type. - if q.tm.ByID(n.Decorator()) == "flate" && q.tm.ByID(n.Name()) == "flate_decoder" { + // TODO: don't hard-code deflate.flate_decoder as an acceptable type. + if q.tm.ByID(n.Decorator()) == "deflate" && q.tm.ByID(n.Name()) == "flate_decoder" { break } return fmt.Errorf("check: unrecognized node for tcheckTypeExpr") diff --git a/std/flate/README.md b/std/deflate/README.md similarity index 100% rename from std/flate/README.md rename to std/deflate/README.md diff --git a/std/flate/codec_consts.wuffs b/std/deflate/codec_consts.wuffs similarity index 100% rename from std/flate/codec_consts.wuffs rename to std/deflate/codec_consts.wuffs diff --git a/std/flate/decode_flate.wuffs b/std/deflate/decode_deflate.wuffs similarity index 99% rename from std/flate/decode_flate.wuffs rename to std/deflate/decode_deflate.wuffs index d6160e2c..9dbbdde2 100644 --- a/std/flate/decode_flate.wuffs +++ b/std/deflate/decode_deflate.wuffs @@ -17,8 +17,6 @@ packageid "flte" // TODO: rename "struct flate_decoder" to just "struct decoder", to avoid // stutter in the fully qualified C name such as "wuffs_flate__flate_decoder". -// TODO: rename flate to deflate, since that's what RFC 1951 calls it. - pub error "bad Huffman code (over-subscribed)" pub error "bad Huffman code (under-subscribed)" pub error "bad Huffman code length count" diff --git a/std/flate/decode_huffman_fast.wuffs b/std/deflate/decode_huffman_fast.wuffs similarity index 100% rename from std/flate/decode_huffman_fast.wuffs rename to std/deflate/decode_huffman_fast.wuffs diff --git a/std/flate/decode_huffman_slow.wuffs b/std/deflate/decode_huffman_slow.wuffs similarity index 100% rename from std/flate/decode_huffman_slow.wuffs rename to std/deflate/decode_huffman_slow.wuffs diff --git a/std/zlib/decode_zlib.wuffs b/std/zlib/decode_zlib.wuffs index 611f3042..86568b68 100644 --- a/std/zlib/decode_zlib.wuffs +++ b/std/zlib/decode_zlib.wuffs @@ -14,7 +14,7 @@ packageid "zlib" -use "std/flate" +use "std/deflate" pub error "checksum mismatch" pub error "invalid zlib compression method" @@ -24,7 +24,7 @@ pub error "invalid zlib parity check" pub error "TODO: unsupported zlib preset dictionary" pub struct decoder?( - flate flate.flate_decoder, + flate deflate.flate_decoder, adler adler32, ) diff --git a/test/c/mimiclib/deflate-gzip-zlib.c b/test/c/mimiclib/deflate-gzip-zlib.c index 76b6e118..1274532d 100644 --- a/test/c/mimiclib/deflate-gzip-zlib.c +++ b/test/c/mimiclib/deflate-gzip-zlib.c @@ -46,13 +46,13 @@ const char* mimic_bench_crc32(wuffs_base__buf1* dst, return NULL; } -unsigned int mimic_flate_read_func(void* ctx, unsigned char** buf) { +unsigned int mimic_deflate_read_func(void* ctx, unsigned char** buf) { wuffs_base__buf1* src = (wuffs_base__buf1*)(ctx); *buf = src->ptr + src->ri; return src->wi - src->ri; } -int mimic_flate_write_func(void* ctx, unsigned char* ptr, unsigned int len) { +int mimic_deflate_write_func(void* ctx, unsigned char* ptr, unsigned int len) { wuffs_base__buf1* dst = (wuffs_base__buf1*)(ctx); size_t n = len; if (n > dst->len - dst->wi) { @@ -63,10 +63,10 @@ int mimic_flate_write_func(void* ctx, unsigned char* ptr, unsigned int len) { return 0; } -const char* mimic_flate_decode(wuffs_base__buf1* dst, - wuffs_base__buf1* src, - uint64_t wlimit, - uint64_t rlimit) { +const char* mimic_deflate_decode(wuffs_base__buf1* dst, + wuffs_base__buf1* src, + uint64_t wlimit, + uint64_t rlimit) { // TODO: don't ignore wlimit and rlimit. const char* ret = NULL; uint8_t window[32 * 1024]; @@ -79,8 +79,8 @@ const char* mimic_flate_decode(wuffs_base__buf1* dst, goto cleanup0; } - int ib_err = - inflateBack(&z, mimic_flate_read_func, src, mimic_flate_write_func, dst); + int ib_err = inflateBack(&z, mimic_deflate_read_func, src, + mimic_deflate_write_func, dst); if (ib_err != Z_STREAM_END) { ret = "inflateBack failed"; goto cleanup1; diff --git a/test/c/std/flate.c b/test/c/std/deflate.c similarity index 68% rename from test/c/std/flate.c rename to test/c/std/deflate.c index 2a0edfef..0e29d0de 100644 --- a/test/c/std/flate.c +++ b/test/c/std/deflate.c @@ -21,7 +21,7 @@ giflib for GIF, libpng for PNG, etc. To manually run this test: for cc in clang gcc; do - $cc -std=c99 -Wall -Werror flate.c && ./a.out + $cc -std=c99 -Wall -Werror deflate.c && ./a.out rm -f a.out done @@ -40,7 +40,7 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the // If building this program in an environment that doesn't easily accomodate // relative includes, you can use the script/inline-c-relative-includes.go // program to generate a stand-alone C file. -#include "../../../gen/c/std/flate.c" +#include "../../../gen/c/std/deflate.c" #include "../testlib/testlib.c" #ifdef WUFFS_MIMIC #include "../mimiclib/deflate-gzip-zlib.c" @@ -62,14 +62,14 @@ golden_test crc32_pi_gt = { .src_filename = "../../testdata/pi.txt", // }; -golden_test flate_256_bytes_gt = { +golden_test deflate_256_bytes_gt = { .want_filename = "../../testdata/artificial/256.bytes", // .src_filename = "../../testdata/artificial/256.bytes.gz", // .src_offset0 = 20, // .src_offset1 = 281, // }; -golden_test flate_flate_backref_crosses_blocks_gt = { +golden_test deflate_deflate_backref_crosses_blocks_gt = { .want_filename = "../../testdata/artificial/" "flate-backref-crosses-blocks.flate.decompressed", @@ -78,28 +78,28 @@ golden_test flate_flate_backref_crosses_blocks_gt = { "flate-backref-crosses-blocks.flate", }; -golden_test flate_midsummer_gt = { +golden_test deflate_midsummer_gt = { .want_filename = "../../testdata/midsummer.txt", // .src_filename = "../../testdata/midsummer.txt.gz", // .src_offset0 = 24, // .src_offset1 = 5166, // }; -golden_test flate_pi_gt = { +golden_test deflate_pi_gt = { .want_filename = "../../testdata/pi.txt", // .src_filename = "../../testdata/pi.txt.gz", // .src_offset0 = 17, // .src_offset1 = 48335, // }; -golden_test flate_romeo_gt = { +golden_test deflate_romeo_gt = { .want_filename = "../../testdata/romeo.txt", // .src_filename = "../../testdata/romeo.txt.gz", // .src_offset0 = 20, // .src_offset1 = 550, // }; -golden_test flate_romeo_fixed_gt = { +golden_test deflate_romeo_fixed_gt = { .want_filename = "../../testdata/romeo.txt", // .src_filename = "../../testdata/romeo.txt.fixed-huff.flate", // }; @@ -114,14 +114,14 @@ golden_test gzip_pi_gt = { .src_filename = "../../testdata/pi.txt.gz", // }; -// ---------------- Flate Tests +// ---------------- Deflate Tests -const char* wuffs_flate_decode(wuffs_base__buf1* dst, - wuffs_base__buf1* src, - uint64_t wlimit, - uint64_t rlimit) { - wuffs_flate__flate_decoder dec; - wuffs_flate__flate_decoder__initialize(&dec, WUFFS_VERSION, 0); +const char* wuffs_deflate_decode(wuffs_base__buf1* dst, + wuffs_base__buf1* src, + uint64_t wlimit, + uint64_t rlimit) { + wuffs_deflate__flate_decoder dec; + wuffs_deflate__flate_decoder__initialize(&dec, WUFFS_VERSION, 0); uint64_t wlim = 0; uint64_t rlim = 0; while (true) { @@ -136,74 +136,74 @@ const char* wuffs_flate_decode(wuffs_base__buf1* dst, src_reader.private_impl.limit.ptr_to_len = &rlim; } - wuffs_flate__status s = - wuffs_flate__flate_decoder__decode(&dec, dst_writer, src_reader); + wuffs_deflate__status s = + wuffs_deflate__flate_decoder__decode(&dec, dst_writer, src_reader); - if (s == WUFFS_FLATE__STATUS_OK) { + if (s == WUFFS_DEFLATE__STATUS_OK) { return NULL; } - if ((wlimit && (s == WUFFS_FLATE__SUSPENSION_SHORT_WRITE)) || - (rlimit && (s == WUFFS_FLATE__SUSPENSION_SHORT_READ))) { + if ((wlimit && (s == WUFFS_DEFLATE__SUSPENSION_SHORT_WRITE)) || + (rlimit && (s == WUFFS_DEFLATE__SUSPENSION_SHORT_READ))) { continue; } - return wuffs_flate__status__string(s); + return wuffs_deflate__status__string(s); } } -void test_wuffs_flate_decode_256_bytes() { +void test_wuffs_deflate_decode_256_bytes() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_flate_decode, &flate_256_bytes_gt, 0, 0); + do_test_buf1_buf1(wuffs_deflate_decode, &deflate_256_bytes_gt, 0, 0); } -void test_wuffs_flate_decode_flate_backref_crosses_blocks() { +void test_wuffs_deflate_decode_flate_backref_crosses_blocks() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_flate_decode, &flate_flate_backref_crosses_blocks_gt, - 0, 0); + do_test_buf1_buf1(wuffs_deflate_decode, + &deflate_deflate_backref_crosses_blocks_gt, 0, 0); } -void test_wuffs_flate_decode_midsummer() { +void test_wuffs_deflate_decode_midsummer() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_flate_decode, &flate_midsummer_gt, 0, 0); + do_test_buf1_buf1(wuffs_deflate_decode, &deflate_midsummer_gt, 0, 0); } -void test_wuffs_flate_decode_pi() { +void test_wuffs_deflate_decode_pi() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_flate_decode, &flate_pi_gt, 0, 0); + do_test_buf1_buf1(wuffs_deflate_decode, &deflate_pi_gt, 0, 0); } -void test_wuffs_flate_decode_pi_many_big_reads() { +void test_wuffs_deflate_decode_pi_many_big_reads() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_flate_decode, &flate_pi_gt, 0, 4096); + do_test_buf1_buf1(wuffs_deflate_decode, &deflate_pi_gt, 0, 4096); } -void test_wuffs_flate_decode_pi_many_medium_reads() { +void test_wuffs_deflate_decode_pi_many_medium_reads() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_flate_decode, &flate_pi_gt, 0, 599); + do_test_buf1_buf1(wuffs_deflate_decode, &deflate_pi_gt, 0, 599); } -void test_wuffs_flate_decode_pi_many_small_writes_reads() { +void test_wuffs_deflate_decode_pi_many_small_writes_reads() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_flate_decode, &flate_pi_gt, 59, 61); + do_test_buf1_buf1(wuffs_deflate_decode, &deflate_pi_gt, 59, 61); } -void test_wuffs_flate_decode_romeo() { +void test_wuffs_deflate_decode_romeo() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_flate_decode, &flate_romeo_gt, 0, 0); + do_test_buf1_buf1(wuffs_deflate_decode, &deflate_romeo_gt, 0, 0); } -void test_wuffs_flate_decode_romeo_fixed() { +void test_wuffs_deflate_decode_romeo_fixed() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(wuffs_flate_decode, &flate_romeo_fixed_gt, 0, 0); + do_test_buf1_buf1(wuffs_deflate_decode, &deflate_romeo_fixed_gt, 0, 0); } -void test_wuffs_flate_decode_split_src() { +void test_wuffs_deflate_decode_split_src() { CHECK_FOCUS(__func__); wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; wuffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE}; - golden_test* gt = &flate_256_bytes_gt; + golden_test* gt = &deflate_256_bytes_gt; if (!read_file(&src, gt->src_filename)) { return; } @@ -211,7 +211,7 @@ void test_wuffs_flate_decode_split_src() { return; } - wuffs_flate__flate_decoder dec; + wuffs_deflate__flate_decoder dec; wuffs_base__writer1 dst_writer = {.buf = &got}; wuffs_base__reader1 src_reader = {.buf = &src}; @@ -224,31 +224,32 @@ void test_wuffs_flate_decode_split_src() { } got.wi = 0; - wuffs_flate__flate_decoder__initialize(&dec, WUFFS_VERSION, 0); + wuffs_deflate__flate_decoder__initialize(&dec, WUFFS_VERSION, 0); src.closed = false; src.ri = gt->src_offset0; src.wi = split; - wuffs_flate__status s0 = - wuffs_flate__flate_decoder__decode(&dec, dst_writer, src_reader); + wuffs_deflate__status s0 = + wuffs_deflate__flate_decoder__decode(&dec, dst_writer, src_reader); src.closed = true; src.ri = split; src.wi = gt->src_offset1; - wuffs_flate__status s1 = - wuffs_flate__flate_decoder__decode(&dec, dst_writer, src_reader); + wuffs_deflate__status s1 = + wuffs_deflate__flate_decoder__decode(&dec, dst_writer, src_reader); - if (s0 != WUFFS_FLATE__SUSPENSION_SHORT_READ) { + if (s0 != WUFFS_DEFLATE__SUSPENSION_SHORT_READ) { FAIL("i=%d: s0: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", i, s0, - wuffs_flate__status__string(s0), WUFFS_FLATE__SUSPENSION_SHORT_READ, - wuffs_flate__status__string(WUFFS_FLATE__SUSPENSION_SHORT_READ)); + wuffs_deflate__status__string(s0), + WUFFS_DEFLATE__SUSPENSION_SHORT_READ, + wuffs_deflate__status__string(WUFFS_DEFLATE__SUSPENSION_SHORT_READ)); return; } - if (s1 != WUFFS_FLATE__STATUS_OK) { + if (s1 != WUFFS_DEFLATE__STATUS_OK) { FAIL("i=%d: s1: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", i, s1, - wuffs_flate__status__string(s1), WUFFS_FLATE__STATUS_OK, - wuffs_flate__status__string(WUFFS_FLATE__STATUS_OK)); + wuffs_deflate__status__string(s1), WUFFS_DEFLATE__STATUS_OK, + wuffs_deflate__status__string(WUFFS_DEFLATE__STATUS_OK)); return; } @@ -260,20 +261,20 @@ void test_wuffs_flate_decode_split_src() { } } -bool do_test_wuffs_flate_history(int i, - golden_test* gt, - wuffs_base__buf1* src, - wuffs_base__buf1* got, - wuffs_flate__flate_decoder* dec, - uint32_t starting_history_index, - uint64_t limit, - wuffs_flate__status want_s) { +bool do_test_wuffs_deflate_history(int i, + golden_test* gt, + wuffs_base__buf1* src, + wuffs_base__buf1* got, + wuffs_deflate__flate_decoder* dec, + uint32_t starting_history_index, + uint64_t limit, + wuffs_deflate__status want_s) { src->ri = gt->src_offset0; src->wi = gt->src_offset1; got->ri = 0; got->wi = 0; - wuffs_flate__flate_decoder__initialize(dec, WUFFS_VERSION, 0); + wuffs_deflate__flate_decoder__initialize(dec, WUFFS_VERSION, 0); wuffs_base__writer1 dst_writer = {.buf = got}; wuffs_base__reader1 src_reader = {.buf = src}; @@ -281,26 +282,26 @@ bool do_test_wuffs_flate_history(int i, dst_writer.private_impl.limit.ptr_to_len = &limit; - wuffs_flate__status got_s = - wuffs_flate__flate_decoder__decode(dec, dst_writer, src_reader); + wuffs_deflate__status got_s = + wuffs_deflate__flate_decoder__decode(dec, dst_writer, src_reader); if (got_s != want_s) { FAIL("i=%d: starting_history_index=0x%04" PRIX32 ": decode status: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", - i, starting_history_index, got_s, wuffs_flate__status__string(got_s), - want_s, wuffs_flate__status__string(want_s)); + i, starting_history_index, got_s, wuffs_deflate__status__string(got_s), + want_s, wuffs_deflate__status__string(want_s)); return false; } return true; } -void test_wuffs_flate_history_full() { +void test_wuffs_deflate_history_full() { CHECK_FOCUS(__func__); wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; wuffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE}; - golden_test* gt = &flate_pi_gt; + golden_test* gt = &deflate_pi_gt; if (!read_file(&src, gt->src_filename)) { return; } @@ -311,11 +312,11 @@ void test_wuffs_flate_history_full() { const int full_history_size = 0x8000; int i; for (i = -2; i <= +2; i++) { - wuffs_flate__flate_decoder dec; - if (!do_test_wuffs_flate_history( + wuffs_deflate__flate_decoder dec; + if (!do_test_wuffs_deflate_history( i, gt, &src, &got, &dec, 0, want.wi + i, - i >= 0 ? WUFFS_FLATE__STATUS_OK - : WUFFS_FLATE__SUSPENSION_SHORT_WRITE)) { + i >= 0 ? WUFFS_DEFLATE__STATUS_OK + : WUFFS_DEFLATE__SUSPENSION_SHORT_WRITE)) { return; } @@ -349,13 +350,13 @@ void test_wuffs_flate_history_full() { } } -void test_wuffs_flate_history_partial() { +void test_wuffs_deflate_history_partial() { CHECK_FOCUS(__func__); wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; - golden_test* gt = &flate_pi_gt; + golden_test* gt = &deflate_pi_gt; if (!read_file(&src, gt->src_filename)) { return; } @@ -373,10 +374,10 @@ void test_wuffs_flate_history_partial() { const char* fragment = "3.14"; const uint32_t fragment_length = 4; - wuffs_flate__flate_decoder dec; - if (!do_test_wuffs_flate_history(i, gt, &src, &got, &dec, - starting_history_index, fragment_length, - WUFFS_FLATE__SUSPENSION_SHORT_WRITE)) { + wuffs_deflate__flate_decoder dec; + if (!do_test_wuffs_deflate_history(i, gt, &src, &got, &dec, + starting_history_index, fragment_length, + WUFFS_DEFLATE__SUSPENSION_SHORT_WRITE)) { return; } @@ -408,7 +409,7 @@ void test_wuffs_flate_history_partial() { } } -void test_wuffs_flate_table_redirect() { +void test_wuffs_deflate_table_redirect() { CHECK_FOCUS(__func__); // Call init_huff with a Huffman code that looks like: @@ -454,8 +455,8 @@ void test_wuffs_flate_table_redirect() { // 1st is the key in the first level table (9 bits). // 2nd is the key in the second level table (variable bits). - wuffs_flate__flate_decoder dec; - wuffs_flate__flate_decoder__initialize(&dec, WUFFS_VERSION, 0); + wuffs_deflate__flate_decoder dec; + wuffs_deflate__flate_decoder__initialize(&dec, WUFFS_VERSION, 0); // The initializer should zero out dec's fields, but to be paranoid, we zero // it out explicitly. @@ -478,10 +479,10 @@ void test_wuffs_flate_table_redirect() { dec.private_impl.f_code_lengths[n++] = 13; dec.private_impl.f_code_lengths[n++] = 13; - wuffs_flate__status s = - wuffs_flate__flate_decoder__init_huff(&dec, 0, 0, n, 257); + wuffs_deflate__status s = + wuffs_deflate__flate_decoder__init_huff(&dec, 0, 0, n, 257); if (s) { - FAIL("%s", wuffs_flate__status__string(s)); + FAIL("%s", wuffs_deflate__status__string(s)); return; } @@ -544,35 +545,35 @@ void test_wuffs_flate_table_redirect() { #ifdef WUFFS_MIMIC -void test_mimic_flate_decode_256_bytes() { +void test_mimic_deflate_decode_256_bytes() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(mimic_flate_decode, &flate_256_bytes_gt, 0, 0); + do_test_buf1_buf1(mimic_deflate_decode, &deflate_256_bytes_gt, 0, 0); } -void test_mimic_flate_decode_flate_backref_crosses_blocks() { +void test_mimic_deflate_decode_flate_backref_crosses_blocks() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(mimic_flate_decode, &flate_flate_backref_crosses_blocks_gt, - 0, 0); + do_test_buf1_buf1(mimic_deflate_decode, + &deflate_deflate_backref_crosses_blocks_gt, 0, 0); } -void test_mimic_flate_decode_midsummer() { +void test_mimic_deflate_decode_midsummer() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(mimic_flate_decode, &flate_midsummer_gt, 0, 0); + do_test_buf1_buf1(mimic_deflate_decode, &deflate_midsummer_gt, 0, 0); } -void test_mimic_flate_decode_pi() { +void test_mimic_deflate_decode_pi() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(mimic_flate_decode, &flate_pi_gt, 0, 0); + do_test_buf1_buf1(mimic_deflate_decode, &deflate_pi_gt, 0, 0); } -void test_mimic_flate_decode_romeo() { +void test_mimic_deflate_decode_romeo() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(mimic_flate_decode, &flate_romeo_gt, 0, 0); + do_test_buf1_buf1(mimic_deflate_decode, &deflate_romeo_gt, 0, 0); } -void test_mimic_flate_decode_romeo_fixed() { +void test_mimic_deflate_decode_romeo_fixed() { CHECK_FOCUS(__func__); - do_test_buf1_buf1(mimic_flate_decode, &flate_romeo_fixed_gt, 0, 0); + do_test_buf1_buf1(mimic_deflate_decode, &deflate_romeo_fixed_gt, 0, 0); } void test_mimic_gzip_decode_midsummer() { @@ -587,22 +588,23 @@ void test_mimic_gzip_decode_pi() { #endif // WUFFS_MIMIC -// ---------------- Flate Benches +// ---------------- Deflate Benches -void bench_wuffs_flate_decode_1k() { +void bench_wuffs_deflate_decode_1k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(wuffs_flate_decode, tc_dst, &flate_romeo_gt, 0, 0, 200000); + do_bench_buf1_buf1(wuffs_deflate_decode, tc_dst, &deflate_romeo_gt, 0, 0, + 200000); } -void bench_wuffs_flate_decode_10k() { +void bench_wuffs_deflate_decode_10k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(wuffs_flate_decode, tc_dst, &flate_midsummer_gt, 0, 0, + do_bench_buf1_buf1(wuffs_deflate_decode, tc_dst, &deflate_midsummer_gt, 0, 0, 30000); } -void bench_wuffs_flate_decode_100k() { +void bench_wuffs_deflate_decode_100k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(wuffs_flate_decode, tc_dst, &flate_pi_gt, 0, 0, 3000); + do_bench_buf1_buf1(wuffs_deflate_decode, tc_dst, &deflate_pi_gt, 0, 0, 3000); } // ---------------- Mimic Benches @@ -620,20 +622,21 @@ void bench_mimic_crc32_100k() { do_bench_buf1_buf1(mimic_bench_crc32, tc_src, &crc32_pi_gt, 0, 0, 10000); } -void bench_mimic_flate_decode_1k() { +void bench_mimic_deflate_decode_1k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(mimic_flate_decode, tc_dst, &flate_romeo_gt, 0, 0, 200000); + do_bench_buf1_buf1(mimic_deflate_decode, tc_dst, &deflate_romeo_gt, 0, 0, + 200000); } -void bench_mimic_flate_decode_10k() { +void bench_mimic_deflate_decode_10k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(mimic_flate_decode, tc_dst, &flate_midsummer_gt, 0, 0, + do_bench_buf1_buf1(mimic_deflate_decode, tc_dst, &deflate_midsummer_gt, 0, 0, 30000); } -void bench_mimic_flate_decode_100k() { +void bench_mimic_deflate_decode_100k() { CHECK_FOCUS(__func__); - do_bench_buf1_buf1(mimic_flate_decode, tc_dst, &flate_pi_gt, 0, 0, 3000); + do_bench_buf1_buf1(mimic_deflate_decode, tc_dst, &deflate_pi_gt, 0, 0, 3000); } void bench_mimic_gzip_decode_10k() { @@ -656,28 +659,28 @@ void bench_mimic_gzip_decode_100k() { // The empty comments forces clang-format to place one element per line. proc tests[] = { - test_wuffs_flate_decode_256_bytes, // - test_wuffs_flate_decode_flate_backref_crosses_blocks, // - test_wuffs_flate_decode_midsummer, // - test_wuffs_flate_decode_pi, // - test_wuffs_flate_decode_pi_many_big_reads, // - test_wuffs_flate_decode_pi_many_medium_reads, // - test_wuffs_flate_decode_pi_many_small_writes_reads, // - test_wuffs_flate_decode_romeo, // - test_wuffs_flate_decode_romeo_fixed, // - test_wuffs_flate_decode_split_src, // - test_wuffs_flate_history_full, // - test_wuffs_flate_history_partial, // - test_wuffs_flate_table_redirect, // + test_wuffs_deflate_decode_256_bytes, // + test_wuffs_deflate_decode_flate_backref_crosses_blocks, // + test_wuffs_deflate_decode_midsummer, // + test_wuffs_deflate_decode_pi, // + test_wuffs_deflate_decode_pi_many_big_reads, // + test_wuffs_deflate_decode_pi_many_medium_reads, // + test_wuffs_deflate_decode_pi_many_small_writes_reads, // + test_wuffs_deflate_decode_romeo, // + test_wuffs_deflate_decode_romeo_fixed, // + test_wuffs_deflate_decode_split_src, // + test_wuffs_deflate_history_full, // + test_wuffs_deflate_history_partial, // + test_wuffs_deflate_table_redirect, // #ifdef WUFFS_MIMIC - test_mimic_flate_decode_256_bytes, // - test_mimic_flate_decode_flate_backref_crosses_blocks, // - test_mimic_flate_decode_midsummer, // - test_mimic_flate_decode_pi, // - test_mimic_flate_decode_romeo, // - test_mimic_flate_decode_romeo_fixed, // + test_mimic_deflate_decode_256_bytes, // + test_mimic_deflate_decode_flate_backref_crosses_blocks, // + test_mimic_deflate_decode_midsummer, // + test_mimic_deflate_decode_pi, // + test_mimic_deflate_decode_romeo, // + test_mimic_deflate_decode_romeo_fixed, // test_mimic_gzip_decode_midsummer, // test_mimic_gzip_decode_pi, // @@ -690,18 +693,18 @@ proc tests[] = { // The empty comments forces clang-format to place one element per line. proc benches[] = { - bench_wuffs_flate_decode_1k, // - bench_wuffs_flate_decode_10k, // - bench_wuffs_flate_decode_100k, // + bench_wuffs_deflate_decode_1k, // + bench_wuffs_deflate_decode_10k, // + bench_wuffs_deflate_decode_100k, // #ifdef WUFFS_MIMIC bench_mimic_crc32_10k, // bench_mimic_crc32_100k, // - bench_mimic_flate_decode_1k, // - bench_mimic_flate_decode_10k, // - bench_mimic_flate_decode_100k, // + bench_mimic_deflate_decode_1k, // + bench_mimic_deflate_decode_10k, // + bench_mimic_deflate_decode_100k, // bench_mimic_gzip_decode_10k, // bench_mimic_gzip_decode_100k, // @@ -712,6 +715,6 @@ proc benches[] = { }; int main(int argc, char** argv) { - proc_filename = "std/flate.c"; + proc_filename = "std/deflate.c"; return test_main(argc, argv, tests, benches); } diff --git a/test/c/std/zlib.c b/test/c/std/zlib.c index d5edab6c..3e28f6fa 100644 --- a/test/c/std/zlib.c +++ b/test/c/std/zlib.c @@ -40,7 +40,7 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the // If building this program in an environment that doesn't easily accomodate // relative includes, you can use the script/inline-c-relative-includes.go // program to generate a stand-alone C file. -#include "../../../gen/c/std/flate.c" +#include "../../../gen/c/std/deflate.c" #include "../../../gen/c/std/zlib.c" #include "../testlib/testlib.c" #ifdef WUFFS_MIMIC