Rename std/flate to std/deflate

This commit is contained in:
Nigel Tao committed 2017-12-04 10:27:48 +11:00
1 parent d168e6977b
commit 1388f84e5c
20 files changed
+590 -571

No files matched your search

+3 -3
View File
@@ -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'.
//
+5 -5
View File
@@ -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 {
+3 -3
View File
@@ -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".
//
+2 -2
View File
@@ -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)
+3 -3
View File
@@ -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.
+245 -239
View File
@@ -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;
}
+3 -3
View File
@@ -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'.
//
+62 -58
View File
@@ -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;
+54 -50
View File
@@ -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
+57 -53
View File
@@ -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 {
+2 -2
View File
@@ -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")
File renamed without changes.
File renamed without changes.
@@ -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"
File renamed without changes.
File renamed without changes.
+2 -2
View File
@@ -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,
)
+8 -8
View File
@@ -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;
+140 -137
View File
@@ -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);
}
+1 -1
View File
@@ -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