diff --git a/doc/changelog.md b/doc/changelog.md index 47b5a441..5bfe7fef 100644 --- a/doc/changelog.md +++ b/doc/changelog.md @@ -8,7 +8,7 @@ - Added a `use` keyword. - Added a `yield` keyword. - Added an image\_config built-in concept. -- Added `std/crc32`. +- Added `std/crc32` and `std/gzip`. - Spun `std/zlib` out of `std/flate`. - Let the `std/zlib` decoder ignore checksums. - Renamed `std/flate` to `std/deflate`. diff --git a/gen/c/std/gzip.c b/gen/c/std/gzip.c new file mode 100644 index 00000000..40d76b72 --- /dev/null +++ b/gen/c/std/gzip.c @@ -0,0 +1,1059 @@ +#ifndef WUFFS_GZIP_H +#define WUFFS_GZIP_H + +// Code generated by wuffs-c. DO NOT EDIT. + +#ifndef WUFFS_BASE_HEADER_H +#define WUFFS_BASE_HEADER_H + +// Copyright 2017 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include +#include +#include + +// Wuffs requires a word size of at least 32 bits because it assumes that +// converting a u32 to usize will never overflow. For example, the size of a +// decoded image is often represented, explicitly or implicitly in an image +// file, as a u32, and it is convenient to compare that to a buffer size. +// +// Similarly, the word size is at most 64 bits because it assumes that +// converting a usize to u64 will never overflow. +#if __WORDSIZE < 32 +#error "Wuffs requires a word size of at least 32 bits" +#elif __WORDSIZE > 64 +#error "Wuffs requires a word size of at most 64 bits" +#endif + +// WUFFS_VERSION is the major.minor version number as a uint32. The major +// number is the high 16 bits. The minor number is the low 16 bits. +// +// The intention is to bump the version number at least on every API / ABI +// backwards incompatible change. +// +// For now, the API and ABI are simply unstable and can change at any time. +// +// TODO: don't hard code this in base-header.h. +#define WUFFS_VERSION (0x00001) + +// ---------------- I/O + +// wuffs_base__slice_u8 is a 1-dimensional buffer (a pointer and length). +// +// A value with all fields NULL or zero is a valid, empty slice. +typedef struct { + uint8_t* ptr; + size_t len; +} wuffs_base__slice_u8; + +// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus +// additional indexes into that buffer, plus an opened / closed flag. +// +// A value with all fields NULL or zero is a valid, empty buffer. +typedef struct { + uint8_t* ptr; // Pointer. + size_t len; // Length. + size_t wi; // Write index. Invariant: wi <= len. + size_t ri; // Read index. Invariant: ri <= wi. + bool closed; // No further writes are expected. +} wuffs_base__buf1; + +// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream: +// its first N bytes. That N can be greater than a buffer's current read or +// write capacity. N decreases naturally over time as bytes are read from or +// written to the stream. +// +// A value with all fields NULL or zero is a valid, unlimited view. +typedef struct wuffs_base__limit1 { + uint64_t* ptr_to_len; // Pointer to N. + struct wuffs_base__limit1* next; // Linked list of limits. +} wuffs_base__limit1; + +typedef struct { + // TODO: move buf into private_impl? As it is, it looks like users can modify + // the buf field to point to a different buffer, which can turn the limit and + // mark fields into dangling pointers. + wuffs_base__buf1* buf; + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. + struct { + wuffs_base__limit1 limit; + uint8_t* mark; + } private_impl; +} wuffs_base__reader1; + +typedef struct { + // TODO: move buf into private_impl? As it is, it looks like users can modify + // the buf field to point to a different buffer, which can turn the limit and + // mark fields into dangling pointers. + wuffs_base__buf1* buf; + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. + struct { + wuffs_base__limit1 limit; + uint8_t* mark; + } private_impl; +} wuffs_base__writer1; + +// ---------------- Images + +typedef struct { + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. + struct { + uint32_t flags; + uint32_t w; + uint32_t h; + // TODO: color model, including both packed RGBA and planar, + // chroma-subsampled YCbCr. + } private_impl; +} wuffs_base__image_config; + +static inline void wuffs_base__image_config__invalidate( + wuffs_base__image_config* c) { + if (c) { + *c = ((wuffs_base__image_config){}); + } +} + +static inline bool wuffs_base__image_config__valid( + wuffs_base__image_config* c) { + if (!c || !(c->private_impl.flags & 1)) { + return false; + } + uint64_t wh = ((uint64_t)c->private_impl.w) * ((uint64_t)c->private_impl.h); + // TODO: handle things other than 1 byte per pixel. + return wh <= ((uint64_t)SIZE_MAX); +} + +static inline uint32_t wuffs_base__image_config__width( + wuffs_base__image_config* c) { + return wuffs_base__image_config__valid(c) ? c->private_impl.w : 0; +} + +static inline uint32_t wuffs_base__image_config__height( + wuffs_base__image_config* c) { + return wuffs_base__image_config__valid(c) ? c->private_impl.h : 0; +} + +// TODO: this is the right API for planar (not packed) pixbufs? Should it allow +// decoding into a color model different from the format's intrinsic one? For +// example, decoding a JPEG image straight to RGBA instead of to YCbCr? +static inline size_t wuffs_base__image_config__pixbuf_size( + wuffs_base__image_config* c) { + if (wuffs_base__image_config__valid(c)) { + uint64_t wh = ((uint64_t)c->private_impl.w) * ((uint64_t)c->private_impl.h); + // TODO: handle things other than 1 byte per pixel. + return (size_t)wh; + } + return 0; +} + +static inline void wuffs_base__image_config__initialize( + wuffs_base__image_config* c, + uint32_t width, + uint32_t height, + uint32_t TODO_color_model) { + if (!c) { + return; + } + c->private_impl.flags = 1; + c->private_impl.w = width; + c->private_impl.h = height; + // TODO: color model. +} + +#endif // WUFFS_BASE_HEADER_H + + // ---------------- Use Declarations + + // ---------------- BEGIN USE "std/crc32" + +#ifndef WUFFS_CRC32_H +#define WUFFS_CRC32_H + + // Code generated by wuffs-c. DO NOT EDIT. + + // ---------------- Use Declarations + +#ifdef __cplusplus +extern "C" { +#endif + +// ---------------- Status Codes + +// Status codes are int32_t values: +// - the sign bit indicates a non-recoverable status code: an error +// - bits 10-30 hold the packageid: a namespace +// - bits 8-9 are reserved +// - bits 0-7 are a package-namespaced numeric code +// +// Do not manipulate these bits directly. Use the API functions such as +// wuffs_crc32__status__is_error instead. +typedef int32_t wuffs_crc32__status; + +#define wuffs_crc32__packageid 810620 // 0x000C5E7C + +#define WUFFS_CRC32__STATUS_OK 0 // 0x00000000 +#define WUFFS_CRC32__ERROR_BAD_WUFFS_VERSION -2147483647 // 0x80000001 +#define WUFFS_CRC32__ERROR_BAD_RECEIVER -2147483646 // 0x80000002 +#define WUFFS_CRC32__ERROR_BAD_ARGUMENT -2147483645 // 0x80000003 +#define WUFFS_CRC32__ERROR_INITIALIZER_NOT_CALLED -2147483644 // 0x80000004 +#define WUFFS_CRC32__ERROR_INVALID_I_O_OPERATION -2147483643 // 0x80000005 +#define WUFFS_CRC32__ERROR_CLOSED_FOR_WRITES -2147483642 // 0x80000006 +#define WUFFS_CRC32__ERROR_UNEXPECTED_EOF -2147483641 // 0x80000007 +#define WUFFS_CRC32__SUSPENSION_SHORT_READ 8 // 0x00000008 +#define WUFFS_CRC32__SUSPENSION_SHORT_WRITE 9 // 0x00000009 +#define WUFFS_CRC32__ERROR_CANNOT_RETURN_A_SUSPENSION -2147483638 // 0x8000000A +#define WUFFS_CRC32__ERROR_INVALID_CALL_SEQUENCE -2147483637 // 0x8000000B +#define WUFFS_CRC32__SUSPENSION_END_OF_DATA 12 // 0x0000000C + +bool wuffs_crc32__status__is_error(wuffs_crc32__status s); + +const char* wuffs_crc32__status__string(wuffs_crc32__status s); + +// ---------------- Public Consts + +// ---------------- Structs + +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_crc32__ieee__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_crc32__status status; + uint32_t magic; + + uint32_t f_state; + + } private_impl; +} wuffs_crc32__ieee; + +// ---------------- Public Initializer Prototypes + +// wuffs_crc32__ieee__initialize is an initializer function. +// +// It should be called before any other wuffs_crc32__ieee__* function. +// +// Pass WUFFS_VERSION and 0 for wuffs_version and for_internal_use_only. +void wuffs_crc32__ieee__initialize(wuffs_crc32__ieee* self, + uint32_t wuffs_version, + uint32_t for_internal_use_only); + +// ---------------- Public Function Prototypes + +uint32_t wuffs_crc32__ieee__update(wuffs_crc32__ieee* self, + wuffs_base__slice_u8 a_x); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // WUFFS_CRC32_H + +// ---------------- END USE "std/crc32" + +// ---------------- BEGIN USE "std/deflate" + +#ifndef WUFFS_DEFLATE_H +#define WUFFS_DEFLATE_H + +// Code generated by wuffs-c. DO NOT EDIT. + +// ---------------- Use Declarations + +#ifdef __cplusplus +extern "C" { +#endif + +// ---------------- Status Codes + +// Status codes are int32_t values: +// - the sign bit indicates a non-recoverable status code: an error +// - bits 10-30 hold the packageid: a namespace +// - bits 8-9 are reserved +// - bits 0-7 are a package-namespaced numeric code +// +// Do not manipulate these bits directly. Use the API functions such as +// wuffs_deflate__status__is_error instead. +typedef int32_t wuffs_deflate__status; + +#define wuffs_deflate__packageid 848533 // 0x000CF295 + +#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_DEFLATE__ERROR_INVALID_CALL_SEQUENCE -2147483637 // 0x8000000B +#define WUFFS_DEFLATE__SUSPENSION_END_OF_DATA 12 // 0x0000000C + +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_OVER_SUBSCRIBED \ + -1278585856 // 0xB3CA5400 +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_UNDER_SUBSCRIBED \ + -1278585855 // 0xB3CA5401 +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_COUNT \ + -1278585854 // 0xB3CA5402 +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_REPETITION \ + -1278585853 // 0xB3CA5403 +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE -1278585852 // 0xB3CA5404 +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_MINIMUM_CODE_LENGTH \ + -1278585851 // 0xB3CA5405 +#define WUFFS_DEFLATE__ERROR_BAD_DISTANCE -1278585850 // 0xB3CA5406 +#define WUFFS_DEFLATE__ERROR_BAD_DISTANCE_CODE_COUNT -1278585849 // 0xB3CA5407 +#define WUFFS_DEFLATE__ERROR_BAD_FLATE_BLOCK -1278585848 // 0xB3CA5408 +#define WUFFS_DEFLATE__ERROR_BAD_LITERAL_LENGTH_CODE_COUNT \ + -1278585847 // 0xB3CA5409 +#define WUFFS_DEFLATE__ERROR_INCONSISTENT_STORED_BLOCK_LENGTH \ + -1278585846 // 0xB3CA540A +#define WUFFS_DEFLATE__ERROR_MISSING_END_OF_BLOCK_CODE \ + -1278585845 // 0xB3CA540B +#define WUFFS_DEFLATE__ERROR_NO_HUFFMAN_CODES -1278585844 // 0xB3CA540C +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE \ + -1278585843 // 0xB3CA540D +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_END_OF_BLOCK \ + -1278585842 // 0xB3CA540E +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_DISTANCE \ + -1278585841 // 0xB3CA540F +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS \ + -1278585840 // 0xB3CA5410 + +bool wuffs_deflate__status__is_error(wuffs_deflate__status s); + +const char* wuffs_deflate__status__string(wuffs_deflate__status s); + +// ---------------- Public Consts + +// ---------------- Structs + +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_deflate__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_deflate__status status; + uint32_t magic; + + uint32_t f_bits; + uint32_t f_n_bits; + uint32_t f_huffs[2][1234]; + uint32_t f_n_huffs_bits[2]; + uint8_t f_history[32768]; + uint32_t f_history_index; + uint8_t f_code_lengths[320]; + bool f_end_of_block; + + struct { + uint32_t coro_susp_point; + wuffs_deflate__status v_z; + uint64_t v_n_copied; + uint32_t v_already_full; + } c_decode[1]; + struct { + uint32_t coro_susp_point; + uint32_t v_final; + uint32_t v_type; + } c_decode_blocks[1]; + struct { + uint32_t coro_susp_point; + uint32_t v_length; + uint32_t v_n_copied; + uint64_t scratch; + } c_decode_uncompressed[1]; + struct { + uint32_t coro_susp_point; + uint32_t v_i; + } c_init_fixed_huffman[1]; + struct { + uint32_t coro_susp_point; + uint32_t v_bits; + uint32_t v_n_bits; + uint32_t v_n_lit; + uint32_t v_n_dist; + uint32_t v_n_clen; + uint32_t v_i; + uint32_t v_mask; + uint32_t v_table_entry; + uint32_t v_table_entry_n_bits; + uint32_t v_n_extra_bits; + uint8_t v_rep_symbol; + uint32_t v_rep_count; + } c_init_dynamic_huffman[1]; + struct { + uint32_t coro_susp_point; + uint32_t v_bits; + uint32_t v_n_bits; + uint32_t v_table_entry; + uint32_t v_table_entry_n_bits; + uint32_t v_lmask; + uint32_t v_dmask; + uint32_t v_redir_top; + uint32_t v_redir_mask; + uint32_t v_length; + uint32_t v_dist_minus_1; + uint32_t v_n_copied; + uint32_t v_hlen; + uint32_t v_hdist; + } c_decode_huffman_slow[1]; + } private_impl; +} wuffs_deflate__decoder; + +// ---------------- Public Initializer Prototypes + +// wuffs_deflate__decoder__initialize is an initializer function. +// +// It should be called before any other wuffs_deflate__decoder__* function. +// +// Pass WUFFS_VERSION and 0 for wuffs_version and for_internal_use_only. +void wuffs_deflate__decoder__initialize(wuffs_deflate__decoder* self, + uint32_t wuffs_version, + uint32_t for_internal_use_only); + +// ---------------- Public Function Prototypes + +wuffs_deflate__status wuffs_deflate__decoder__decode( + wuffs_deflate__decoder* self, + wuffs_base__writer1 a_dst, + wuffs_base__reader1 a_src); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // WUFFS_DEFLATE_H + +// ---------------- END USE "std/deflate" + +#ifdef __cplusplus +extern "C" { +#endif + +// ---------------- Status Codes + +// Status codes are int32_t values: +// - the sign bit indicates a non-recoverable status code: an error +// - bits 10-30 hold the packageid: a namespace +// - bits 8-9 are reserved +// - bits 0-7 are a package-namespaced numeric code +// +// Do not manipulate these bits directly. Use the API functions such as +// wuffs_gzip__status__is_error instead. +typedef int32_t wuffs_gzip__status; + +#define wuffs_gzip__packageid 1041911 // 0x000FE5F7 + +#define WUFFS_GZIP__STATUS_OK 0 // 0x00000000 +#define WUFFS_GZIP__ERROR_BAD_WUFFS_VERSION -2147483647 // 0x80000001 +#define WUFFS_GZIP__ERROR_BAD_RECEIVER -2147483646 // 0x80000002 +#define WUFFS_GZIP__ERROR_BAD_ARGUMENT -2147483645 // 0x80000003 +#define WUFFS_GZIP__ERROR_INITIALIZER_NOT_CALLED -2147483644 // 0x80000004 +#define WUFFS_GZIP__ERROR_INVALID_I_O_OPERATION -2147483643 // 0x80000005 +#define WUFFS_GZIP__ERROR_CLOSED_FOR_WRITES -2147483642 // 0x80000006 +#define WUFFS_GZIP__ERROR_UNEXPECTED_EOF -2147483641 // 0x80000007 +#define WUFFS_GZIP__SUSPENSION_SHORT_READ 8 // 0x00000008 +#define WUFFS_GZIP__SUSPENSION_SHORT_WRITE 9 // 0x00000009 +#define WUFFS_GZIP__ERROR_CANNOT_RETURN_A_SUSPENSION -2147483638 // 0x8000000A +#define WUFFS_GZIP__ERROR_INVALID_CALL_SEQUENCE -2147483637 // 0x8000000B +#define WUFFS_GZIP__SUSPENSION_END_OF_DATA 12 // 0x0000000C + +#define WUFFS_GZIP__ERROR_BAD_GZIP_HEADER -1080566784 // 0xBF97DC00 + +bool wuffs_gzip__status__is_error(wuffs_gzip__status s); + +const char* wuffs_gzip__status__string(wuffs_gzip__status s); + +// ---------------- Public Consts + +// ---------------- Structs + +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_gzip__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_gzip__status status; + uint32_t magic; + + struct { + uint32_t coro_susp_point; + } c_decode[1]; + } private_impl; +} wuffs_gzip__decoder; + +// ---------------- Public Initializer Prototypes + +// wuffs_gzip__decoder__initialize is an initializer function. +// +// It should be called before any other wuffs_gzip__decoder__* function. +// +// Pass WUFFS_VERSION and 0 for wuffs_version and for_internal_use_only. +void wuffs_gzip__decoder__initialize(wuffs_gzip__decoder* self, + uint32_t wuffs_version, + uint32_t for_internal_use_only); + +// ---------------- Public Function Prototypes + +wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, + wuffs_base__writer1 a_dst, + wuffs_base__reader1 a_src); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // WUFFS_GZIP_H + +// C HEADER ENDS HERE. + +#ifndef WUFFS_BASE_IMPL_H +#define WUFFS_BASE_IMPL_H + +// Copyright 2017 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// wuffs_base__empty_struct is used when a Wuffs function returns an empty +// struct. In C, if a function f returns void, you can't say "x = f()", but in +// Wuffs, if a function g returns empty, you can say "y = g()". +typedef struct { +} wuffs_base__empty_struct; + +#define WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(x) (void)(x) + +// WUFFS_BASE__MAGIC is a magic number to check that initializers are called. +// It's not foolproof, given C doesn't automatically zero memory before use, +// but it should catch 99.99% of cases. +// +// Its (non-zero) value is arbitrary, based on md5sum("wuffs"). +#define WUFFS_BASE__MAGIC (0x3CCB6C71U) + +// WUFFS_BASE__ALREADY_ZEROED is passed from a container struct's initializer +// to a containee struct's initializer when the container has already zeroed +// the containee's memory. +// +// Its (non-zero) value is arbitrary, based on md5sum("zeroed"). +#define WUFFS_BASE__ALREADY_ZEROED (0x68602EF1U) + +// Denote intentional fallthroughs for -Wimplicit-fallthrough. +// +// The order matters here. Clang also defines "__GNUC__". +#if defined(__clang__) && __cplusplus >= 201103L +#define WUFFS_BASE__FALLTHROUGH [[clang::fallthrough]] +#elif !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 7) +#define WUFFS_BASE__FALLTHROUGH __attribute__((fallthrough)) +#else +#define WUFFS_BASE__FALLTHROUGH +#endif + +// Use switch cases for coroutine suspension points, similar to the technique +// in https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html +// +// We use trivial macros instead of an explicit assignment and case statement +// so that clang-format doesn't get confused by the unusual "case"s. +#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0 case 0:; +#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT(n) \ + coro_susp_point = n; \ + WUFFS_BASE__FALLTHROUGH; \ + case n:; + +#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \ + if (status < 0) { \ + goto exit; \ + } else if (status == 0) { \ + goto ok; \ + } \ + coro_susp_point = n; \ + goto suspend; \ + case n:; + +// Clang also defines "__GNUC__". +#if defined(__GNUC__) +#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1)) +#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0)) +#else +#define WUFFS_BASE__LIKELY(expr) (expr) +#define WUFFS_BASE__UNLIKELY(expr) (expr) +#endif + +// Uncomment this #include for printf-debugging. +// #include + +// ---------------- Static Inline Functions +// +// The helpers below are functions, instead of macros, because their arguments +// can be an expression that we shouldn't evaluate more than once. +// +// They are in base-impl.h and hence copy/pasted into every generated C file, +// instead of being in some "base.c" file, since a design goal is that users of +// the generated C code can often just #include a single .c file, such as +// "gif.c", without having to additionally include or otherwise build and link +// a "base.c" file. +// +// They are static, so that linking multiple wuffs .o files won't complain about +// duplicate function definitions. +// +// They are explicitly marked inline, even if modern compilers don't use the +// inline attribute to guide optimizations such as inlining, to avoid the +// -Wunused-function warning, and we like to compile with -Wall -Werror. + +static inline uint16_t wuffs_base__load_u16be(uint8_t* p) { + return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0); +} + +static inline uint16_t wuffs_base__load_u16le(uint8_t* p) { + return ((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8); +} + +static inline uint32_t wuffs_base__load_u32be(uint8_t* p) { + return ((uint32_t)(p[0]) << 24) | ((uint32_t)(p[1]) << 16) | + ((uint32_t)(p[2]) << 8) | ((uint32_t)(p[3]) << 0); +} + +static inline uint32_t wuffs_base__load_u32le(uint8_t* p) { + return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) | + ((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24); +} + +static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i( + wuffs_base__slice_u8 s, + uint64_t i) { + if ((i <= SIZE_MAX) && (i <= s.len)) { + return ((wuffs_base__slice_u8){ + .ptr = s.ptr + i, + .len = s.len - i, + }); + } + return ((wuffs_base__slice_u8){}); +} + +static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_j( + wuffs_base__slice_u8 s, + uint64_t j) { + if ((j <= SIZE_MAX) && (j <= s.len)) { + return ((wuffs_base__slice_u8){.ptr = s.ptr, .len = j}); + } + return ((wuffs_base__slice_u8){}); +} + +static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_ij( + wuffs_base__slice_u8 s, + uint64_t i, + uint64_t j) { + if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) { + return ((wuffs_base__slice_u8){ + .ptr = s.ptr + i, + .len = j - i, + }); + } + return ((wuffs_base__slice_u8){}); +} + +// wuffs_base__slice_u8__prefix returns up to the first up_to bytes of s. +static inline wuffs_base__slice_u8 wuffs_base__slice_u8__prefix( + wuffs_base__slice_u8 s, + uint64_t up_to) { + if ((uint64_t)(s.len) > up_to) { + s.len = up_to; + } + return s; +} + +// wuffs_base__slice_u8__suffix returns up to the last up_to bytes of s. +static inline wuffs_base__slice_u8 wuffs_base__slice_u8_suffix( + wuffs_base__slice_u8 s, + uint64_t up_to) { + if ((uint64_t)(s.len) > up_to) { + s.ptr += (uint64_t)(s.len) - up_to; + s.len = up_to; + } + return s; +} + +// wuffs_base__slice_u8__copy_from_slice calls memmove(dst.ptr, src.ptr, +// length) where length is the minimum of dst.len and src.len. +// +// Passing a wuffs_base__slice_u8 with all fields NULL or zero (a valid, empty +// slice) is valid and results in a no-op. +static inline uint64_t wuffs_base__slice_u8__copy_from_slice( + wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 src) { + size_t length = dst.len < src.len ? dst.len : src.len; + if (length > 0) { + memmove(dst.ptr, src.ptr, length); + } + return length; +} + +static inline uint32_t wuffs_base__writer1__copy_from_history32( + uint8_t** ptr_ptr, + uint8_t* start, // May be NULL, meaning an unmarked writer1. + uint8_t* end, + uint32_t distance, + uint32_t length) { + if (!start || !distance) { + return 0; + } + uint8_t* ptr = *ptr_ptr; + if ((size_t)(ptr - start) < (size_t)(distance)) { + return 0; + } + start = ptr - distance; + size_t n = end - ptr; + if ((size_t)(length) > n) { + length = n; + } else { + n = length; + } + // 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'. + // + // See also wuffs_base__writer1__copy_from_history32__bco below. + // + // Alternatively, or additionally, have a sloppy_copy_from_history32 method + // that copies 8 bytes at a time, possibly writing more than length bytes? + for (; n >= 3; n -= 3) { + *ptr++ = *start++; + *ptr++ = *start++; + *ptr++ = *start++; + } + for (; n; n--) { + *ptr++ = *start++; + } + *ptr_ptr = ptr; + return length; +} + +// wuffs_base__writer1__copy_from_history32__bco is a Bounds Check Optimized +// version of the wuffs_base__writer1__copy_from_history32 function above. The +// caller needs to prove that: +// - start != NULL +// - distance > 0 +// - distance <= (*ptr_ptr - start) +// - length <= (end - *ptr_ptr) +static inline uint32_t wuffs_base__writer1__copy_from_history32__bco( + uint8_t** ptr_ptr, + uint8_t* start, + uint8_t* end, + uint32_t distance, + uint32_t length) { + uint8_t* ptr = *ptr_ptr; + start = ptr - distance; + uint32_t n = length; + for (; n >= 3; n -= 3) { + *ptr++ = *start++; + *ptr++ = *start++; + *ptr++ = *start++; + } + for (; n; n--) { + *ptr++ = *start++; + } + *ptr_ptr = ptr; + return length; +} + +static inline uint32_t wuffs_base__writer1__copy_from_reader32( + uint8_t** ptr_wptr, + uint8_t* wend, + uint8_t** ptr_rptr, + uint8_t* rend, + uint32_t length) { + uint8_t* wptr = *ptr_wptr; + size_t n = length; + if (n > wend - wptr) { + n = wend - wptr; + } + uint8_t* rptr = *ptr_rptr; + if (n > rend - rptr) { + n = rend - rptr; + } + if (n > 0) { + memmove(wptr, rptr, n); + *ptr_wptr += n; + *ptr_rptr += n; + } + return n; +} + +static inline uint64_t wuffs_base__writer1__copy_from_slice( + uint8_t** ptr_wptr, + uint8_t* wend, + wuffs_base__slice_u8 src) { + uint8_t* wptr = *ptr_wptr; + size_t n = src.len; + if (n > wend - wptr) { + n = wend - wptr; + } + if (n > 0) { + memmove(wptr, src.ptr, n); + *ptr_wptr += n; + } + return n; +} + +static inline uint32_t wuffs_base__writer1__copy_from_slice32( + uint8_t** ptr_wptr, + uint8_t* wend, + wuffs_base__slice_u8 src, + uint32_t length) { + uint8_t* wptr = *ptr_wptr; + size_t n = src.len; + if (n > length) { + n = length; + } + if (n > wend - wptr) { + n = wend - wptr; + } + if (n > 0) { + memmove(wptr, src.ptr, n); + *ptr_wptr += n; + } + return n; +} + +// Note that the *__limit and *__mark methods are private (in base-impl.h) not +// public (in base-header.h). We assume that, at the boundary between user code +// and Wuffs code, the reader1 and writer1's private_impl fields (including +// limit and mark) are NULL. Otherwise, some internal assumptions break down. +// For example, limits could be represented as pointers, even though +// conceptually they are counts, but that pointer-to-count correspondence +// becomes invalid if a buffer is re-used (e.g. on resuming a coroutine). +// +// Admittedly, some of the Wuffs test code calls these methods, but that test +// code is still Wuffs code, not user code. Other Wuffs test code modifies +// private_impl fields directly. + +static inline wuffs_base__reader1 wuffs_base__reader1__limit( + wuffs_base__reader1* o, + uint64_t* ptr_to_len) { + wuffs_base__reader1 ret = *o; + ret.private_impl.limit.ptr_to_len = ptr_to_len; + ret.private_impl.limit.next = &o->private_impl.limit; + return ret; +} + +static inline wuffs_base__empty_struct wuffs_base__reader1__mark( + wuffs_base__reader1* o, + uint8_t* mark) { + o->private_impl.mark = mark; + return ((wuffs_base__empty_struct){}); +} + +// TODO: static inline wuffs_base__writer1 wuffs_base__writer1__limit() + +static inline wuffs_base__empty_struct wuffs_base__writer1__mark( + wuffs_base__writer1* o, + uint8_t* mark) { + o->private_impl.mark = mark; + return ((wuffs_base__empty_struct){}); +} + +static const char* wuffs_base__status__strings[13] = { + "ok", + "bad wuffs version", + "bad receiver", + "bad argument", + "initializer not called", + "invalid I/O operation", + "closed for writes", + "unexpected EOF", + "short read", + "short write", + "cannot return a suspension", + "invalid call sequence", + "end of data", +}; + +#endif // WUFFS_BASE_IMPL_H + +// ---------------- Status Codes Implementations + +bool wuffs_gzip__status__is_error(wuffs_gzip__status s) { + return s < 0; +} + +const char* wuffs_gzip__status__strings[1] = { + "gzip: bad Gzip header", +}; + +const char* wuffs_gzip__status__string(wuffs_gzip__status s) { + const char** a = NULL; + uint32_t n = 0; + switch ((s >> 10) & 0x1FFFFF) { + case 0: + a = wuffs_base__status__strings; + n = 13; + break; + case wuffs_gzip__packageid: + a = wuffs_gzip__status__strings; + n = 1; + break; + case wuffs_crc32__packageid: + return wuffs_crc32__status__string(s); + case wuffs_deflate__packageid: + return wuffs_deflate__status__string(s); + } + uint32_t i = s & 0xFF; + return i < n ? a[i] : "unknown status"; +} + +// ---------------- Private Consts + +// ---------------- Private Initializer Prototypes + +// ---------------- Private Function Prototypes + +// ---------------- Initializer Implementations + +void wuffs_gzip__decoder__initialize(wuffs_gzip__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_GZIP__ERROR_BAD_WUFFS_VERSION; + return; + } + if (for_internal_use_only != WUFFS_BASE__ALREADY_ZEROED) { + memset(self, 0, sizeof(*self)); + } + self->private_impl.magic = WUFFS_BASE__MAGIC; +} + +// ---------------- Function Implementations + +wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, + wuffs_base__writer1 a_dst, + wuffs_base__reader1 a_src) { + if (!self) { + return WUFFS_GZIP__ERROR_BAD_RECEIVER; + } + if (self->private_impl.magic != WUFFS_BASE__MAGIC) { + self->private_impl.status = WUFFS_GZIP__ERROR_INITIALIZER_NOT_CALLED; + } + if (self->private_impl.status < 0) { + return self->private_impl.status; + } + wuffs_gzip__status status = WUFFS_GZIP__STATUS_OK; + + uint8_t* b_rptr_src = NULL; + uint8_t* b_rstart_src = NULL; + uint8_t* b_rend_src = NULL; + if (a_src.buf) { + b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + b_rstart_src = b_rptr_src; + uint64_t len = a_src.buf->wi - a_src.buf->ri; + wuffs_base__limit1* lim; + for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { + if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { + len = *lim->ptr_to_len; + } + } + b_rend_src = b_rptr_src + len; + } + + uint32_t coro_susp_point = self->private_impl.c_decode[0].coro_susp_point; + if (coro_susp_point) { + } else { + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + if (WUFFS_BASE__UNLIKELY(b_rptr_src == b_rend_src)) { + goto short_read_src; + } + uint8_t t_0 = *b_rptr_src++; + if (t_0 != 31) { + status = WUFFS_GZIP__ERROR_BAD_GZIP_HEADER; + goto exit; + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + if (WUFFS_BASE__UNLIKELY(b_rptr_src == b_rend_src)) { + goto short_read_src; + } + uint8_t t_1 = *b_rptr_src++; + if (t_1 != 139) { + status = WUFFS_GZIP__ERROR_BAD_GZIP_HEADER; + goto exit; + } + + goto ok; + ok: + self->private_impl.c_decode[0].coro_susp_point = 0; + goto exit; + } + + goto suspend; +suspend: + self->private_impl.c_decode[0].coro_susp_point = coro_susp_point; + +exit: + if (a_src.buf) { + size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); + a_src.buf->ri += n; + wuffs_base__limit1* lim; + for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { + if (lim->ptr_to_len) { + *lim->ptr_to_len -= n; + } + } + WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(b_rstart_src); + WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(b_rend_src); + } + + self->private_impl.status = status; + return status; + +short_read_src: + if (a_src.buf && a_src.buf->closed && !a_src.private_impl.limit.ptr_to_len) { + status = WUFFS_GZIP__ERROR_UNEXPECTED_EOF; + goto exit; + } + status = WUFFS_GZIP__SUSPENSION_SHORT_READ; + goto suspend; +} diff --git a/gen/h/std/gzip.h b/gen/h/std/gzip.h new file mode 100644 index 00000000..a16da279 --- /dev/null +++ b/gen/h/std/gzip.h @@ -0,0 +1,535 @@ +#ifndef WUFFS_GZIP_H +#define WUFFS_GZIP_H + +// Code generated by wuffs-c. DO NOT EDIT. + +#ifndef WUFFS_BASE_HEADER_H +#define WUFFS_BASE_HEADER_H + +// Copyright 2017 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include +#include +#include + +// Wuffs requires a word size of at least 32 bits because it assumes that +// converting a u32 to usize will never overflow. For example, the size of a +// decoded image is often represented, explicitly or implicitly in an image +// file, as a u32, and it is convenient to compare that to a buffer size. +// +// Similarly, the word size is at most 64 bits because it assumes that +// converting a usize to u64 will never overflow. +#if __WORDSIZE < 32 +#error "Wuffs requires a word size of at least 32 bits" +#elif __WORDSIZE > 64 +#error "Wuffs requires a word size of at most 64 bits" +#endif + +// WUFFS_VERSION is the major.minor version number as a uint32. The major +// number is the high 16 bits. The minor number is the low 16 bits. +// +// The intention is to bump the version number at least on every API / ABI +// backwards incompatible change. +// +// For now, the API and ABI are simply unstable and can change at any time. +// +// TODO: don't hard code this in base-header.h. +#define WUFFS_VERSION (0x00001) + +// ---------------- I/O + +// wuffs_base__slice_u8 is a 1-dimensional buffer (a pointer and length). +// +// A value with all fields NULL or zero is a valid, empty slice. +typedef struct { + uint8_t* ptr; + size_t len; +} wuffs_base__slice_u8; + +// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus +// additional indexes into that buffer, plus an opened / closed flag. +// +// A value with all fields NULL or zero is a valid, empty buffer. +typedef struct { + uint8_t* ptr; // Pointer. + size_t len; // Length. + size_t wi; // Write index. Invariant: wi <= len. + size_t ri; // Read index. Invariant: ri <= wi. + bool closed; // No further writes are expected. +} wuffs_base__buf1; + +// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream: +// its first N bytes. That N can be greater than a buffer's current read or +// write capacity. N decreases naturally over time as bytes are read from or +// written to the stream. +// +// A value with all fields NULL or zero is a valid, unlimited view. +typedef struct wuffs_base__limit1 { + uint64_t* ptr_to_len; // Pointer to N. + struct wuffs_base__limit1* next; // Linked list of limits. +} wuffs_base__limit1; + +typedef struct { + // TODO: move buf into private_impl? As it is, it looks like users can modify + // the buf field to point to a different buffer, which can turn the limit and + // mark fields into dangling pointers. + wuffs_base__buf1* buf; + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. + struct { + wuffs_base__limit1 limit; + uint8_t* mark; + } private_impl; +} wuffs_base__reader1; + +typedef struct { + // TODO: move buf into private_impl? As it is, it looks like users can modify + // the buf field to point to a different buffer, which can turn the limit and + // mark fields into dangling pointers. + wuffs_base__buf1* buf; + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. + struct { + wuffs_base__limit1 limit; + uint8_t* mark; + } private_impl; +} wuffs_base__writer1; + +// ---------------- Images + +typedef struct { + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. + struct { + uint32_t flags; + uint32_t w; + uint32_t h; + // TODO: color model, including both packed RGBA and planar, + // chroma-subsampled YCbCr. + } private_impl; +} wuffs_base__image_config; + +static inline void wuffs_base__image_config__invalidate( + wuffs_base__image_config* c) { + if (c) { + *c = ((wuffs_base__image_config){}); + } +} + +static inline bool wuffs_base__image_config__valid( + wuffs_base__image_config* c) { + if (!c || !(c->private_impl.flags & 1)) { + return false; + } + uint64_t wh = ((uint64_t)c->private_impl.w) * ((uint64_t)c->private_impl.h); + // TODO: handle things other than 1 byte per pixel. + return wh <= ((uint64_t)SIZE_MAX); +} + +static inline uint32_t wuffs_base__image_config__width( + wuffs_base__image_config* c) { + return wuffs_base__image_config__valid(c) ? c->private_impl.w : 0; +} + +static inline uint32_t wuffs_base__image_config__height( + wuffs_base__image_config* c) { + return wuffs_base__image_config__valid(c) ? c->private_impl.h : 0; +} + +// TODO: this is the right API for planar (not packed) pixbufs? Should it allow +// decoding into a color model different from the format's intrinsic one? For +// example, decoding a JPEG image straight to RGBA instead of to YCbCr? +static inline size_t wuffs_base__image_config__pixbuf_size( + wuffs_base__image_config* c) { + if (wuffs_base__image_config__valid(c)) { + uint64_t wh = ((uint64_t)c->private_impl.w) * ((uint64_t)c->private_impl.h); + // TODO: handle things other than 1 byte per pixel. + return (size_t)wh; + } + return 0; +} + +static inline void wuffs_base__image_config__initialize( + wuffs_base__image_config* c, + uint32_t width, + uint32_t height, + uint32_t TODO_color_model) { + if (!c) { + return; + } + c->private_impl.flags = 1; + c->private_impl.w = width; + c->private_impl.h = height; + // TODO: color model. +} + +#endif // WUFFS_BASE_HEADER_H + + // ---------------- Use Declarations + + // ---------------- BEGIN USE "std/crc32" + +#ifndef WUFFS_CRC32_H +#define WUFFS_CRC32_H + + // Code generated by wuffs-c. DO NOT EDIT. + + // ---------------- Use Declarations + +#ifdef __cplusplus +extern "C" { +#endif + +// ---------------- Status Codes + +// Status codes are int32_t values: +// - the sign bit indicates a non-recoverable status code: an error +// - bits 10-30 hold the packageid: a namespace +// - bits 8-9 are reserved +// - bits 0-7 are a package-namespaced numeric code +// +// Do not manipulate these bits directly. Use the API functions such as +// wuffs_crc32__status__is_error instead. +typedef int32_t wuffs_crc32__status; + +#define wuffs_crc32__packageid 810620 // 0x000C5E7C + +#define WUFFS_CRC32__STATUS_OK 0 // 0x00000000 +#define WUFFS_CRC32__ERROR_BAD_WUFFS_VERSION -2147483647 // 0x80000001 +#define WUFFS_CRC32__ERROR_BAD_RECEIVER -2147483646 // 0x80000002 +#define WUFFS_CRC32__ERROR_BAD_ARGUMENT -2147483645 // 0x80000003 +#define WUFFS_CRC32__ERROR_INITIALIZER_NOT_CALLED -2147483644 // 0x80000004 +#define WUFFS_CRC32__ERROR_INVALID_I_O_OPERATION -2147483643 // 0x80000005 +#define WUFFS_CRC32__ERROR_CLOSED_FOR_WRITES -2147483642 // 0x80000006 +#define WUFFS_CRC32__ERROR_UNEXPECTED_EOF -2147483641 // 0x80000007 +#define WUFFS_CRC32__SUSPENSION_SHORT_READ 8 // 0x00000008 +#define WUFFS_CRC32__SUSPENSION_SHORT_WRITE 9 // 0x00000009 +#define WUFFS_CRC32__ERROR_CANNOT_RETURN_A_SUSPENSION -2147483638 // 0x8000000A +#define WUFFS_CRC32__ERROR_INVALID_CALL_SEQUENCE -2147483637 // 0x8000000B +#define WUFFS_CRC32__SUSPENSION_END_OF_DATA 12 // 0x0000000C + +bool wuffs_crc32__status__is_error(wuffs_crc32__status s); + +const char* wuffs_crc32__status__string(wuffs_crc32__status s); + +// ---------------- Public Consts + +// ---------------- Structs + +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_crc32__ieee__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_crc32__status status; + uint32_t magic; + + uint32_t f_state; + + } private_impl; +} wuffs_crc32__ieee; + +// ---------------- Public Initializer Prototypes + +// wuffs_crc32__ieee__initialize is an initializer function. +// +// It should be called before any other wuffs_crc32__ieee__* function. +// +// Pass WUFFS_VERSION and 0 for wuffs_version and for_internal_use_only. +void wuffs_crc32__ieee__initialize(wuffs_crc32__ieee* self, + uint32_t wuffs_version, + uint32_t for_internal_use_only); + +// ---------------- Public Function Prototypes + +uint32_t wuffs_crc32__ieee__update(wuffs_crc32__ieee* self, + wuffs_base__slice_u8 a_x); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // WUFFS_CRC32_H + +// ---------------- END USE "std/crc32" + +// ---------------- BEGIN USE "std/deflate" + +#ifndef WUFFS_DEFLATE_H +#define WUFFS_DEFLATE_H + +// Code generated by wuffs-c. DO NOT EDIT. + +// ---------------- Use Declarations + +#ifdef __cplusplus +extern "C" { +#endif + +// ---------------- Status Codes + +// Status codes are int32_t values: +// - the sign bit indicates a non-recoverable status code: an error +// - bits 10-30 hold the packageid: a namespace +// - bits 8-9 are reserved +// - bits 0-7 are a package-namespaced numeric code +// +// Do not manipulate these bits directly. Use the API functions such as +// wuffs_deflate__status__is_error instead. +typedef int32_t wuffs_deflate__status; + +#define wuffs_deflate__packageid 848533 // 0x000CF295 + +#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_DEFLATE__ERROR_INVALID_CALL_SEQUENCE -2147483637 // 0x8000000B +#define WUFFS_DEFLATE__SUSPENSION_END_OF_DATA 12 // 0x0000000C + +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_OVER_SUBSCRIBED \ + -1278585856 // 0xB3CA5400 +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_UNDER_SUBSCRIBED \ + -1278585855 // 0xB3CA5401 +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_COUNT \ + -1278585854 // 0xB3CA5402 +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_REPETITION \ + -1278585853 // 0xB3CA5403 +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE -1278585852 // 0xB3CA5404 +#define WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_MINIMUM_CODE_LENGTH \ + -1278585851 // 0xB3CA5405 +#define WUFFS_DEFLATE__ERROR_BAD_DISTANCE -1278585850 // 0xB3CA5406 +#define WUFFS_DEFLATE__ERROR_BAD_DISTANCE_CODE_COUNT -1278585849 // 0xB3CA5407 +#define WUFFS_DEFLATE__ERROR_BAD_FLATE_BLOCK -1278585848 // 0xB3CA5408 +#define WUFFS_DEFLATE__ERROR_BAD_LITERAL_LENGTH_CODE_COUNT \ + -1278585847 // 0xB3CA5409 +#define WUFFS_DEFLATE__ERROR_INCONSISTENT_STORED_BLOCK_LENGTH \ + -1278585846 // 0xB3CA540A +#define WUFFS_DEFLATE__ERROR_MISSING_END_OF_BLOCK_CODE \ + -1278585845 // 0xB3CA540B +#define WUFFS_DEFLATE__ERROR_NO_HUFFMAN_CODES -1278585844 // 0xB3CA540C +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE \ + -1278585843 // 0xB3CA540D +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_END_OF_BLOCK \ + -1278585842 // 0xB3CA540E +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_DISTANCE \ + -1278585841 // 0xB3CA540F +#define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS \ + -1278585840 // 0xB3CA5410 + +bool wuffs_deflate__status__is_error(wuffs_deflate__status s); + +const char* wuffs_deflate__status__string(wuffs_deflate__status s); + +// ---------------- Public Consts + +// ---------------- Structs + +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_deflate__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_deflate__status status; + uint32_t magic; + + uint32_t f_bits; + uint32_t f_n_bits; + uint32_t f_huffs[2][1234]; + uint32_t f_n_huffs_bits[2]; + uint8_t f_history[32768]; + uint32_t f_history_index; + uint8_t f_code_lengths[320]; + bool f_end_of_block; + + struct { + uint32_t coro_susp_point; + wuffs_deflate__status v_z; + uint64_t v_n_copied; + uint32_t v_already_full; + } c_decode[1]; + struct { + uint32_t coro_susp_point; + uint32_t v_final; + uint32_t v_type; + } c_decode_blocks[1]; + struct { + uint32_t coro_susp_point; + uint32_t v_length; + uint32_t v_n_copied; + uint64_t scratch; + } c_decode_uncompressed[1]; + struct { + uint32_t coro_susp_point; + uint32_t v_i; + } c_init_fixed_huffman[1]; + struct { + uint32_t coro_susp_point; + uint32_t v_bits; + uint32_t v_n_bits; + uint32_t v_n_lit; + uint32_t v_n_dist; + uint32_t v_n_clen; + uint32_t v_i; + uint32_t v_mask; + uint32_t v_table_entry; + uint32_t v_table_entry_n_bits; + uint32_t v_n_extra_bits; + uint8_t v_rep_symbol; + uint32_t v_rep_count; + } c_init_dynamic_huffman[1]; + struct { + uint32_t coro_susp_point; + uint32_t v_bits; + uint32_t v_n_bits; + uint32_t v_table_entry; + uint32_t v_table_entry_n_bits; + uint32_t v_lmask; + uint32_t v_dmask; + uint32_t v_redir_top; + uint32_t v_redir_mask; + uint32_t v_length; + uint32_t v_dist_minus_1; + uint32_t v_n_copied; + uint32_t v_hlen; + uint32_t v_hdist; + } c_decode_huffman_slow[1]; + } private_impl; +} wuffs_deflate__decoder; + +// ---------------- Public Initializer Prototypes + +// wuffs_deflate__decoder__initialize is an initializer function. +// +// It should be called before any other wuffs_deflate__decoder__* function. +// +// Pass WUFFS_VERSION and 0 for wuffs_version and for_internal_use_only. +void wuffs_deflate__decoder__initialize(wuffs_deflate__decoder* self, + uint32_t wuffs_version, + uint32_t for_internal_use_only); + +// ---------------- Public Function Prototypes + +wuffs_deflate__status wuffs_deflate__decoder__decode( + wuffs_deflate__decoder* self, + wuffs_base__writer1 a_dst, + wuffs_base__reader1 a_src); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // WUFFS_DEFLATE_H + +// ---------------- END USE "std/deflate" + +#ifdef __cplusplus +extern "C" { +#endif + +// ---------------- Status Codes + +// Status codes are int32_t values: +// - the sign bit indicates a non-recoverable status code: an error +// - bits 10-30 hold the packageid: a namespace +// - bits 8-9 are reserved +// - bits 0-7 are a package-namespaced numeric code +// +// Do not manipulate these bits directly. Use the API functions such as +// wuffs_gzip__status__is_error instead. +typedef int32_t wuffs_gzip__status; + +#define wuffs_gzip__packageid 1041911 // 0x000FE5F7 + +#define WUFFS_GZIP__STATUS_OK 0 // 0x00000000 +#define WUFFS_GZIP__ERROR_BAD_WUFFS_VERSION -2147483647 // 0x80000001 +#define WUFFS_GZIP__ERROR_BAD_RECEIVER -2147483646 // 0x80000002 +#define WUFFS_GZIP__ERROR_BAD_ARGUMENT -2147483645 // 0x80000003 +#define WUFFS_GZIP__ERROR_INITIALIZER_NOT_CALLED -2147483644 // 0x80000004 +#define WUFFS_GZIP__ERROR_INVALID_I_O_OPERATION -2147483643 // 0x80000005 +#define WUFFS_GZIP__ERROR_CLOSED_FOR_WRITES -2147483642 // 0x80000006 +#define WUFFS_GZIP__ERROR_UNEXPECTED_EOF -2147483641 // 0x80000007 +#define WUFFS_GZIP__SUSPENSION_SHORT_READ 8 // 0x00000008 +#define WUFFS_GZIP__SUSPENSION_SHORT_WRITE 9 // 0x00000009 +#define WUFFS_GZIP__ERROR_CANNOT_RETURN_A_SUSPENSION -2147483638 // 0x8000000A +#define WUFFS_GZIP__ERROR_INVALID_CALL_SEQUENCE -2147483637 // 0x8000000B +#define WUFFS_GZIP__SUSPENSION_END_OF_DATA 12 // 0x0000000C + +#define WUFFS_GZIP__ERROR_BAD_GZIP_HEADER -1080566784 // 0xBF97DC00 + +bool wuffs_gzip__status__is_error(wuffs_gzip__status s); + +const char* wuffs_gzip__status__string(wuffs_gzip__status s); + +// ---------------- Public Consts + +// ---------------- Structs + +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_gzip__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_gzip__status status; + uint32_t magic; + + struct { + uint32_t coro_susp_point; + } c_decode[1]; + } private_impl; +} wuffs_gzip__decoder; + +// ---------------- Public Initializer Prototypes + +// wuffs_gzip__decoder__initialize is an initializer function. +// +// It should be called before any other wuffs_gzip__decoder__* function. +// +// Pass WUFFS_VERSION and 0 for wuffs_version and for_internal_use_only. +void wuffs_gzip__decoder__initialize(wuffs_gzip__decoder* self, + uint32_t wuffs_version, + uint32_t for_internal_use_only); + +// ---------------- Public Function Prototypes + +wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, + wuffs_base__writer1 a_dst, + wuffs_base__reader1 a_src); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // WUFFS_GZIP_H diff --git a/std/gzip/README.md b/std/gzip/README.md new file mode 100644 index 00000000..70d5a6ae --- /dev/null +++ b/std/gzip/README.md @@ -0,0 +1,10 @@ +# Gzip + +Gzip ([RFC 1952](https://www.ietf.org/rfc/rfc1952.txt)) is a thin wrapper +around raw deflate (RFC 1951). Gzip is similar to zlib (RFC 1950), but with a +different wire format and checksum algorithm. + +Gzip is used as an HTTP compression format and as a standalone file format for +the `gzip`, `gunzip` and `zcat` utility programs. + +TODO: a worked example. diff --git a/std/gzip/decode_zlib.wuffs b/std/gzip/decode_zlib.wuffs new file mode 100644 index 00000000..956b5bb3 --- /dev/null +++ b/std/gzip/decode_zlib.wuffs @@ -0,0 +1,33 @@ +// Copyright 2018 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +packageid "gzip" + +use "std/crc32" +use "std/deflate" + +pub error "bad Gzip header" + +pub struct decoder?( +) + +pub func decoder.decode?(dst writer1, src reader1)() { + // Read the header. + if in.src.read_u8?() != 0x1F { + return error "bad Gzip header" + } + if in.src.read_u8?() != 0x8B { + return error "bad Gzip header" + } +} diff --git a/test/c/std/crc32.c b/test/c/std/crc32.c index aca7a39a..86f9ac29 100644 --- a/test/c/std/crc32.c +++ b/test/c/std/crc32.c @@ -211,7 +211,7 @@ void bench_mimic_crc32_ieee_100k() { // ---------------- Manifest -// Note that the mimic tests and benches don't work with +// Note that the crc32 mimic tests and benches don't work with // WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB. // The empty comments forces clang-format to place one element per line. diff --git a/test/c/std/deflate.c b/test/c/std/deflate.c index fa9c2f24..f4963abd 100644 --- a/test/c/std/deflate.c +++ b/test/c/std/deflate.c @@ -105,16 +105,6 @@ golden_test deflate_romeo_fixed_gt = { .src_filename = "../../data/romeo.txt.fixed-huff.deflate", // }; -golden_test gzip_midsummer_gt = { - .want_filename = "../../data/midsummer.txt", // - .src_filename = "../../data/midsummer.txt.gz", // -}; - -golden_test gzip_pi_gt = { - .want_filename = "../../data/pi.txt", // - .src_filename = "../../data/pi.txt.gz", // -}; - // ---------------- Deflate Tests const char* wuffs_deflate_decode(wuffs_base__buf1* dst, @@ -589,16 +579,6 @@ void test_mimic_deflate_decode_romeo_fixed() { do_test_buf1_buf1(mimic_deflate_decode, &deflate_romeo_fixed_gt, 0, 0); } -void test_mimic_gzip_decode_midsummer() { - CHECK_FOCUS(__func__); - do_test_buf1_buf1(mimic_gzip_decode, &gzip_midsummer_gt, 0, 0); -} - -void test_mimic_gzip_decode_pi() { - CHECK_FOCUS(__func__); - do_test_buf1_buf1(mimic_gzip_decode, &gzip_pi_gt, 0, 0); -} - #endif // WUFFS_MIMIC // ---------------- Deflate Benches @@ -641,25 +621,10 @@ void bench_mimic_deflate_decode_100k() { do_bench_buf1_buf1(mimic_deflate_decode, tc_dst, &deflate_pi_gt, 0, 0, 3000); } -void bench_mimic_gzip_decode_10k() { - CHECK_FOCUS(__func__); - do_bench_buf1_buf1(mimic_gzip_decode, tc_dst, &gzip_midsummer_gt, 0, 0, - 30000); -} - -void bench_mimic_gzip_decode_100k() { - CHECK_FOCUS(__func__); - do_bench_buf1_buf1(mimic_gzip_decode, tc_dst, &gzip_pi_gt, 0, 0, 3000); -} - #endif // WUFFS_MIMIC // ---------------- Manifest -// TODO: move gzip tests and benches from std/deflate to std/gzip. -// Note that the gzip mimic tests and benches don't work with -// WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB. - // The empty comments forces clang-format to place one element per line. proc tests[] = { @@ -688,9 +653,6 @@ proc tests[] = { test_mimic_deflate_decode_romeo, // test_mimic_deflate_decode_romeo_fixed, // - test_mimic_gzip_decode_midsummer, // - test_mimic_gzip_decode_pi, // - #endif // WUFFS_MIMIC NULL, @@ -709,9 +671,6 @@ proc benches[] = { bench_mimic_deflate_decode_10k, // bench_mimic_deflate_decode_100k, // - bench_mimic_gzip_decode_10k, // - bench_mimic_gzip_decode_100k, // - #endif // WUFFS_MIMIC NULL, diff --git a/test/c/std/gzip.c b/test/c/std/gzip.c new file mode 100644 index 00000000..cc088cc0 --- /dev/null +++ b/test/c/std/gzip.c @@ -0,0 +1,169 @@ +// Copyright 2018 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/* +This test program is typically run indirectly, by the "wuffs test" or "wuffs +bench" commands. These commands take an optional "-mimic" flag to check that +Wuffs' output mimics (i.e. exactly matches) other libraries' output, such as +giflib for GIF, libpng for PNG, etc. + +To manually run this test: + +for cc in clang gcc; do + $cc -std=c99 -Wall -Werror gzip.c && ./a.out + rm -f a.out +done + +Each edition should print "PASS", amongst other information, and exit(0). + +Add the "wuffs mimic cflags" (everything after the colon below) to the C +compiler flags (after the .c file) to run the mimic tests. + +To manually run the benchmarks, replace "-Wall -Werror" with "-O3" and replace +the first "./a.out" with "./a.out -bench". Combine these changes with the +"wuffs mimic cflags" to run the mimic benchmarks. +*/ + +// !! wuffs mimic cflags: -DWUFFS_MIMIC -lz + +// 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/crc32.c" +#include "../../../gen/c/std/deflate.c" +#include "../../../gen/c/std/gzip.c" +#include "../testlib/testlib.c" +#ifdef WUFFS_MIMIC +#include "../mimiclib/deflate-gzip-zlib.c" +#endif + +// ---------------- Golden Tests + +golden_test gzip_midsummer_gt = { + .want_filename = "../../data/midsummer.txt", // + .src_filename = "../../data/midsummer.txt.gz", // +}; + +golden_test gzip_pi_gt = { + .want_filename = "../../data/pi.txt", // + .src_filename = "../../data/pi.txt.gz", // +}; + +// ---------------- Gzip Tests + +const char* wuffs_gzip_decode(wuffs_base__buf1* dst, + wuffs_base__buf1* src, + uint64_t wlimit, + uint64_t rlimit) { + // TODO. + return NULL; +} + +void test_wuffs_gzip_decode_midsummer() { + CHECK_FOCUS(__func__); + do_test_buf1_buf1(wuffs_gzip_decode, &gzip_midsummer_gt, 0, 0); +} + +void test_wuffs_gzip_decode_pi() { + CHECK_FOCUS(__func__); + do_test_buf1_buf1(wuffs_gzip_decode, &gzip_pi_gt, 0, 0); +} + + // ---------------- Mimic Tests + +#ifdef WUFFS_MIMIC + +void test_mimic_gzip_decode_midsummer() { + CHECK_FOCUS(__func__); + do_test_buf1_buf1(mimic_gzip_decode, &gzip_midsummer_gt, 0, 0); +} + +void test_mimic_gzip_decode_pi() { + CHECK_FOCUS(__func__); + do_test_buf1_buf1(mimic_gzip_decode, &gzip_pi_gt, 0, 0); +} + +#endif // WUFFS_MIMIC + +// ---------------- Gzip Benches + +void bench_wuffs_gzip_decode_10k() { + CHECK_FOCUS(__func__); + do_bench_buf1_buf1(wuffs_gzip_decode, tc_dst, &gzip_midsummer_gt, 0, 0, + 30000); +} + +void bench_wuffs_gzip_decode_100k() { + CHECK_FOCUS(__func__); + do_bench_buf1_buf1(wuffs_gzip_decode, tc_dst, &gzip_pi_gt, 0, 0, 3000); +} + + // ---------------- Mimic Benches + +#ifdef WUFFS_MIMIC + +void bench_mimic_gzip_decode_10k() { + CHECK_FOCUS(__func__); + do_bench_buf1_buf1(mimic_gzip_decode, tc_dst, &gzip_midsummer_gt, 0, 0, + 30000); +} + +void bench_mimic_gzip_decode_100k() { + CHECK_FOCUS(__func__); + do_bench_buf1_buf1(mimic_gzip_decode, tc_dst, &gzip_pi_gt, 0, 0, 3000); +} + +#endif // WUFFS_MIMIC + +// ---------------- Manifest + +// Note that the gzip mimic tests and benches don't work with +// WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB. + +// The empty comments forces clang-format to place one element per line. +proc tests[] = { + +// test_wuffs_gzip_decode_midsummer, // TODO: uncomment. +// test_wuffs_gzip_decode_pi, // TODO: uncomment. + +#ifdef WUFFS_MIMIC + + test_mimic_gzip_decode_midsummer, // + test_mimic_gzip_decode_pi, // + +#endif // WUFFS_MIMIC + + NULL, +}; + +// The empty comments forces clang-format to place one element per line. +proc benches[] = { + + bench_wuffs_gzip_decode_10k, // + bench_wuffs_gzip_decode_100k, // + +#ifdef WUFFS_MIMIC + + bench_mimic_gzip_decode_10k, // + bench_mimic_gzip_decode_100k, // + +#endif // WUFFS_MIMIC + + NULL, +}; + +int main(int argc, char** argv) { + proc_filename = "std/gzip.c"; + return test_main(argc, argv, tests, benches); +} diff --git a/test/c/std/zlib.c b/test/c/std/zlib.c index e96ed58a..4ba16697 100644 --- a/test/c/std/zlib.c +++ b/test/c/std/zlib.c @@ -401,6 +401,9 @@ void bench_mimic_zlib_decode_100k() { // ---------------- Manifest +// Note that the adler32 mimic tests and benches don't work with +// WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB. + // The empty comments forces clang-format to place one element per line. proc tests[] = {