diff --git a/doc/changelog.md b/doc/changelog.md index 2cc8c546..13493d7c 100644 --- a/doc/changelog.md +++ b/doc/changelog.md @@ -5,6 +5,7 @@ - Renamed Puffs to Wuffs. - Added a `yield` keyword. +- Spun `std/zlib` out of `std/flate`. ## 2017-11-16 diff --git a/gen/c/std/zlib.c b/gen/c/std/zlib.c new file mode 100644 index 00000000..78647387 --- /dev/null +++ b/gen/c/std/zlib.c @@ -0,0 +1,592 @@ +#ifndef WUFFS_ZLIB_H +#define WUFFS_ZLIB_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) + +// 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; + +#endif // WUFFS_BASE_HEADER_H + +#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_zlib__status__is_error instead. +typedef int32_t wuffs_zlib__status; + +#define wuffs_zlib__packageid 2064249 // 0x001F7F79 + +#define WUFFS_ZLIB__STATUS_OK 0 // 0x00000000 +#define WUFFS_ZLIB__ERROR_BAD_WUFFS_VERSION -2147483647 // 0x80000001 +#define WUFFS_ZLIB__ERROR_BAD_RECEIVER -2147483646 // 0x80000002 +#define WUFFS_ZLIB__ERROR_BAD_ARGUMENT -2147483645 // 0x80000003 +#define WUFFS_ZLIB__ERROR_INITIALIZER_NOT_CALLED -2147483644 // 0x80000004 +#define WUFFS_ZLIB__ERROR_INVALID_I_O_OPERATION -2147483643 // 0x80000005 +#define WUFFS_ZLIB__ERROR_CLOSED_FOR_WRITES -2147483642 // 0x80000006 +#define WUFFS_ZLIB__ERROR_UNEXPECTED_EOF -2147483641 // 0x80000007 +#define WUFFS_ZLIB__SUSPENSION_SHORT_READ 8 // 0x00000008 +#define WUFFS_ZLIB__SUSPENSION_SHORT_WRITE 9 // 0x00000009 +#define WUFFS_ZLIB__ERROR_CANNOT_RETURN_A_SUSPENSION -2147483638 // 0x8000000A + +bool wuffs_zlib__status__is_error(wuffs_zlib__status s); + +const char* wuffs_zlib__status__string(wuffs_zlib__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_zlib__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_zlib__status status; + uint32_t magic; + + } private_impl; +} wuffs_zlib__decoder; + +// ---------------- Public Initializer Prototypes + +// wuffs_zlib__decoder__initialize is an initializer function. +// +// It should be called before any other wuffs_zlib__decoder__* function. +// +// Pass WUFFS_VERSION and 0 for wuffs_version and for_internal_use_only. +void wuffs_zlib__decoder__initialize(wuffs_zlib__decoder* self, + uint32_t wuffs_version, + uint32_t for_internal_use_only); + +// ---------------- Public Function Prototypes + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // WUFFS_ZLIB_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) + +// 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; \ + 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/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 + // 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){}); +} + +#endif // WUFFS_BASE_IMPL_H + +// ---------------- Status Codes Implementations + +bool wuffs_zlib__status__is_error(wuffs_zlib__status s) { + return s < 0; +} + +const char* wuffs_zlib__status__strings0[11] = { + "zlib: ok", + "zlib: bad wuffs version", + "zlib: bad receiver", + "zlib: bad argument", + "zlib: initializer not called", + "zlib: invalid I/O operation", + "zlib: closed for writes", + "zlib: unexpected EOF", + "zlib: short read", + "zlib: short write", + "zlib: cannot return a suspension", +}; + +const char* wuffs_zlib__status__strings1[0] = {}; + +const char* wuffs_zlib__status__string(wuffs_zlib__status s) { + const char** a = NULL; + uint32_t n = 0; + switch ((s >> 10) & 0x1FFFFF) { + case 0: + a = wuffs_zlib__status__strings0; + n = 11; + break; + case wuffs_zlib__packageid: + a = wuffs_zlib__status__strings1; + n = 0; + break; + } + uint32_t i = s & 0xFF; + return i < n ? a[i] : "zlib: unknown status"; +} + +// ---------------- Private Consts + +// ---------------- Private Initializer Prototypes + +// ---------------- Private Function Prototypes + +// ---------------- Initializer Implementations + +void wuffs_zlib__decoder__initialize(wuffs_zlib__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_ZLIB__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 diff --git a/gen/h/std/zlib.h b/gen/h/std/zlib.h new file mode 100644 index 00000000..c5ee8a8b --- /dev/null +++ b/gen/h/std/zlib.h @@ -0,0 +1,180 @@ +#ifndef WUFFS_ZLIB_H +#define WUFFS_ZLIB_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) + +// 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; + +#endif // WUFFS_BASE_HEADER_H + +#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_zlib__status__is_error instead. +typedef int32_t wuffs_zlib__status; + +#define wuffs_zlib__packageid 2064249 // 0x001F7F79 + +#define WUFFS_ZLIB__STATUS_OK 0 // 0x00000000 +#define WUFFS_ZLIB__ERROR_BAD_WUFFS_VERSION -2147483647 // 0x80000001 +#define WUFFS_ZLIB__ERROR_BAD_RECEIVER -2147483646 // 0x80000002 +#define WUFFS_ZLIB__ERROR_BAD_ARGUMENT -2147483645 // 0x80000003 +#define WUFFS_ZLIB__ERROR_INITIALIZER_NOT_CALLED -2147483644 // 0x80000004 +#define WUFFS_ZLIB__ERROR_INVALID_I_O_OPERATION -2147483643 // 0x80000005 +#define WUFFS_ZLIB__ERROR_CLOSED_FOR_WRITES -2147483642 // 0x80000006 +#define WUFFS_ZLIB__ERROR_UNEXPECTED_EOF -2147483641 // 0x80000007 +#define WUFFS_ZLIB__SUSPENSION_SHORT_READ 8 // 0x00000008 +#define WUFFS_ZLIB__SUSPENSION_SHORT_WRITE 9 // 0x00000009 +#define WUFFS_ZLIB__ERROR_CANNOT_RETURN_A_SUSPENSION -2147483638 // 0x8000000A + +bool wuffs_zlib__status__is_error(wuffs_zlib__status s); + +const char* wuffs_zlib__status__string(wuffs_zlib__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_zlib__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_zlib__status status; + uint32_t magic; + + } private_impl; +} wuffs_zlib__decoder; + +// ---------------- Public Initializer Prototypes + +// wuffs_zlib__decoder__initialize is an initializer function. +// +// It should be called before any other wuffs_zlib__decoder__* function. +// +// Pass WUFFS_VERSION and 0 for wuffs_version and for_internal_use_only. +void wuffs_zlib__decoder__initialize(wuffs_zlib__decoder* self, + uint32_t wuffs_version, + uint32_t for_internal_use_only); + +// ---------------- Public Function Prototypes + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // WUFFS_ZLIB_H diff --git a/std/flate/decode_flate.wuffs b/std/flate/decode_flate.wuffs index 3133748d..e0f845ac 100644 --- a/std/flate/decode_flate.wuffs +++ b/std/flate/decode_flate.wuffs @@ -14,6 +14,15 @@ 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: delete std/flate/decode_zlib.wuffs, and update std/flate/README.md. +// +// Would we then need to somehow share code between test/c/std/{flate,gzip}.c? + +// TODO: rename flate to deflate, since that's what RFC 1951 calls it. + pub error "bad Huffman code (over-subscribed)" pub error "bad Huffman code (under-subscribed)" pub error "bad Huffman code length count" diff --git a/std/flate/decode_zlib.wuffs b/std/flate/decode_zlib.wuffs index 2f5369b7..8908cd8d 100644 --- a/std/flate/decode_zlib.wuffs +++ b/std/flate/decode_zlib.wuffs @@ -18,13 +18,6 @@ pub error "invalid zlib parity check" pub error "TODO: unsupported zlib preset dictionary" -// TODO: move this file from std/flate to std/zlib? In doing so, we could -// rename both of "struct flate_decoder" and "struct zlib_decoder" to just -// "struct decoder", to avoid stutter in the fully qualified C name such as -// "wuffs_flate__flate_decoder". -// -// Would we then need to somehow share code between test/c/std/{flate,gzip}.c? - pub struct zlib_decoder?( flate flate_decoder, adler adler32, diff --git a/std/zlib/README.md b/std/zlib/README.md new file mode 100644 index 00000000..d0846976 --- /dev/null +++ b/std/zlib/README.md @@ -0,0 +1,9 @@ +# Zlib + +zlib ([RFC 1950](https://www.ietf.org/rfc/rfc1950.txt)) is a thin wrapper +around raw deflate (RFC 1951). Zlib is similar to gzip (RFC 1952), but with a +different wire format and checksum algorithm. + +zlib is used by the ELF executable and PNG image file formats. + +TODO: a worked example. diff --git a/std/zlib/decode_zlib.wuffs b/std/zlib/decode_zlib.wuffs new file mode 100644 index 00000000..954c9f8c --- /dev/null +++ b/std/zlib/decode_zlib.wuffs @@ -0,0 +1,18 @@ +// 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. + +packageid "zlib" + +pub struct decoder?( +) diff --git a/test/c/mimiclib/flate.c b/test/c/mimiclib/flate.c index a4d3878c..f6794b3f 100644 --- a/test/c/mimiclib/flate.c +++ b/test/c/mimiclib/flate.c @@ -14,6 +14,8 @@ #include "zlib.h" +// TODO: rename this file to "deflate-gzip-zlib.c". + uint32_t global_mimiclib_flate_unused_u32; const char* mimic_bench_adler32(wuffs_base__buf1* dst, diff --git a/test/c/std/zlib.c b/test/c/std/zlib.c new file mode 100644 index 00000000..0e70cb31 --- /dev/null +++ b/test/c/std/zlib.c @@ -0,0 +1,65 @@ +// 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. + +/* +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 zlib.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/flate.c" +#include "../../../gen/c/std/zlib.c" +#include "../testlib/testlib.c" +#ifdef WUFFS_MIMIC +#include "../mimiclib/flate.c" +#endif + +// ---------------- Manifest + +// The empty comments forces clang-format to place one element per line. +proc tests[] = { + NULL, +}; + +// The empty comments forces clang-format to place one element per line. +proc benches[] = { + NULL, +}; + +int main(int argc, char** argv) { + proc_filename = "std/zlib.c"; + return test_main(argc, argv, tests, benches); +}