Make the status type a const char*, not a struct

This commit is contained in:
Nigel Tao committed 2018-08-12 16:05:14 +10:00
1 parent e0311e3bb2
commit b840c80040
24 files changed
+624 -815

No files matched your search

@@ -56,10 +56,10 @@ static inline void wuffs_base__ignore_check_wuffs_version_status(
case n:;
#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \
if (status.code < 0) { \
goto exit; \
} else if (status.code == 0) { \
if (!status) { \
goto ok; \
} else if (*status != '$') { \
goto exit; \
} \
coro_susp_point = n; \
goto suspend; \
+13 -29
View File
@@ -99,45 +99,29 @@ typedef struct {
// --------
// A status code is either zero (OK), positive (a recoverable suspension or
// pause in processing) or negative (a non-recoverable error). Its bits:
// - bit 31 (the sign bit) indicates unrecoverable-ness: an error.
// - bits 30 .. 24 are a package-namespaced numeric code
// - bits 23 .. 21 are reserved.
// - bits 20 .. 0 are the packageid (a namespace) as a base38 value.
// A status is either NULL (meaning OK or no error) or string message. That
// message is human-readable, for programmers, but it is not for end users. It
// is not localized, and does not contain additional contextual information
// such as a source filename.
//
// Do not manipulate these bits directly; they are private implementation
// details. Use methods such as wuffs_base__status__is_error instead.
typedef struct {
int32_t code;
const char* msg;
} wuffs_base__status;
// Status strings are statically allocated and should never be free'd.
typedef const char* wuffs_base__status;
// !! INSERT wuffs_base__status names.
// TODO: turn WUFFS_BASE__MAKE_STATUS into a macro, and add a msg field.
static inline wuffs_base__status //
WUFFS_BASE__MAKE_STATUS(int32_t code) {
return ((wuffs_base__status){
.code = code,
.msg = NULL,
});
static inline bool //
wuffs_base__status__is_error(wuffs_base__status z) {
return z && (*z != '$');
}
static inline bool //
wuffs_base__status__is_error(wuffs_base__status s) {
return s.code < 0;
wuffs_base__status__is_ok(wuffs_base__status z) {
return z == NULL;
}
static inline bool //
wuffs_base__status__is_ok(wuffs_base__status s) {
return s.code == 0;
}
static inline bool //
wuffs_base__status__is_suspension(wuffs_base__status s) {
return s.code > 0;
wuffs_base__status__is_suspension(wuffs_base__status z) {
return z && (*z == '$');
}
const char* //
@@ -809,18 +809,17 @@ wuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b,
wuffs_base__pixel_config* pixcfg,
wuffs_base__slice_u8 pixbuf_memory) {
if (!b) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
*b = ((wuffs_base__pixel_buffer){});
if (!pixcfg) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_ARGUMENT);
return wuffs_base__error__bad_argument;
}
// TODO: don't assume 1 byte per pixel. Don't assume packed.
uint64_t wh = ((uint64_t)pixcfg->private_impl.width) *
((uint64_t)pixcfg->private_impl.height);
if (wh > pixbuf_memory.len) {
return WUFFS_BASE__MAKE_STATUS(
WUFFS_BASE__ERROR_BAD_ARGUMENT_LENGTH_TOO_SHORT);
return wuffs_base__error__bad_argument_length_too_short;
}
b->private_impl.pixcfg = *pixcfg;
wuffs_base__table_u8* tab = &b->private_impl.planes[0];
@@ -828,7 +827,7 @@ wuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b,
tab->width = pixcfg->private_impl.width;
tab->height = pixcfg->private_impl.height;
tab->stride = pixcfg->private_impl.width;
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
return NULL;
}
// The palette argument is ignored unless its length is exactly 1024.
+3 -3
View File
@@ -409,7 +409,7 @@ func (g *gen) writeBuiltinCallSuspendibles(b *buffer, n *a.Expr, depth uint32) e
g.currFunk.tempW++
b.printf("if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {" +
"status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; }")
"status = wuffs_base__suspension__short_read; goto suspend; }")
// TODO: watch for passing an array type to writeCTypeName? In C, an
// array type can decay into a pointer.
@@ -470,7 +470,7 @@ func (g *gen) writeBuiltinCallSuspendibles(b *buffer, n *a.Expr, depth uint32) e
b.printf("%s -= io1_a_src - iop_a_src;\n", scratchName)
b.printf("iop_a_src = io1_a_src;\n")
b.writes("status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; }\n")
b.writes("status = wuffs_base__suspension__short_read; goto suspend; }\n")
b.printf("iop_a_src += %s;\n", scratchName)
return nil
}
@@ -479,7 +479,7 @@ func (g *gen) writeBuiltinCallSuspendibles(b *buffer, n *a.Expr, depth uint32) e
switch method.Ident() {
case t.IDWriteU8:
b.writes("if (iop_a_dst == io1_a_dst) {\n" +
"status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE); goto suspend; }\n" +
"status = wuffs_base__suspension__short_write; goto suspend; }\n" +
"*iop_a_dst++ = ")
x := n.Args()[0].AsArg().Value()
if err := g.writeExpr(b, x, replaceCallSuspendibles, depth); err != nil {
+7 -7
View File
@@ -724,7 +724,7 @@ func (g *gen) writeConstList(b *buffer, n *a.Expr) error {
func (g *gen) writeStruct(b *buffer, n *a.Struct) error {
// For API/ABI compatibility, the very first field in the struct's
// private_impl must be the status code. This lets the initializer callee
// set "self->private_impl.status = WUFFS_BASE__ERROR_BAD_WUFFS_VERSION;"
// set "self->private_impl.status = wuffs_base__error__bad_wuffs_version;"
// regardless of the sizeof(*self) struct reserved by the caller and even
// if the caller and callee were built with different versions.
structName := n.QID().Str(g.tm)
@@ -983,17 +983,17 @@ func (g *gen) writeInitializerImpl(b *buffer, n *a.Struct) error {
return err
}
b.writes("{\n")
b.writes("if (!self) { return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER); }\n")
b.writes("if (!self) { return wuffs_base__error__bad_receiver; }\n")
b.writes("if (sizeof(*self) != sizeof_star_self) {\n")
b.writes("return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER);\n")
b.writes("return wuffs_base__error__bad_sizeof_receiver;\n")
b.writes("}\n")
b.writes("if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) || " +
"(((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {\n")
b.writes("return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION);\n")
b.writes("return wuffs_base__error__bad_wuffs_version;\n")
b.writes("}\n")
b.writes("if (self->private_impl.magic != 0) {\n")
b.writes("return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE);\n")
b.writes("return wuffs_base__error__check_wuffs_version_called_twice;\n")
b.writes("}\n")
// Call any ctors on sub-structs.
@@ -1022,12 +1022,12 @@ func (g *gen) writeInitializerImpl(b *buffer, n *a.Struct) error {
b.printf("wuffs_base__status z = %s%s__check_wuffs_version("+
"&self->private_impl.%s%s, sizeof(self->private_impl.%s%s), WUFFS_VERSION);\n",
prefix, qid[1].Str(g.tm), fPrefix, f.Name().Str(g.tm), fPrefix, f.Name().Str(g.tm))
b.printf("if (z.code) { return z; }\n")
b.printf("if (z) { return z; }\n")
b.printf("}\n")
}
b.writes("self->private_impl.magic = WUFFS_BASE__MAGIC;\n")
b.writes("return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);\n")
b.writes("return NULL;\n")
b.writes("}\n\n")
return nil
}
+6 -7
View File
@@ -22,8 +22,7 @@ const baseBasePublicH = "" +
"nt.com/nothings/stb/master/docs/stb_howto.txt\n#ifdef WUFFS_CONFIG__STATIC_FUNCTIONS\n#define WUFFS_BASE__MAYBE_STATIC static\n#else\n#define WUFFS_BASE__MAYBE_STATIC\n#endif\n\n// Clang also defines \"__GNUC__\".\n#if defined(__GNUC__)\n#define WUFFS_BASE__WARN_UNUSED_RESULT __attribute__((warn_unused_result))\n#else\n#define WUFFS_BASE__WARN_UNUSED_RESULT\n#endif\n\n// wuffs_base__empty_struct is used when a Wuffs function returns an empty\n// struct. In C, if a function f returns void, you can't say \"x = f()\", but in\n// Wuffs, if a function g returns empty, you can say \"y = g()\".\ntypedef struct {\n // private_impl is a placeholder field. It isn't explicitly used, except that\n // without it, the sizeof a struct with no fields can differ across C/C++\n // compilers, and it is undefined behavior in C99. For example, gcc says that\n // the sizeof an empty struct is 0, and g++ says that it is 1. This leads to\n // ABI incompatibility if a Wuffs .c file is processed by one compiler and\n // its .h file with another compiler.\n " +
"//\n // Instead, we explicitly insert an otherwise unused field, so that the\n // sizeof this struct is always 1.\n uint8_t private_impl;\n} wuffs_base__empty_struct;\n\n// wuffs_base__utility is a placeholder receiver type. It enables what Java\n// calls static methods, as opposed to regular methods.\ntypedef struct {\n // private_impl is a placeholder field. It isn't explicitly used, except that\n // without it, the sizeof a struct with no fields can differ across C/C++\n // compilers, and it is undefined behavior in C99. For example, gcc says that\n // the sizeof an empty struct is 0, and g++ says that it is 1. This leads to\n // ABI incompatibility if a Wuffs .c file is processed by one compiler and\n // its .h file with another compiler.\n //\n // Instead, we explicitly insert an otherwise unused field, so that the\n // sizeof this struct is always 1.\n uint8_t private_impl;\n} wuffs_base__utility;\n\n" +
"" +
"// --------\n\n// A status code is either zero (OK), positive (a recoverable suspension or\n// pause in processing) or negative (a non-recoverable error). Its bits:\n// - bit 31 (the sign bit) indicates unrecoverable-ness: an error.\n// - bits 30 .. 24 are a package-namespaced numeric code\n// - bits 23 .. 21 are reserved.\n// - bits 20 .. 0 are the packageid (a namespace) as a base38 value.\n//\n// Do not manipulate these bits directly; they are private implementation\n// details. Use methods such as wuffs_base__status__is_error instead.\ntypedef struct {\n int32_t code;\n const char* msg;\n} wuffs_base__status;\n\n// !! INSERT wuffs_base__status names.\n\n// TODO: turn WUFFS_BASE__MAKE_STATUS into a macro, and add a msg field.\n\nstatic inline wuffs_base__status //\nWUFFS_BASE__MAKE_STATUS(int32_t code) {\n return ((wuffs_base__status){\n .code = code,\n .msg = NULL,\n });\n}\n\nstatic inline bool //\nwuffs_base__status__is_error(wuffs_base__status s) {\n return s.code < 0;\n}\n\nstatic inline bool //\nwuffs_ba" +
"se__status__is_ok(wuffs_base__status s) {\n return s.code == 0;\n}\n\nstatic inline bool //\nwuffs_base__status__is_suspension(wuffs_base__status s) {\n return s.code > 0;\n}\n\nconst char* //\nwuffs_base__status__string(int32_t status_code);\n\n" +
"// --------\n\n// A status is either NULL (meaning OK or no error) or string message. That\n// message is human-readable, for programmers, but it is not for end users. It\n// is not localized, and does not contain additional contextual information\n// such as a source filename.\n//\n// Status strings are statically allocated and should never be free'd.\ntypedef const char* wuffs_base__status;\n\n// !! INSERT wuffs_base__status names.\n\nstatic inline bool //\nwuffs_base__status__is_error(wuffs_base__status z) {\n return z && (*z != '$');\n}\n\nstatic inline bool //\nwuffs_base__status__is_ok(wuffs_base__status z) {\n return z == NULL;\n}\n\nstatic inline bool //\nwuffs_base__status__is_suspension(wuffs_base__status z) {\n return z && (*z == '$');\n}\n\nconst char* //\nwuffs_base__status__string(int32_t status_code);\n\n" +
"" +
"// --------\n\n// Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a\n// second. See https://github.com/OculusVR/Flicks\ntypedef int64_t wuffs_base__flicks;\n\n#define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000)\n#define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600)\n\n" +
"" +
@@ -74,7 +73,7 @@ const baseBasePublicH = "" +
const baseBasePrivateH = "" +
"#ifndef WUFFS_INCLUDE_GUARD__BASE_PRIVATE\n#define WUFFS_INCLUDE_GUARD__BASE_PRIVATE\n\n// Copyright 2017 The Wuffs Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// https://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#define WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(x) (void)(x)\n\nstatic inline void wuffs_base__ignore_check_wuffs_version_status(\n wuffs_base__status z) {}\n\n// WUFFS_BASE__MAGIC is a magic number to check that initializers are called.\n// It's not foolproof, given C doesn't automatically zero me" +
"mory before use,\n// but it should catch 99.99% of cases.\n//\n// Its (non-zero) value is arbitrary, based on md5sum(\"wuffs\").\n#define WUFFS_BASE__MAGIC ((uint32_t)0x3CCB6C71)\n\n// Denote intentional fallthroughs for -Wimplicit-fallthrough.\n//\n// The order matters here. Clang also defines \"__GNUC__\".\n#if defined(__clang__) && __cplusplus >= 201103L\n#define WUFFS_BASE__FALLTHROUGH [[clang::fallthrough]]\n#elif !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 7)\n#define WUFFS_BASE__FALLTHROUGH __attribute__((fallthrough))\n#else\n#define WUFFS_BASE__FALLTHROUGH\n#endif\n\n// Use switch cases for coroutine suspension points, similar to the technique\n// in https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html\n//\n// We use trivial macros instead of an explicit assignment and case statement\n// so that clang-format doesn't get confused by the unusual \"case\"s.\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0 case 0:;\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT(n) \\\n coro_susp_point = n; " +
" \\\n WUFFS_BASE__FALLTHROUGH; \\\n case n:;\n\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \\\n if (status.code < 0) { \\\n goto exit; \\\n } else if (status.code == 0) { \\\n goto ok; \\\n } \\\n coro_susp_point = n; \\\n goto suspend; \\\n case n:;\n\n// Clang also defines \"__GNUC__\".\n#if defined(__GNUC__)\n#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1))\n#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))\n#else\n#define WUFFS_BASE__LIKELY(expr) (expr)\n#define WUFFS_BASE__UNLIKELY(expr) (expr)\n#endif\n\n// The helpers below are functions, instead of macros, because their arguments\n// can be an expression that we shouldn't evaluat" +
" \\\n WUFFS_BASE__FALLTHROUGH; \\\n case n:;\n\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \\\n if (!status) { \\\n goto ok; \\\n } else if (*status != '$') { \\\n goto exit; \\\n } \\\n coro_susp_point = n; \\\n goto suspend; \\\n case n:;\n\n// Clang also defines \"__GNUC__\".\n#if defined(__GNUC__)\n#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1))\n#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))\n#else\n#define WUFFS_BASE__LIKELY(expr) (expr)\n#define WUFFS_BASE__UNLIKELY(expr) (expr)\n#endif\n\n// The helpers below are functions, instead of macros, because their arguments\n// can be an expression that we shouldn't evaluat" +
"e more than once.\n//\n// They are static, so that linking multiple wuffs .o files won't complain about\n// duplicate function definitions.\n//\n// They are explicitly marked inline, even if modern compilers don't use the\n// inline attribute to guide optimizations such as inlining, to avoid the\n// -Wunused-function warning, and we like to compile with -Wall -Werror.\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__return_empty_struct() {\n return ((wuffs_base__empty_struct){});\n}\n\n" +
"" +
"// ---------------- Numeric Types\n\nstatic inline uint8_t //\nwuffs_base__load_u8be(uint8_t* p) {\n return p[0];\n}\n\nstatic inline uint16_t //\nwuffs_base__load_u16be(uint8_t* p) {\n return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0);\n}\n\nstatic inline uint16_t //\nwuffs_base__load_u16le(uint8_t* p) {\n return ((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8);\n}\n\nstatic inline uint32_t //\nwuffs_base__load_u24be(uint8_t* p) {\n return ((uint32_t)(p[0]) << 16) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 0);\n}\n\nstatic inline uint32_t //\nwuffs_base__load_u24le(uint8_t* p) {\n return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 16);\n}\n\nstatic inline uint32_t //\nwuffs_base__load_u32be(uint8_t* p) {\n return ((uint32_t)(p[0]) << 24) | ((uint32_t)(p[1]) << 16) |\n ((uint32_t)(p[2]) << 8) | ((uint32_t)(p[3]) << 0);\n}\n\nstatic inline uint32_t //\nwuffs_base__load_u32le(uint8_t* p) {\n return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |\n ((uin" +
@@ -155,8 +154,8 @@ const baseImagePublicH = "" +
"wuffs_base__frame_config__height(this);\n}\n\ninline wuffs_base__flicks //\nwuffs_base__frame_config::duration() {\n return wuffs_base__frame_config__duration(this);\n}\n\ninline bool //\nwuffs_base__frame_config::blend() {\n return wuffs_base__frame_config__blend(this);\n}\n\ninline wuffs_base__animation_disposal //\nwuffs_base__frame_config::disposal() {\n return wuffs_base__frame_config__disposal(this);\n}\n\ninline bool //\nwuffs_base__frame_config::palette_changed() {\n return wuffs_base__frame_config__palette_changed(this);\n}\n\n#endif // __cplusplus\n\n" +
"" +
"// --------\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__pixel_config pixcfg;\n wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX];\n uint8_t palette[1024];\n // TODO: color spaces.\n } private_impl;\n\n#ifdef __cplusplus\n inline wuffs_base__status set_from_slice(wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory);\n inline void set_palette(wuffs_base__slice_u8 palette);\n inline wuffs_base__pixel_config* pixel_config();\n inline wuffs_base__rect_ie_u32 bounds();\n inline uint32_t width();\n inline uint32_t height();\n inline wuffs_base__table_u8 plane(uint32_t p);\n inline wuffs_base__slice_u8 palette();\n#endif // __cplusplus\n\n} wuffs_base__pixel_buffer;\n\nstatic inline wuffs_base__status //\nwuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b,\n " +
" wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory) {\n if (!b) {\n return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);\n }\n *b = ((wuffs_base__pixel_buffer){});\n if (!pixcfg) {\n return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_ARGUMENT);\n }\n // TODO: don't assume 1 byte per pixel. Don't assume packed.\n uint64_t wh = ((uint64_t)pixcfg->private_impl.width) *\n ((uint64_t)pixcfg->private_impl.height);\n if (wh > pixbuf_memory.len) {\n return WUFFS_BASE__MAKE_STATUS(\n WUFFS_BASE__ERROR_BAD_ARGUMENT_LENGTH_TOO_SHORT);\n }\n b->private_impl.pixcfg = *pixcfg;\n wuffs_base__table_u8* tab = &b->private_impl.planes[0];\n tab->ptr = pixbuf_memory.ptr;\n tab->width = pixcfg->private_impl.width;\n tab->height = pixcfg->private_impl.height;\n tab->stride = pixcfg->private_impl.width;\n return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);\n}\n\n// The palette argument is ignored unless its length is exactly 1024.\ns" +
"tatic inline void //\nwuffs_base__pixel_buffer__set_palette(wuffs_base__pixel_buffer* b,\n wuffs_base__slice_u8 palette) {\n if (b && palette.ptr && (palette.len == 1024)) {\n memmove(b->private_impl.palette, palette.ptr, 1024);\n }\n}\n\n// wuffs_base__pixel_config returns the overall configuration for this frame.\nstatic inline wuffs_base__pixel_config* //\nwuffs_base__pixel_buffer__pixel_config(wuffs_base__pixel_buffer* b) {\n return b ? &b->private_impl.pixcfg : NULL;\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__pixel_buffer__bounds(wuffs_base__pixel_buffer* b) {\n return b ? wuffs_base__pixel_config__bounds(&b->private_impl.pixcfg)\n : ((wuffs_base__rect_ie_u32){});\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_buffer__width(wuffs_base__pixel_buffer* b) {\n return b ? wuffs_base__pixel_config__width(&b->private_impl.pixcfg) : 0;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_buffer__height(wuffs_base__pixel_buffer* b) {\n return b ? wuffs_base__pi" +
"xel_config__height(&b->private_impl.pixcfg) : 0;\n}\n\nstatic inline wuffs_base__table_u8 //\nwuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* b, uint32_t p) {\n return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX))\n ? b->private_impl.planes[p]\n : ((wuffs_base__table_u8){});\n}\n\n// wuffs_base__pixel_buffer__palette returns the palette that the pixel data\n// can index. The backing array is inside b and has length 1024.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* b) {\n return b ? ((wuffs_base__slice_u8){.ptr = b->private_impl.palette,\n .len = 1024})\n : ((wuffs_base__slice_u8){});\n}\n\n#ifdef __cplusplus\n\ninline wuffs_base__status //\nwuffs_base__pixel_buffer::set_from_slice(wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory) {\n return wuffs_base__pixel_buffer__set_from_slice(this, pixcfg, pixbuf_memory);\n}\n\ninline void" +
" //\nwuffs_base__pixel_buffer::set_palette(wuffs_base__slice_u8 palette) {\n wuffs_base__pixel_buffer__set_palette(this, palette);\n}\n\ninline wuffs_base__pixel_config* //\nwuffs_base__pixel_buffer::pixel_config() {\n return wuffs_base__pixel_buffer__pixel_config(this);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__pixel_buffer::bounds() {\n return wuffs_base__pixel_buffer__bounds(this);\n}\n\ninline uint32_t //\nwuffs_base__pixel_buffer::width() {\n return wuffs_base__pixel_buffer__width(this);\n}\n\ninline uint32_t //\nwuffs_base__pixel_buffer::height() {\n return wuffs_base__pixel_buffer__height(this);\n}\n\ninline wuffs_base__table_u8 //\nwuffs_base__pixel_buffer::plane(uint32_t p) {\n return wuffs_base__pixel_buffer__plane(this, p);\n}\n\ninline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer::palette() {\n return wuffs_base__pixel_buffer__palette(this);\n}\n\n#endif // __cplusplus\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n" +
" wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory) {\n if (!b) {\n return wuffs_base__error__bad_receiver;\n }\n *b = ((wuffs_base__pixel_buffer){});\n if (!pixcfg) {\n return wuffs_base__error__bad_argument;\n }\n // TODO: don't assume 1 byte per pixel. Don't assume packed.\n uint64_t wh = ((uint64_t)pixcfg->private_impl.width) *\n ((uint64_t)pixcfg->private_impl.height);\n if (wh > pixbuf_memory.len) {\n return wuffs_base__error__bad_argument_length_too_short;\n }\n b->private_impl.pixcfg = *pixcfg;\n wuffs_base__table_u8* tab = &b->private_impl.planes[0];\n tab->ptr = pixbuf_memory.ptr;\n tab->width = pixcfg->private_impl.width;\n tab->height = pixcfg->private_impl.height;\n tab->stride = pixcfg->private_impl.width;\n return NULL;\n}\n\n// The palette argument is ignored unless its length is exactly 1024.\nstatic inline void //\nwuffs_base__pixel_buffer__set_palette(wuffs_base__pixel_buffer* b,\n " +
" wuffs_base__slice_u8 palette) {\n if (b && palette.ptr && (palette.len == 1024)) {\n memmove(b->private_impl.palette, palette.ptr, 1024);\n }\n}\n\n// wuffs_base__pixel_config returns the overall configuration for this frame.\nstatic inline wuffs_base__pixel_config* //\nwuffs_base__pixel_buffer__pixel_config(wuffs_base__pixel_buffer* b) {\n return b ? &b->private_impl.pixcfg : NULL;\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__pixel_buffer__bounds(wuffs_base__pixel_buffer* b) {\n return b ? wuffs_base__pixel_config__bounds(&b->private_impl.pixcfg)\n : ((wuffs_base__rect_ie_u32){});\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_buffer__width(wuffs_base__pixel_buffer* b) {\n return b ? wuffs_base__pixel_config__width(&b->private_impl.pixcfg) : 0;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_buffer__height(wuffs_base__pixel_buffer* b) {\n return b ? wuffs_base__pixel_config__height(&b->private_impl.pixcfg) : 0;\n}\n\nstatic inline wuffs_base__table_u8 //\nwuffs_base__pixel_buffer__plane(" +
"wuffs_base__pixel_buffer* b, uint32_t p) {\n return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX))\n ? b->private_impl.planes[p]\n : ((wuffs_base__table_u8){});\n}\n\n// wuffs_base__pixel_buffer__palette returns the palette that the pixel data\n// can index. The backing array is inside b and has length 1024.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* b) {\n return b ? ((wuffs_base__slice_u8){.ptr = b->private_impl.palette,\n .len = 1024})\n : ((wuffs_base__slice_u8){});\n}\n\n#ifdef __cplusplus\n\ninline wuffs_base__status //\nwuffs_base__pixel_buffer::set_from_slice(wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory) {\n return wuffs_base__pixel_buffer__set_from_slice(this, pixcfg, pixbuf_memory);\n}\n\ninline void //\nwuffs_base__pixel_buffer::set_palette(wuffs_base__slice_u8 palette) {\n wuffs_base__pixel_buffer__set_palette(this, pa" +
"lette);\n}\n\ninline wuffs_base__pixel_config* //\nwuffs_base__pixel_buffer::pixel_config() {\n return wuffs_base__pixel_buffer__pixel_config(this);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__pixel_buffer::bounds() {\n return wuffs_base__pixel_buffer__bounds(this);\n}\n\ninline uint32_t //\nwuffs_base__pixel_buffer::width() {\n return wuffs_base__pixel_buffer__width(this);\n}\n\ninline uint32_t //\nwuffs_base__pixel_buffer::height() {\n return wuffs_base__pixel_buffer__height(this);\n}\n\ninline wuffs_base__table_u8 //\nwuffs_base__pixel_buffer::plane(uint32_t p) {\n return wuffs_base__pixel_buffer__plane(this, p);\n}\n\ninline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer::palette() {\n return wuffs_base__pixel_buffer__palette(this);\n}\n\n#endif // __cplusplus\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n" +
""
+18 -15
View File
@@ -16,7 +16,6 @@ package cgen
import (
"fmt"
"strings"
"github.com/google/wuffs/lang/builtin"
@@ -210,16 +209,28 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, depth u
return nil
case t.IDError, t.IDStatus, t.IDSuspension:
status := g.statusMap[n.StatusQID()]
if status.name == "" {
if z := g.statusMap[n.StatusQID()]; z.cName != "" {
b.writes(g.pkgPrefix)
if z.keyword == t.IDSuspension {
b.writes("suspension__")
} else {
b.writes("error__")
}
b.writes(z.cName)
} else {
msg, _ := t.Unescape(n.Ident().Str(g.tm))
z := builtin.StatusMap[msg]
if z.Message == "" {
return fmt.Errorf("no status code for %q", msg)
}
status.name = strings.ToUpper(cName(z.String(), "WUFFS_BASE__"))
b.writes("wuffs_base__")
if z.Keyword == t.IDSuspension {
b.writes("suspension__")
} else {
b.writes("error__")
}
b.writes(cName(z.Message, ""))
}
b.printf("WUFFS_BASE__MAKE_STATUS(%s)", status.name)
return nil
}
return fmt.Errorf("unrecognized token (0x%X) for writeExprOther", n.Operator())
@@ -237,15 +248,10 @@ func (g *gen) writeExprUnaryOp(b *buffer, n *a.Expr, rp replacementPolicy, depth
}
func (g *gen) writeExprBinaryOp(b *buffer, n *a.Expr, rp replacementPolicy, depth uint32) error {
opName, extra := "", ""
opName := ""
op := n.Operator()
switch op {
case t.IDXBinaryEqEq, t.IDXBinaryNotEq:
if lhs := n.LHS().AsExpr(); lhs.MType().IsStatus() {
extra = ".code"
}
case t.IDXBinaryTildeSatPlus, t.IDXBinaryTildeSatMinus:
uBits := uintBits(n.MType().QID())
if uBits == 0 {
@@ -260,9 +266,8 @@ func (g *gen) writeExprBinaryOp(b *buffer, n *a.Expr, rp replacementPolicy, dept
case t.IDXBinaryAs:
return g.writeExprAs(b, n.LHS().AsExpr(), n.RHS().AsTypeExpr(), rp, depth)
}
if opName == "" {
default:
opName = cOpName(op)
if opName == "" {
return fmt.Errorf("unrecognized operator %q", op.AmbiguousForm().Str(g.tm))
@@ -273,12 +278,10 @@ func (g *gen) writeExprBinaryOp(b *buffer, n *a.Expr, rp replacementPolicy, dept
if err := g.writeExpr(b, n.LHS().AsExpr(), rp, depth); err != nil {
return err
}
b.writes(extra)
b.writes(opName)
if err := g.writeExpr(b, n.RHS().AsExpr(), rp, depth); err != nil {
return err
}
b.writes(extra)
b.writeb(')')
return nil
}
+7 -7
View File
@@ -223,16 +223,16 @@ func (g *gen) writeFuncImplHeader(b *buffer) error {
b.writes("if (!self) { return ")
if g.currFunk.suspendible {
b.writes("WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER)")
b.writes("wuffs_base__error__bad_receiver")
} else if err := g.writeOutParamZeroValue(b, out); err != nil {
return err
}
b.writes(";}")
b.writes("if (self->private_impl.magic != WUFFS_BASE__MAGIC) {" +
"self->private_impl.status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING); }")
"self->private_impl.status = wuffs_base__error__check_wuffs_version_missing; }")
b.writes("if (self->private_impl.status.code < 0) { return ")
b.writes("if (wuffs_base__status__is_error(self->private_impl.status)) { return ")
if g.currFunk.suspendible {
b.writes("self->private_impl.status")
} else if err := g.writeOutParamZeroValue(b, out); err != nil {
@@ -250,7 +250,7 @@ func (g *gen) writeFuncImplHeader(b *buffer) error {
}
if g.currFunk.suspendible {
b.printf("wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);\n")
b.printf("wuffs_base__status status = NULL;\n")
}
b.writes("\n")
@@ -408,12 +408,12 @@ func (g *gen) writeFuncImplArgChecks(b *buffer, n *a.Func) error {
b.writes(") {")
if g.currFunk.suspendible {
if g.currFunk.public {
b.writes("self->private_impl.status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_ARGUMENT);\n")
b.writes("self->private_impl.status = wuffs_base__error__bad_argument;\n")
}
b.writes("return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_ARGUMENT);\n\n")
b.writes("return wuffs_base__error__bad_argument;\n\n")
} else if !n.Receiver().IsZero() {
// TODO: unused code path??
b.writes("self->private_impl.status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_ARGUMENT); return;")
b.writes("self->private_impl.status = wuffs_base__error__bad_argument; return;")
} else {
b.printf("return;")
}
+6 -5
View File
@@ -309,7 +309,7 @@ func (g *gen) writeStatementRet(b *buffer, n *a.Ret, depth uint32) error {
b.writes("status = ")
retKeyword := t.IDStatus
if retExpr == nil {
b.writes("WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK)")
b.writes("NULL")
} else {
retKeyword = retExpr.Operator()
// TODO: check that retExpr has no call-suspendibles.
@@ -332,8 +332,9 @@ func (g *gen) writeStatementRet(b *buffer, n *a.Ret, depth uint32) error {
b.writes("goto ok;")
default:
g.currFunk.hasGotoOK = true
b.writes("if (status.code == 0) { goto ok; } else if (status.code > 0) { " +
"status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CANNOT_RETURN_A_SUSPENSION); } goto exit;")
b.writes("if (!status) { goto ok; }" +
"else if (wuffs_base__status__is_suspension(status)) { " +
"status = wuffs_base__error__cannot_return_a_suspension; } goto exit;")
}
return nil
}
@@ -528,7 +529,7 @@ func (g *gen) writeCallSuspendibles(b *buffer, n *a.Expr, depth uint32) error {
}
if n.Operator() != t.IDTry {
b.writes("if (status.code) { goto suspend; }\n")
b.writes("if (status) { goto suspend; }\n")
}
return nil
}
@@ -571,7 +572,7 @@ func (g *gen) writeReadUXX(b *buffer, n *a.Expr, preName string, size uint32, en
b.printf("while (true) {")
b.printf("if (WUFFS_BASE__UNLIKELY(iop_%s == io1_%s)) {"+
"status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; }",
"status = wuffs_base__suspension__short_read; goto suspend; }",
preName, preName)
b.printf("uint64_t *scratch = &%s;", scratchName)
+1 -1
View File
@@ -34,7 +34,7 @@
- Marked some internal status codes as private.
- Removed closed-for-read/write built-in status codes.
- Changed the string messages for built-in status codes.
- Made the status type a struct, not an int32\_t.
- Made the status type a `const char *`, not an `int32_t`.
- Made a packageid declaration mandatory.
- Disallowed certain packageid's like `base` or `config`.
- Disallowed `__double_underscore` prefixed names.
+2 -2
View File
@@ -58,8 +58,8 @@ uint8_t src_buffer[SRC_BUFFER_SIZE];
int main(int argc, char** argv) {
wuffs_crc32__ieee_hasher h = ((wuffs_crc32__ieee_hasher){});
wuffs_base__status z = h.check_wuffs_version(sizeof h, WUFFS_VERSION);
if (z.code) {
fprintf(stderr, "%s\n", wuffs_crc32__status__string(z.code));
if (z) {
fprintf(stderr, "%s\n", z);
return 1;
}
+12 -12
View File
@@ -273,8 +273,8 @@ const char* play() {
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_base__status z =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
return wuffs_gif__status__string(z.code);
if (z) {
return z;
}
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
@@ -285,8 +285,8 @@ const char* play() {
first_play = false;
wuffs_base__image_config ic = ((wuffs_base__image_config){});
z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (z.code) {
return wuffs_gif__status__string(z.code);
if (z) {
return z;
}
if (!wuffs_base__image_config__is_valid(&ic)) {
return "invalid image configuration";
@@ -303,8 +303,8 @@ const char* play() {
z = wuffs_base__pixel_buffer__set_from_slice(
&pb, wuffs_base__image_config__pixel_config(&ic),
((wuffs_base__slice_u8){.ptr = image_buffer, .len = image_len}));
if (z.code) {
return wuffs_gif__status__string(z.code);
if (z) {
return z;
}
memset(image_buffer, 0, image_len);
memset(dst_buffer, 0, dst_len);
@@ -315,11 +315,11 @@ const char* play() {
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
wuffs_base__status z =
wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader);
if (z.code) {
if (z.code == WUFFS_BASE__SUSPENSION_END_OF_DATA) {
if (z) {
if (z == wuffs_base__suspension__end_of_data) {
break;
}
return wuffs_gif__status__string(z.code);
return z;
}
switch (wuffs_base__frame_config__disposal(&fc)) {
@@ -331,11 +331,11 @@ const char* play() {
z = wuffs_gif__decoder__decode_frame(&dec, &pb, 0, 0, src_reader,
((wuffs_base__slice_u8){}));
if (z.code) {
if (z.code == WUFFS_BASE__SUSPENSION_END_OF_DATA) {
if (z) {
if (z == wuffs_base__suspension__end_of_data) {
break;
}
return wuffs_gif__status__string(z.code);
return z;
}
compose(&pb, wuffs_base__frame_config__bounds(&fc));
+4 -4
View File
@@ -62,12 +62,12 @@ static const char* decode() {
wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){});
wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version(
&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
return wuffs_deflate__status__string(z.code);
if (z) {
return z;
}
z = wuffs_deflate__decoder__decode(&dec, dst_writer, src_reader);
if (z.code) {
return wuffs_deflate__status__string(z.code);
if (z) {
return z;
}
ignore_return_value(write(1, dst.ptr, dst.wi));
return NULL;
+5 -8
View File
@@ -77,8 +77,8 @@ static const char* decode() {
wuffs_gzip__decoder dec = ((wuffs_gzip__decoder){});
wuffs_base__status z =
wuffs_gzip__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
return wuffs_gzip__status__string(z.code);
if (z) {
return z;
}
wuffs_base__io_buffer src =
@@ -112,16 +112,13 @@ static const char* decode() {
ignore_return_value(write(stdout_fd, dst_buffer, dst.wi));
}
if (z.code == WUFFS_BASE__STATUS_OK) {
return NULL;
}
if (z.code == WUFFS_BASE__SUSPENSION_SHORT_READ) {
if (z == wuffs_base__suspension__short_read) {
break;
}
if (z.code == WUFFS_BASE__SUSPENSION_SHORT_WRITE) {
if (z == wuffs_base__suspension__short_write) {
continue;
}
return wuffs_gzip__status__string(z.code);
return z;
}
wuffs_base__io_buffer__compact(&src);
+10 -10
View File
@@ -56,14 +56,15 @@ const char* fuzz(wuffs_base__io_reader src_reader, uint32_t hash) {
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_base__status z = wuffs_gif__decoder__check_wuffs_version(
&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
return wuffs_gif__status__string(z.code);
if (z) {
ret = z;
goto exit;
}
wuffs_base__image_config ic = ((wuffs_base__image_config){});
z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (z.code) {
ret = wuffs_gif__status__string(z.code);
if (z) {
ret = z;
goto exit;
}
if (!wuffs_base__image_config__is_valid(&ic)) {
@@ -87,8 +88,8 @@ const char* fuzz(wuffs_base__io_reader src_reader, uint32_t hash) {
z = wuffs_base__pixel_buffer__set_from_slice(
&pb, wuffs_base__image_config__pixel_config(&ic),
((wuffs_base__slice_u8){.ptr = pixbuf, .len = pixbuf_size}));
if (z.code) {
ret = wuffs_gif__status__string(z.code);
if (z) {
ret = z;
goto exit;
}
@@ -96,11 +97,10 @@ const char* fuzz(wuffs_base__io_reader src_reader, uint32_t hash) {
while (true) {
z = wuffs_gif__decoder__decode_frame(&dec, &pb, 0, 0, src_reader,
((wuffs_base__slice_u8){}));
if (z.code) {
if ((z.code == WUFFS_BASE__SUSPENSION_END_OF_DATA) && seen_ok) {
z.code = WUFFS_BASE__STATUS_OK;
if (z) {
if ((z != wuffs_base__suspension__end_of_data) || !seen_ok) {
ret = z;
}
ret = wuffs_gif__status__string(z.code);
goto exit;
}
seen_ok = true;
+4 -6
View File
@@ -47,12 +47,11 @@ It should print "PASS", amongst other information, and exit(0).
#include "../fuzzlib/fuzzlib.c"
const char* fuzz(wuffs_base__io_reader src_reader, uint32_t hash) {
const char* ret = NULL;
wuffs_zlib__decoder dec = ((wuffs_zlib__decoder){});
wuffs_base__status z =
wuffs_zlib__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
return wuffs_zlib__status__string(z.code);
if (z) {
return z;
}
// Ignore the checksum for 99.99%-ish of all input. When fuzzers generate
@@ -68,8 +67,7 @@ const char* fuzz(wuffs_base__io_reader src_reader, uint32_t hash) {
while (true) {
dst.wi = 0;
z = wuffs_zlib__decoder__decode(&dec, dst_writer, src_reader);
if (z.code != WUFFS_BASE__SUSPENSION_SHORT_WRITE) {
ret = wuffs_zlib__status__string(z.code);
if (z != wuffs_base__suspension__short_write) {
break;
}
if (dst.wi == 0) {
@@ -77,5 +75,5 @@ const char* fuzz(wuffs_base__io_reader src_reader, uint32_t hash) {
intentional_segfault();
}
}
return ret;
return z;
}
+351 -435
View File
@@ -123,19 +123,13 @@ typedef struct {
// --------
// A status code is either zero (OK), positive (a recoverable suspension or
// pause in processing) or negative (a non-recoverable error). Its bits:
// - bit 31 (the sign bit) indicates unrecoverable-ness: an error.
// - bits 30 .. 24 are a package-namespaced numeric code
// - bits 23 .. 21 are reserved.
// - bits 20 .. 0 are the packageid (a namespace) as a base38 value.
// A status is either NULL (meaning OK or no error) or string message. That
// message is human-readable, for programmers, but it is not for end users. It
// is not localized, and does not contain additional contextual information
// such as a source filename.
//
// Do not manipulate these bits directly; they are private implementation
// details. Use methods such as wuffs_base__status__is_error instead.
typedef struct {
int32_t code;
const char* msg;
} wuffs_base__status;
// Status strings are statically allocated and should never be free'd.
typedef const char* wuffs_base__status;
#define WUFFS_BASE__STATUS_OK 0 // 0x00000000
#define WUFFS_BASE__ERROR_BAD_WUFFS_VERSION -16777216 // 0xFF000000
@@ -165,29 +159,19 @@ extern const char* wuffs_base__suspension__end_of_data;
extern const char* wuffs_base__suspension__short_read;
extern const char* wuffs_base__suspension__short_write;
// TODO: turn WUFFS_BASE__MAKE_STATUS into a macro, and add a msg field.
static inline wuffs_base__status //
WUFFS_BASE__MAKE_STATUS(int32_t code) {
return ((wuffs_base__status){
.code = code,
.msg = NULL,
});
static inline bool //
wuffs_base__status__is_error(wuffs_base__status z) {
return z && (*z != '$');
}
static inline bool //
wuffs_base__status__is_error(wuffs_base__status s) {
return s.code < 0;
wuffs_base__status__is_ok(wuffs_base__status z) {
return z == NULL;
}
static inline bool //
wuffs_base__status__is_ok(wuffs_base__status s) {
return s.code == 0;
}
static inline bool //
wuffs_base__status__is_suspension(wuffs_base__status s) {
return s.code > 0;
wuffs_base__status__is_suspension(wuffs_base__status z) {
return z && (*z == '$');
}
const char* //
@@ -1935,18 +1919,17 @@ wuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b,
wuffs_base__pixel_config* pixcfg,
wuffs_base__slice_u8 pixbuf_memory) {
if (!b) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
*b = ((wuffs_base__pixel_buffer){});
if (!pixcfg) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_ARGUMENT);
return wuffs_base__error__bad_argument;
}
// TODO: don't assume 1 byte per pixel. Don't assume packed.
uint64_t wh = ((uint64_t)pixcfg->private_impl.width) *
((uint64_t)pixcfg->private_impl.height);
if (wh > pixbuf_memory.len) {
return WUFFS_BASE__MAKE_STATUS(
WUFFS_BASE__ERROR_BAD_ARGUMENT_LENGTH_TOO_SHORT);
return wuffs_base__error__bad_argument_length_too_short;
}
b->private_impl.pixcfg = *pixcfg;
wuffs_base__table_u8* tab = &b->private_impl.planes[0];
@@ -1954,7 +1937,7 @@ wuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b,
tab->width = pixcfg->private_impl.width;
tab->height = pixcfg->private_impl.height;
tab->stride = pixcfg->private_impl.width;
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
return NULL;
}
// The palette argument is ignored unless its length is exactly 1024.
@@ -3101,10 +3084,10 @@ static inline void wuffs_base__ignore_check_wuffs_version_status(
case n:;
#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \
if (status.code < 0) { \
goto exit; \
} else if (status.code == 0) { \
if (!status) { \
goto ok; \
} else if (*status != '$') { \
goto exit; \
} \
coro_susp_point = n; \
goto suspend; \
@@ -3937,21 +3920,20 @@ wuffs_adler32__hasher__check_wuffs_version(wuffs_adler32__hasher* self,
size_t sizeof_star_self,
uint64_t wuffs_version) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (sizeof(*self) != sizeof_star_self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER);
return wuffs_base__error__bad_sizeof_receiver;
}
if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) ||
(((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION);
return wuffs_base__error__bad_wuffs_version;
}
if (self->private_impl.magic != 0) {
return WUFFS_BASE__MAKE_STATUS(
WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE);
return wuffs_base__error__check_wuffs_version_called_twice;
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
return NULL;
}
// ---------------- Function Implementations
@@ -3965,10 +3947,9 @@ wuffs_adler32__hasher__update(wuffs_adler32__hasher* self,
return 0;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return 0;
}
@@ -4469,21 +4450,20 @@ wuffs_crc32__ieee_hasher__check_wuffs_version(wuffs_crc32__ieee_hasher* self,
size_t sizeof_star_self,
uint64_t wuffs_version) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (sizeof(*self) != sizeof_star_self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER);
return wuffs_base__error__bad_sizeof_receiver;
}
if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) ||
(((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION);
return wuffs_base__error__bad_wuffs_version;
}
if (self->private_impl.magic != 0) {
return WUFFS_BASE__MAKE_STATUS(
WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE);
return wuffs_base__error__check_wuffs_version_called_twice;
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
return NULL;
}
// ---------------- Function Implementations
@@ -4497,10 +4477,9 @@ wuffs_crc32__ieee_hasher__update(wuffs_crc32__ieee_hasher* self,
return 0;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return 0;
}
@@ -4882,21 +4861,20 @@ wuffs_deflate__decoder__check_wuffs_version(wuffs_deflate__decoder* self,
size_t sizeof_star_self,
uint64_t wuffs_version) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (sizeof(*self) != sizeof_star_self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER);
return wuffs_base__error__bad_sizeof_receiver;
}
if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) ||
(((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION);
return wuffs_base__error__bad_wuffs_version;
}
if (self->private_impl.magic != 0) {
return WUFFS_BASE__MAKE_STATUS(
WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE);
return wuffs_base__error__check_wuffs_version_called_twice;
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
return NULL;
}
// ---------------- Function Implementations
@@ -4908,16 +4886,15 @@ wuffs_deflate__decoder__decode(wuffs_deflate__decoder* self,
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return self->private_impl.status;
}
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
wuffs_base__status v_z;
wuffs_base__slice_u8 v_written;
@@ -4970,11 +4947,10 @@ wuffs_deflate__decoder__decode(wuffs_deflate__decoder* self,
}
if (!wuffs_base__status__is_suspension(v_z)) {
status = v_z;
if (status.code == 0) {
if (!status) {
goto ok;
} else if (status.code > 0) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_BASE__ERROR_CANNOT_RETURN_A_SUSPENSION);
} else if (wuffs_base__status__is_suspension(status)) {
status = wuffs_base__error__cannot_return_a_suspension;
}
goto exit;
}
@@ -5047,7 +5023,7 @@ static wuffs_base__status //
wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self,
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint32_t v_final;
uint32_t v_type;
@@ -5085,7 +5061,7 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
@@ -5108,14 +5084,14 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
goto label_0_continue;
} else if (v_type == 1) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_deflate__decoder__init_fixed_huffman(self);
if (status.code) {
if (status) {
goto suspend;
}
} else if (v_type == 2) {
@@ -5127,11 +5103,11 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
} else {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_BLOCK);
status = wuffs_deflate__error__bad_block;
goto exit;
}
self->private_impl.f_end_of_block = false;
@@ -5143,7 +5119,7 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
if (self->private_impl.f_end_of_block) {
@@ -5157,14 +5133,14 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
if (self->private_impl.f_end_of_block) {
goto label_0_continue;
}
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_END_OF_BLOCK);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_end_of_block;
goto exit;
}
@@ -5195,7 +5171,7 @@ static wuffs_base__status //
wuffs_deflate__decoder__decode_uncompressed(wuffs_deflate__decoder* self,
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint32_t v_length;
uint32_t v_n_copied;
@@ -5246,8 +5222,7 @@ wuffs_deflate__decoder__decode_uncompressed(wuffs_deflate__decoder* self,
if ((self->private_impl.f_n_bits >= 8) ||
((self->private_impl.f_bits >> self->private_impl.f_n_bits) != 0)) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS);
status = wuffs_deflate__error__internal_error_inconsistent_n_bits;
goto exit;
}
self->private_impl.f_n_bits = 0;
@@ -5263,7 +5238,7 @@ wuffs_deflate__decoder__decode_uncompressed(wuffs_deflate__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch =
@@ -5284,8 +5259,7 @@ wuffs_deflate__decoder__decode_uncompressed(wuffs_deflate__decoder* self,
}
if ((((v_length) & ((1 << (16)) - 1)) + ((v_length) >> (32 - (16)))) !=
65535) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INCONSISTENT_STORED_BLOCK_LENGTH);
status = wuffs_deflate__error__inconsistent_stored_block_length;
goto exit;
}
v_length = ((v_length) & ((1 << (16)) - 1));
@@ -5293,15 +5267,15 @@ wuffs_deflate__decoder__decode_uncompressed(wuffs_deflate__decoder* self,
v_n_copied = wuffs_base__io_writer__copy_n_from_reader(
&iop_a_dst, io1_a_dst, v_length, &iop_a_src, io1_a_src);
if (v_length <= v_n_copied) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
status = NULL;
goto ok;
}
v_length -= v_n_copied;
if (((uint64_t)(io1_a_dst - iop_a_dst)) == 0) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE);
status = wuffs_base__suspension__short_write;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3);
} else {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(4);
}
}
@@ -5334,7 +5308,7 @@ exit:
static wuffs_base__status //
wuffs_deflate__decoder__init_fixed_huffman(wuffs_deflate__decoder* self) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint32_t v_i;
@@ -5370,12 +5344,12 @@ wuffs_deflate__decoder__init_fixed_huffman(wuffs_deflate__decoder* self) {
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_deflate__decoder__init_huff(self, 0, 0, 288, 257);
if (status.code) {
if (status) {
goto suspend;
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
status = wuffs_deflate__decoder__init_huff(self, 1, 288, 320, 0);
if (status.code) {
if (status) {
goto suspend;
}
@@ -5400,7 +5374,7 @@ exit:
static wuffs_base__status //
wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint32_t v_bits;
uint32_t v_n_bits;
@@ -5459,7 +5433,7 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
@@ -5469,15 +5443,13 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
}
v_n_lit = (((v_bits) & ((1 << (5)) - 1)) + 257);
if (v_n_lit > 286) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_BAD_LITERAL_LENGTH_CODE_COUNT);
status = wuffs_deflate__error__bad_literal_length_code_count;
goto exit;
}
v_bits >>= 5;
v_n_dist = (((v_bits) & ((1 << (5)) - 1)) + 1);
if (v_n_dist > 30) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_DISTANCE_CODE_COUNT);
status = wuffs_deflate__error__bad_distance_code_count;
goto exit;
}
v_bits >>= 5;
@@ -5490,7 +5462,7 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_1 = *iop_a_src++;
@@ -5510,7 +5482,7 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_deflate__decoder__init_huff(self, 0, 0, 19, 4095);
if (status.code) {
if (status) {
goto suspend;
}
v_mask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
@@ -5529,7 +5501,7 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_2 = *iop_a_src++;
@@ -5539,8 +5511,8 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
}
label_1_break:;
if ((v_table_entry >> 24) != 128) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_table_entry = ((v_table_entry >> 8) & 255);
@@ -5555,8 +5527,7 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
if (v_table_entry == 16) {
v_n_extra_bits = 2;
if (v_i <= 0) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_REPETITION);
status = wuffs_deflate__error__bad_huffman_code_length_repetition;
goto exit;
}
v_rep_symbol = self->private_impl.f_code_lengths[(v_i - 1)];
@@ -5570,15 +5541,15 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
v_rep_symbol = 0;
v_rep_count = 11;
} else {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
while (v_n_bits < v_n_extra_bits) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_3 = *iop_a_src++;
@@ -5591,8 +5562,7 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
v_n_bits -= v_n_extra_bits;
while (v_rep_count > 0) {
if (v_i >= (v_n_lit + v_n_dist)) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_COUNT);
status = wuffs_deflate__error__bad_huffman_code_length_count;
goto exit;
}
self->private_impl.f_code_lengths[v_i] = v_rep_symbol;
@@ -5601,24 +5571,22 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
}
}
if (v_i != (v_n_lit + v_n_dist)) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_COUNT);
status = wuffs_deflate__error__bad_huffman_code_length_count;
goto exit;
}
if (self->private_impl.f_code_lengths[256] == 0) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_MISSING_END_OF_BLOCK_CODE);
status = wuffs_deflate__error__missing_end_of_block_code;
goto exit;
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
status = wuffs_deflate__decoder__init_huff(self, 0, 0, v_n_lit, 257);
if (status.code) {
if (status) {
goto suspend;
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
status = wuffs_deflate__decoder__init_huff(self, 1, v_n_lit,
(v_n_lit + v_n_dist), 0);
if (status.code) {
if (status) {
goto suspend;
}
self->private_impl.f_bits = v_bits;
@@ -5665,7 +5633,7 @@ wuffs_deflate__decoder__init_huff(wuffs_deflate__decoder* self,
uint32_t a_n_codes0,
uint32_t a_n_codes1,
uint32_t a_base_symbol) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint16_t v_counts[16];
uint32_t v_i;
@@ -5697,37 +5665,35 @@ wuffs_deflate__decoder__init_huff(wuffs_deflate__decoder* self,
v_i = a_n_codes0;
while (v_i < a_n_codes1) {
if (v_counts[self->private_impl.f_code_lengths[v_i]] >= 320) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_counts[self->private_impl.f_code_lengths[v_i]] += 1;
v_i += 1;
}
if ((((uint32_t)(v_counts[0])) + a_n_codes0) == a_n_codes1) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_NO_HUFFMAN_CODES);
status = wuffs_deflate__error__no_huffman_codes;
goto exit;
}
v_remaining = 1;
v_i = 1;
while (v_i <= 15) {
if (v_remaining > 1073741824) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_remaining <<= 1;
if (v_remaining < ((uint32_t)(v_counts[v_i]))) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_OVER_SUBSCRIBED);
status = wuffs_deflate__error__bad_huffman_code_over_subscribed;
goto exit;
}
v_remaining -= ((uint32_t)(v_counts[v_i]));
v_i += 1;
}
if (v_remaining != 0) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_UNDER_SUBSCRIBED);
status = wuffs_deflate__error__bad_huffman_code_under_subscribed;
goto exit;
}
memset(v_offsets, 0, sizeof(v_offsets));
@@ -5737,30 +5703,30 @@ wuffs_deflate__decoder__init_huff(wuffs_deflate__decoder* self,
v_offsets[v_i] = ((uint16_t)(v_n_symbols));
v_count = ((uint32_t)(v_counts[v_i]));
if (v_n_symbols > (320 - v_count)) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_n_symbols = (v_n_symbols + v_count);
v_i += 1;
}
if (v_n_symbols > 288) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
memset(v_symbols, 0, sizeof(v_symbols));
v_i = a_n_codes0;
while (v_i < a_n_codes1) {
if (v_i < a_n_codes0) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
if (self->private_impl.f_code_lengths[v_i] != 0) {
if (v_offsets[self->private_impl.f_code_lengths[v_i]] >= 320) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_symbols[v_offsets[self->private_impl.f_code_lengths[v_i]]] =
@@ -5775,8 +5741,7 @@ wuffs_deflate__decoder__init_huff(wuffs_deflate__decoder* self,
goto label_0_break;
}
if (v_min_cl >= 9) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_MINIMUM_CODE_LENGTH);
status = wuffs_deflate__error__bad_huffman_minimum_code_length;
goto exit;
}
v_min_cl += 1;
@@ -5788,7 +5753,7 @@ label_0_break:;
goto label_1_break;
}
if (v_max_cl <= 1) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_NO_HUFFMAN_CODES);
status = wuffs_deflate__error__no_huffman_codes;
goto exit;
}
v_max_cl -= 1;
@@ -5802,13 +5767,13 @@ label_1_break:;
v_i = 0;
if ((v_n_symbols != ((uint32_t)(v_offsets[v_max_cl]))) ||
(v_n_symbols != ((uint32_t)(v_offsets[15])))) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
if ((a_n_codes0 + ((uint32_t)(v_symbols[0]))) >= 320) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_initial_high_bits = 512;
@@ -5825,8 +5790,8 @@ label_1_break:;
v_value = 0;
while (true) {
if ((a_n_codes0 + ((uint32_t)(v_symbols[v_i]))) >= 320) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_cl = ((uint32_t)(self->private_impl.f_code_lengths[(
@@ -5834,8 +5799,8 @@ label_1_break:;
if (v_cl > v_prev_cl) {
v_code <<= (v_cl - v_prev_cl);
if (v_code >= 32768) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
}
@@ -5856,8 +5821,8 @@ label_1_break:;
}
v_remaining -= ((uint32_t)(v_counts[v_j]));
if (v_remaining > 1073741824) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_remaining <<= 1;
@@ -5865,16 +5830,16 @@ label_1_break:;
}
label_2_break:;
if ((v_j <= 9) || (15 < v_j)) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_tmp = (v_j - 9);
v_initial_high_bits = (((uint32_t)(1)) << v_tmp);
v_top = v_next_top;
if ((v_top + (((uint32_t)(1)) << v_tmp)) > 1234) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_next_top = (v_top + (((uint32_t)(1)) << v_tmp));
@@ -5886,8 +5851,8 @@ label_1_break:;
}
}
if ((v_key >= 512) || (v_counts[v_prev_cl] <= 0)) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_counts[v_prev_cl] -= 1;
@@ -5907,8 +5872,8 @@ label_1_break:;
v_value = (wuffs_deflate__dcode_magic_numbers[(v_symbol & 31)] | v_cl);
}
} else {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_high_bits = v_initial_high_bits;
@@ -5916,8 +5881,8 @@ label_1_break:;
while (v_high_bits >= v_delta) {
v_high_bits -= v_delta;
if ((v_top + ((v_high_bits | v_reversed_key) & 511)) >= 1234) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
self->private_impl
@@ -5930,8 +5895,8 @@ label_1_break:;
}
v_code += 1;
if (v_code >= 32768) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
}
@@ -5947,7 +5912,7 @@ static wuffs_base__status //
wuffs_deflate__decoder__decode_huffman_fast(wuffs_deflate__decoder* self,
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint32_t v_bits;
uint32_t v_n_bits;
@@ -5999,8 +5964,7 @@ wuffs_deflate__decoder__decode_huffman_fast(wuffs_deflate__decoder* self,
if ((self->private_impl.f_n_bits >= 8) ||
((self->private_impl.f_bits >> self->private_impl.f_n_bits) != 0)) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS);
status = wuffs_deflate__error__internal_error_inconsistent_n_bits;
goto exit;
}
v_bits = self->private_impl.f_bits;
@@ -6047,8 +6011,8 @@ label_0_continue:;
v_redir_top = ((v_table_entry >> 8) & 65535);
v_redir_mask = ((((uint32_t)(1)) << ((v_table_entry >> 4) & 15)) - 1);
if ((v_redir_top + (v_bits & v_redir_mask)) >= 1234) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_table_entry = self->private_impl
@@ -6066,23 +6030,23 @@ label_0_continue:;
self->private_impl.f_end_of_block = true;
goto label_0_break;
} else if ((v_table_entry >> 28) != 0) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
} else if ((v_table_entry >> 27) != 0) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE);
status = wuffs_deflate__error__bad_huffman_code;
goto exit;
} else {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
} else if ((v_table_entry >> 27) != 0) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE);
status = wuffs_deflate__error__bad_huffman_code;
goto exit;
} else {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_length = ((v_table_entry >> 8) & 32767);
@@ -6105,8 +6069,8 @@ label_0_continue:;
} else {
}
if (v_length > 258) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
if (v_n_bits < 15) {
@@ -6135,8 +6099,8 @@ label_0_continue:;
v_redir_top = ((v_table_entry >> 8) & 65535);
v_redir_mask = ((((uint32_t)(1)) << ((v_table_entry >> 4) & 15)) - 1);
if ((v_redir_top + (v_bits & v_redir_mask)) >= 1234) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_table_entry = self->private_impl
@@ -6148,11 +6112,11 @@ label_0_continue:;
}
if ((v_table_entry >> 24) != 64) {
if ((v_table_entry >> 24) == 8) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE);
status = wuffs_deflate__error__bad_huffman_code;
goto exit;
}
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_dist_minus_1 = ((v_table_entry >> 8) & 32767);
@@ -6194,8 +6158,8 @@ label_0_continue:;
v_length -= v_hdist;
v_hlen = v_hdist;
if (v_length > 258) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
} else {
@@ -6203,7 +6167,7 @@ label_0_continue:;
v_length = 0;
}
if (self->private_impl.f_history_index < v_hdist) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_DISTANCE);
status = wuffs_deflate__error__bad_distance;
goto exit;
}
v_hdist = (self->private_impl.f_history_index - v_hdist);
@@ -6235,8 +6199,7 @@ label_0_continue:;
.len = (size_t)(iop_a_dst - a_dst.private_impl.bounds[0]),
})
.len))) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_DISTANCE);
status = wuffs_deflate__error__internal_error_inconsistent_distance;
goto exit;
}
}
@@ -6253,8 +6216,7 @@ label_0_break:;
if (iop_a_src > io0_a_src) {
(iop_a_src--, wuffs_base__return_empty_struct());
} else {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_I_O);
status = wuffs_deflate__error__internal_error_inconsistent_i_o;
goto exit;
}
}
@@ -6262,8 +6224,7 @@ label_0_break:;
self->private_impl.f_n_bits = v_n_bits;
if ((self->private_impl.f_n_bits >= 8) ||
((self->private_impl.f_bits >> self->private_impl.f_n_bits) != 0)) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS);
status = wuffs_deflate__error__internal_error_inconsistent_n_bits;
goto exit;
}
goto exit;
@@ -6284,7 +6245,7 @@ static wuffs_base__status //
wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint32_t v_bits;
uint32_t v_n_bits;
@@ -6358,8 +6319,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
if ((self->private_impl.f_n_bits >= 8) ||
((self->private_impl.f_bits >> self->private_impl.f_n_bits) != 0)) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS);
status = wuffs_deflate__error__internal_error_inconsistent_n_bits;
goto exit;
}
v_bits = self->private_impl.f_bits;
@@ -6381,7 +6341,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
@@ -6393,7 +6353,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
if ((v_table_entry >> 31) != 0) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
if (iop_a_dst == io1_a_dst) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE);
status = wuffs_base__suspension__short_write;
goto suspend;
}
*iop_a_dst++ = ((uint8_t)(((v_table_entry >> 8) & 255)));
@@ -6407,8 +6367,8 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
v_redir_mask = ((((uint32_t)(1)) << ((v_table_entry >> 4) & 15)) - 1);
while (true) {
if ((v_redir_top + (v_bits & v_redir_mask)) >= 1234) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_table_entry =
@@ -6423,8 +6383,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_1 = *iop_a_src++;
@@ -6436,8 +6395,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
if ((v_table_entry >> 31) != 0) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
if (iop_a_dst == io1_a_dst) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE);
status = wuffs_base__suspension__short_write;
goto suspend;
}
*iop_a_dst++ = ((uint8_t)(((v_table_entry >> 8) & 255)));
@@ -6447,24 +6405,23 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
self->private_impl.f_end_of_block = true;
goto label_0_break;
} else if ((v_table_entry >> 28) != 0) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
} else if ((v_table_entry >> 27) != 0) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE);
status = wuffs_deflate__error__bad_huffman_code;
goto exit;
} else {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
} else if ((v_table_entry >> 27) != 0) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE);
status = wuffs_deflate__error__bad_huffman_code;
goto exit;
} else {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_length = ((v_table_entry >> 8) & 32767);
@@ -6474,8 +6431,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_2 = *iop_a_src++;
@@ -6500,7 +6456,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_3 = *iop_a_src++;
@@ -6514,8 +6470,8 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
v_redir_mask = ((((uint32_t)(1)) << ((v_table_entry >> 4) & 15)) - 1);
while (true) {
if ((v_redir_top + (v_bits & v_redir_mask)) >= 1234) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_table_entry =
@@ -6530,8 +6486,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_4 = *iop_a_src++;
@@ -6543,12 +6498,11 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
}
if ((v_table_entry >> 24) != 64) {
if ((v_table_entry >> 24) == 8) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE);
status = wuffs_deflate__error__bad_huffman_code;
goto exit;
}
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE);
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto exit;
}
v_dist_minus_1 = ((v_table_entry >> 8) & 32767);
@@ -6558,8 +6512,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_5 = *iop_a_src++;
@@ -6599,7 +6552,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
v_length = 0;
}
if (self->private_impl.f_history_index < v_hdist) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_DISTANCE);
status = wuffs_deflate__error__bad_distance;
goto exit;
}
v_hdist = (self->private_impl.f_history_index - v_hdist);
@@ -6621,8 +6574,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
goto label_5_break;
}
}
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE);
status = wuffs_base__suspension__short_write;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9);
}
label_5_break:;
@@ -6640,8 +6592,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
}
v_hlen -= v_n_copied;
v_hdist += v_n_copied;
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE);
status = wuffs_base__suspension__short_write;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(10);
}
label_6_break:;
@@ -6658,7 +6609,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
goto label_7_break;
}
v_length -= v_n_copied;
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE);
status = wuffs_base__suspension__short_write;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(11);
}
label_7_break:;
@@ -6668,8 +6619,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
self->private_impl.f_n_bits = v_n_bits;
if ((self->private_impl.f_n_bits >= 8) ||
((self->private_impl.f_bits >> self->private_impl.f_n_bits) != 0)) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS);
status = wuffs_deflate__error__internal_error_inconsistent_n_bits;
goto exit;
}
@@ -6871,29 +6821,28 @@ wuffs_gif__decoder__check_wuffs_version(wuffs_gif__decoder* self,
size_t sizeof_star_self,
uint64_t wuffs_version) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (sizeof(*self) != sizeof_star_self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER);
return wuffs_base__error__bad_sizeof_receiver;
}
if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) ||
(((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION);
return wuffs_base__error__bad_wuffs_version;
}
if (self->private_impl.magic != 0) {
return WUFFS_BASE__MAKE_STATUS(
WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE);
return wuffs_base__error__check_wuffs_version_called_twice;
}
{
wuffs_base__status z = wuffs_lzw__decoder__check_wuffs_version(
&self->private_impl.f_lzw, sizeof(self->private_impl.f_lzw),
WUFFS_VERSION);
if (z.code) {
if (z) {
return z;
}
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
return NULL;
}
// ---------------- Function Implementations
@@ -6905,16 +6854,15 @@ wuffs_gif__decoder__decode_image_config(wuffs_gif__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__io_reader a_src) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return self->private_impl.status;
}
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint32_t v_num_loops;
bool v_ffio;
@@ -6931,22 +6879,22 @@ wuffs_gif__decoder__decode_image_config(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence >= 1) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_INVALID_CALL_SEQUENCE);
status = wuffs_base__error__invalid_call_sequence;
goto exit;
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_gif__decoder__decode_header(self, a_src);
if (status.code) {
if (status) {
goto suspend;
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
status = wuffs_gif__decoder__decode_lsd(self, a_src);
if (status.code) {
if (status) {
goto suspend;
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_gif__decoder__decode_up_to_id_part1(self, a_src);
if (status.code) {
if (status) {
goto suspend;
}
v_num_loops = 1;
@@ -6993,10 +6941,9 @@ wuffs_gif__decoder__num_decoded_frame_configs(wuffs_gif__decoder* self) {
return 0;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return 0;
}
@@ -7011,10 +6958,9 @@ wuffs_gif__decoder__num_decoded_frames(wuffs_gif__decoder* self) {
return 0;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return 0;
}
@@ -7029,10 +6975,9 @@ wuffs_gif__decoder__work_buffer_size(wuffs_gif__decoder* self) {
return ((wuffs_base__range_ii_u64){});
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return ((wuffs_base__range_ii_u64){});
}
@@ -7047,16 +6992,15 @@ wuffs_gif__decoder__decode_frame_config(wuffs_gif__decoder* self,
wuffs_base__frame_config* a_dst,
wuffs_base__io_reader a_src) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return self->private_impl.status;
}
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint32_t coro_susp_point =
self->private_impl.c_decode_frame_config[0].coro_susp_point;
@@ -7070,27 +7014,27 @@ wuffs_gif__decoder__decode_frame_config(wuffs_gif__decoder* self,
if (self->private_impl.f_call_sequence == 0) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_gif__decoder__decode_image_config(self, NULL, a_src);
if (status.code) {
if (status) {
goto suspend;
}
} else if (self->private_impl.f_call_sequence != 1) {
if (self->private_impl.f_call_sequence == 2) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
status = wuffs_gif__decoder__skip_frame(self, a_src);
if (status.code) {
if (status) {
goto suspend;
}
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_gif__decoder__decode_up_to_id_part1(self, a_src);
if (status.code) {
if (status) {
goto suspend;
}
}
}
if (self->private_impl.f_end_of_data) {
while (true) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_END_OF_DATA);
status = wuffs_base__suspension__end_of_data;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(4);
}
}
@@ -7142,7 +7086,7 @@ exit:
static wuffs_base__status //
wuffs_gif__decoder__skip_frame(wuffs_gif__decoder* self,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_lw;
@@ -7173,7 +7117,7 @@ wuffs_gif__decoder__skip_frame(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
@@ -7187,7 +7131,7 @@ wuffs_gif__decoder__skip_frame(wuffs_gif__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
self->private_impl.f_seen_graphic_control = false;
@@ -7229,21 +7173,19 @@ wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self,
wuffs_base__io_reader a_src,
wuffs_base__slice_u8 a_work_buffer) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return self->private_impl.status;
}
if (!a_dst) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_ARGUMENT);
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_ARGUMENT);
self->private_impl.status = wuffs_base__error__bad_argument;
return wuffs_base__error__bad_argument;
}
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint32_t coro_susp_point =
self->private_impl.c_decode_frame[0].coro_susp_point;
@@ -7256,13 +7198,13 @@ wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self,
if (self->private_impl.f_call_sequence != 2) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_gif__decoder__decode_frame_config(self, NULL, a_src);
if (status.code) {
if (status) {
goto suspend;
}
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
status = wuffs_gif__decoder__decode_id_part1(self, a_dst, a_src);
if (status.code) {
if (status) {
goto suspend;
}
self->private_impl.f_seen_graphic_control = false;
@@ -7295,7 +7237,7 @@ exit:
static wuffs_base__status //
wuffs_gif__decoder__decode_up_to_id_part1(wuffs_gif__decoder* self,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_block_type;
@@ -7328,7 +7270,7 @@ wuffs_gif__decoder__decode_up_to_id_part1(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
@@ -7343,7 +7285,7 @@ wuffs_gif__decoder__decode_up_to_id_part1(wuffs_gif__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
} else if (v_block_type == 44) {
@@ -7355,7 +7297,7 @@ wuffs_gif__decoder__decode_up_to_id_part1(wuffs_gif__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
goto label_0_break;
@@ -7363,7 +7305,7 @@ wuffs_gif__decoder__decode_up_to_id_part1(wuffs_gif__decoder* self,
self->private_impl.f_end_of_data = true;
goto label_0_break;
} else {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GIF__ERROR_BAD_BLOCK);
status = wuffs_gif__error__bad_block;
goto exit;
}
}
@@ -7395,7 +7337,7 @@ exit:
static wuffs_base__status //
wuffs_gif__decoder__decode_header(wuffs_gif__decoder* self,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_c[6];
uint32_t v_i;
@@ -7432,7 +7374,7 @@ wuffs_gif__decoder__decode_header(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
@@ -7442,7 +7384,7 @@ wuffs_gif__decoder__decode_header(wuffs_gif__decoder* self,
}
if ((v_c[0] != 71) || (v_c[1] != 73) || (v_c[2] != 70) || (v_c[3] != 56) ||
((v_c[4] != 55) && (v_c[4] != 57)) || (v_c[5] != 97)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GIF__ERROR_BAD_HEADER);
status = wuffs_gif__error__bad_header;
goto exit;
}
@@ -7472,7 +7414,7 @@ exit:
static wuffs_base__status //
wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_flags;
uint32_t v_num_palette_entries;
@@ -7518,7 +7460,7 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode_lsd[0].scratch;
@@ -7547,7 +7489,7 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode_lsd[0].scratch;
@@ -7568,7 +7510,7 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_4 = *iop_a_src++;
@@ -7581,7 +7523,7 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self,
((uint64_t)(io1_a_src - iop_a_src))) {
self->private_impl.c_decode_lsd[0].scratch -= io1_a_src - iop_a_src;
iop_a_src = io1_a_src;
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
iop_a_src += self->private_impl.c_decode_lsd[0].scratch;
@@ -7600,8 +7542,7 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode_lsd[0].scratch;
@@ -7668,7 +7609,7 @@ exit:
static wuffs_base__status //
wuffs_gif__decoder__decode_extension(wuffs_gif__decoder* self,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_label;
@@ -7700,7 +7641,7 @@ wuffs_gif__decoder__decode_extension(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
@@ -7715,10 +7656,10 @@ wuffs_gif__decoder__decode_extension(wuffs_gif__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
status = NULL;
goto ok;
} else if (v_label == 255) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
@@ -7729,10 +7670,10 @@ wuffs_gif__decoder__decode_extension(wuffs_gif__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
status = NULL;
goto ok;
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
@@ -7743,7 +7684,7 @@ wuffs_gif__decoder__decode_extension(wuffs_gif__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
@@ -7772,7 +7713,7 @@ exit:
static wuffs_base__status //
wuffs_gif__decoder__skip_blocks(wuffs_gif__decoder* self,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_block_size;
@@ -7805,14 +7746,14 @@ wuffs_gif__decoder__skip_blocks(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
v_block_size = t_0;
}
if (v_block_size == 0) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
status = NULL;
goto ok;
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
@@ -7822,7 +7763,7 @@ wuffs_gif__decoder__skip_blocks(wuffs_gif__decoder* self,
((uint64_t)(io1_a_src - iop_a_src))) {
self->private_impl.c_skip_blocks[0].scratch -= io1_a_src - iop_a_src;
iop_a_src = io1_a_src;
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
iop_a_src += self->private_impl.c_skip_blocks[0].scratch;
@@ -7853,7 +7794,7 @@ exit:
static wuffs_base__status //
wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_c;
uint8_t v_block_size;
@@ -7894,14 +7835,14 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
v_block_size = t_0;
}
if (v_block_size == 0) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
status = NULL;
goto ok;
}
if (v_block_size != 11) {
@@ -7912,7 +7853,7 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self,
((uint64_t)(io1_a_src - iop_a_src))) {
self->private_impl.c_decode_ae[0].scratch -= io1_a_src - iop_a_src;
iop_a_src = io1_a_src;
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
iop_a_src += self->private_impl.c_decode_ae[0].scratch;
@@ -7925,7 +7866,7 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_1 = *iop_a_src++;
@@ -7943,7 +7884,7 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_2 = *iop_a_src++;
@@ -7957,7 +7898,7 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self,
((uint64_t)(io1_a_src - iop_a_src))) {
self->private_impl.c_decode_ae[0].scratch -= io1_a_src - iop_a_src;
iop_a_src = io1_a_src;
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
iop_a_src += self->private_impl.c_decode_ae[0].scratch;
@@ -7966,7 +7907,7 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_3 = *iop_a_src++;
@@ -7980,7 +7921,7 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self,
((uint64_t)(io1_a_src - iop_a_src))) {
self->private_impl.c_decode_ae[0].scratch -= io1_a_src - iop_a_src;
iop_a_src = io1_a_src;
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
iop_a_src += self->private_impl.c_decode_ae[0].scratch;
@@ -7997,8 +7938,7 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode_ae[0].scratch;
@@ -8032,7 +7972,7 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self,
if (a_src.private_impl.buf) {
iop_a_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
}
if (status.code) {
if (status) {
goto suspend;
}
@@ -8064,7 +8004,7 @@ exit:
static wuffs_base__status //
wuffs_gif__decoder__decode_gc(wuffs_gif__decoder* self,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_c;
uint8_t v_flags;
@@ -8095,26 +8035,26 @@ wuffs_gif__decoder__decode_gc(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_seen_graphic_control) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GIF__ERROR_BAD_GRAPHIC_CONTROL);
status = wuffs_gif__error__bad_graphic_control;
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
v_c = t_0;
}
if (v_c != 4) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GIF__ERROR_BAD_GRAPHIC_CONTROL);
status = wuffs_gif__error__bad_graphic_control;
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_1 = *iop_a_src++;
@@ -8140,7 +8080,7 @@ wuffs_gif__decoder__decode_gc(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode_gc[0].scratch;
@@ -8161,7 +8101,7 @@ wuffs_gif__decoder__decode_gc(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_4 = *iop_a_src++;
@@ -8170,14 +8110,14 @@ wuffs_gif__decoder__decode_gc(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_5 = *iop_a_src++;
v_c = t_5;
}
if (v_c != 0) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GIF__ERROR_BAD_GRAPHIC_CONTROL);
status = wuffs_gif__error__bad_graphic_control;
goto exit;
}
self->private_impl.f_seen_graphic_control = true;
@@ -8208,7 +8148,7 @@ exit:
static wuffs_base__status //
wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_flags;
uint32_t v_num_palette_entries;
@@ -8255,7 +8195,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode_id_part0[0].scratch;
@@ -8284,7 +8224,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode_id_part0[0].scratch;
@@ -8313,7 +8253,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode_id_part0[0].scratch;
@@ -8343,7 +8283,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode_id_part0[0].scratch;
@@ -8373,7 +8313,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_8 = *iop_a_src++;
@@ -8402,8 +8342,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch =
@@ -8472,7 +8411,7 @@ static wuffs_base__status //
wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_reader a_src) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_lw;
uint64_t v_block_size;
@@ -8551,14 +8490,14 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
v_lw = t_0;
}
if ((v_lw < 2) || (8 < v_lw)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GIF__ERROR_BAD_LITERAL_WIDTH);
status = wuffs_gif__error__bad_literal_width;
goto exit;
}
wuffs_lzw__decoder__set_literal_width(&self->private_impl.f_lzw,
@@ -8568,7 +8507,7 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_1 = *iop_a_src++;
@@ -8626,25 +8565,20 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
a_src = o_0_a_src;
}
if (wuffs_base__status__is_ok(v_z) ||
(v_z.code ==
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE)
.code)) {
(v_z == wuffs_base__suspension__short_write)) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_gif__decoder__copy_to_image_buffer(self, a_dst);
if (status.code) {
if (status) {
goto suspend;
}
if (v_z.code ==
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE)
.code) {
if (v_z == wuffs_base__suspension__short_write) {
goto label_1_continue;
}
self->private_impl.f_previous_lzw_decode_ended_abruptly = false;
goto label_1_break;
}
if ((v_block_size == 0) &&
(v_z.code ==
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ).code)) {
(v_z == wuffs_base__suspension__short_read)) {
goto label_1_break;
}
status = v_z;
@@ -8657,7 +8591,7 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
self->private_impl.f_uncompressed_wi) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
status = wuffs_gif__decoder__copy_to_image_buffer(self, a_dst);
if (status.code) {
if (status) {
goto suspend;
}
}
@@ -8689,7 +8623,7 @@ exit:
static wuffs_base__status //
wuffs_gif__decoder__copy_to_image_buffer(wuffs_gif__decoder* self,
wuffs_base__pixel_buffer* a_pb) {
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
wuffs_base__slice_u8 v_dst;
wuffs_base__slice_u8 v_src;
@@ -8711,7 +8645,7 @@ label_0_continue:;
self->private_impl.f_uncompressed_ri,
self->private_impl.f_uncompressed_wi);
if (self->private_impl.f_dst_y >= self->private_impl.f_frame_rect_y1) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GIF__ERROR_TOO_MUCH_PIXEL_DATA);
status = wuffs_gif__error__too_much_pixel_data;
goto exit;
}
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
@@ -8756,8 +8690,7 @@ label_0_continue:;
goto label_0_break;
} else if (self->private_impl.f_uncompressed_wi <
self->private_impl.f_uncompressed_ri) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_GIF__ERROR_INTERNAL_ERROR_INCONSISTENT_RI_WI);
status = wuffs_gif__error__internal_error_inconsistent_ri_wi;
goto exit;
}
v_n = (self->private_impl.f_frame_rect_x1 - self->private_impl.f_dst_x);
@@ -8785,8 +8718,7 @@ label_0_continue:;
}
if (self->private_impl.f_uncompressed_ri !=
self->private_impl.f_uncompressed_wi) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_GIF__ERROR_INTERNAL_ERROR_INCONSISTENT_RI_WI);
status = wuffs_gif__error__internal_error_inconsistent_ri_wi;
goto exit;
}
goto label_0_break;
@@ -8886,24 +8818,23 @@ wuffs_gzip__decoder__check_wuffs_version(wuffs_gzip__decoder* self,
size_t sizeof_star_self,
uint64_t wuffs_version) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (sizeof(*self) != sizeof_star_self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER);
return wuffs_base__error__bad_sizeof_receiver;
}
if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) ||
(((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION);
return wuffs_base__error__bad_wuffs_version;
}
if (self->private_impl.magic != 0) {
return WUFFS_BASE__MAKE_STATUS(
WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE);
return wuffs_base__error__check_wuffs_version_called_twice;
}
{
wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version(
&self->private_impl.f_flate, sizeof(self->private_impl.f_flate),
WUFFS_VERSION);
if (z.code) {
if (z) {
return z;
}
}
@@ -8911,12 +8842,12 @@ wuffs_gzip__decoder__check_wuffs_version(wuffs_gzip__decoder* self,
wuffs_base__status z = wuffs_crc32__ieee_hasher__check_wuffs_version(
&self->private_impl.f_checksum, sizeof(self->private_impl.f_checksum),
WUFFS_VERSION);
if (z.code) {
if (z) {
return z;
}
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
return NULL;
}
// ---------------- Function Implementations
@@ -8929,10 +8860,9 @@ wuffs_gzip__decoder__set_ignore_checksum(wuffs_gzip__decoder* self, bool a_ic) {
return;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return;
}
@@ -8946,16 +8876,15 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return self->private_impl.status;
}
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint8_t v_c;
uint8_t v_flags;
@@ -9019,47 +8948,46 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
v_c = t_0;
}
if (v_c != 31) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GZIP__ERROR_BAD_HEADER);
status = wuffs_gzip__error__bad_header;
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_1 = *iop_a_src++;
v_c = t_1;
}
if (v_c != 139) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GZIP__ERROR_BAD_HEADER);
status = wuffs_gzip__error__bad_header;
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_2 = *iop_a_src++;
v_c = t_2;
}
if (v_c != 8) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_GZIP__ERROR_BAD_COMPRESSION_METHOD);
status = wuffs_gzip__error__bad_compression_method;
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_3 = *iop_a_src++;
@@ -9072,7 +9000,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
((uint64_t)(io1_a_src - iop_a_src))) {
self->private_impl.c_decode[0].scratch -= io1_a_src - iop_a_src;
iop_a_src = io1_a_src;
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
iop_a_src += self->private_impl.c_decode[0].scratch;
@@ -9088,8 +9016,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode[0].scratch;
@@ -9114,7 +9041,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
((uint64_t)(io1_a_src - iop_a_src))) {
self->private_impl.c_decode[0].scratch -= io1_a_src - iop_a_src;
iop_a_src = io1_a_src;
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
iop_a_src += self->private_impl.c_decode[0].scratch;
@@ -9124,7 +9051,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_6 = *iop_a_src++;
@@ -9141,7 +9068,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_7 = *iop_a_src++;
@@ -9161,13 +9088,13 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
((uint64_t)(io1_a_src - iop_a_src))) {
self->private_impl.c_decode[0].scratch -= io1_a_src - iop_a_src;
iop_a_src = io1_a_src;
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
iop_a_src += self->private_impl.c_decode[0].scratch;
}
if ((v_flags & 224) != 0) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GZIP__ERROR_BAD_ENCODING_FLAGS);
status = wuffs_gzip__error__bad_encoding_flags;
goto exit;
}
v_checksum_got = 0;
@@ -9225,7 +9152,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(17);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode[0].scratch;
@@ -9254,7 +9181,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(19);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode[0].scratch;
@@ -9275,7 +9202,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
if (!self->private_impl.f_ignore_checksum &&
((v_checksum_got != v_checksum_want) ||
(v_decoded_length_got != v_decoded_length_want))) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_GZIP__ERROR_BAD_CHECKSUM);
status = wuffs_gzip__error__bad_checksum;
goto exit;
}
@@ -9388,21 +9315,20 @@ wuffs_lzw__decoder__check_wuffs_version(wuffs_lzw__decoder* self,
size_t sizeof_star_self,
uint64_t wuffs_version) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (sizeof(*self) != sizeof_star_self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER);
return wuffs_base__error__bad_sizeof_receiver;
}
if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) ||
(((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION);
return wuffs_base__error__bad_wuffs_version;
}
if (self->private_impl.magic != 0) {
return WUFFS_BASE__MAKE_STATUS(
WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE);
return wuffs_base__error__check_wuffs_version_called_twice;
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
return NULL;
}
// ---------------- Function Implementations
@@ -9415,15 +9341,13 @@ wuffs_lzw__decoder__set_literal_width(wuffs_lzw__decoder* self, uint32_t a_lw) {
return;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return;
}
if (a_lw < 2 || a_lw > 8) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_ARGUMENT);
self->private_impl.status = wuffs_base__error__bad_argument;
return;
}
@@ -9437,16 +9361,15 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self,
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return self->private_impl.status;
}
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint32_t v_literal_width;
uint32_t v_clear_code;
@@ -9533,7 +9456,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self,
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
@@ -9547,7 +9470,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self,
if (v_code < v_clear_code) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
if (iop_a_dst == io1_a_dst) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE);
status = wuffs_base__suspension__short_write;
goto suspend;
}
*iop_a_dst++ = ((uint8_t)(v_code));
@@ -9563,7 +9486,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self,
}
} else if (v_code <= v_end_code) {
if (v_code == v_end_code) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
status = NULL;
goto ok;
}
v_save_code = v_end_code;
@@ -9579,8 +9502,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self,
while (v_c >= v_clear_code) {
self->private_impl.f_stack[v_s] = self->private_impl.f_suffixes[v_c];
if (v_s == 0) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_LZW__ERROR_CYCLICAL_PREFIX_CHAIN);
status = wuffs_lzw__error__cyclical_prefix_chain;
goto exit;
}
v_s -= 1;
@@ -9601,7 +9523,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self,
goto label_0_break;
}
v_s = ((v_s + ((uint32_t)((v_n_copied & 4095)))) & 4095);
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE);
status = wuffs_base__suspension__short_write;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3);
}
label_0_break:;
@@ -9616,7 +9538,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self,
v_prev_code = v_code;
}
} else {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_LZW__ERROR_BAD_CODE);
status = wuffs_lzw__error__bad_code;
goto exit;
}
}
@@ -9751,24 +9673,23 @@ wuffs_zlib__decoder__check_wuffs_version(wuffs_zlib__decoder* self,
size_t sizeof_star_self,
uint64_t wuffs_version) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (sizeof(*self) != sizeof_star_self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER);
return wuffs_base__error__bad_sizeof_receiver;
}
if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) ||
(((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION);
return wuffs_base__error__bad_wuffs_version;
}
if (self->private_impl.magic != 0) {
return WUFFS_BASE__MAKE_STATUS(
WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE);
return wuffs_base__error__check_wuffs_version_called_twice;
}
{
wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version(
&self->private_impl.f_flate, sizeof(self->private_impl.f_flate),
WUFFS_VERSION);
if (z.code) {
if (z) {
return z;
}
}
@@ -9776,12 +9697,12 @@ wuffs_zlib__decoder__check_wuffs_version(wuffs_zlib__decoder* self,
wuffs_base__status z = wuffs_adler32__hasher__check_wuffs_version(
&self->private_impl.f_checksum, sizeof(self->private_impl.f_checksum),
WUFFS_VERSION);
if (z.code) {
if (z) {
return z;
}
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
return NULL;
}
// ---------------- Function Implementations
@@ -9794,10 +9715,9 @@ wuffs_zlib__decoder__set_ignore_checksum(wuffs_zlib__decoder* self, bool a_ic) {
return;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return;
}
@@ -9811,16 +9731,15 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self,
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
if (!self) {
return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER);
return wuffs_base__error__bad_receiver;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status =
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING);
self->private_impl.status = wuffs_base__error__check_wuffs_version_missing;
}
if (self->private_impl.status.code < 0) {
if (wuffs_base__status__is_error(self->private_impl.status)) {
return self->private_impl.status;
}
wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);
wuffs_base__status status = NULL;
uint16_t v_x;
uint32_t v_checksum_got;
@@ -9883,7 +9802,7 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode[0].scratch;
@@ -9902,22 +9821,19 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self,
v_x = t_1;
}
if (((v_x >> 8) & 15) != 8) {
status =
WUFFS_BASE__MAKE_STATUS(WUFFS_ZLIB__ERROR_BAD_COMPRESSION_METHOD);
status = wuffs_zlib__error__bad_compression_method;
goto exit;
}
if ((v_x >> 12) > 7) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_ZLIB__ERROR_BAD_COMPRESSION_WINDOW_SIZE);
status = wuffs_zlib__error__bad_compression_window_size;
goto exit;
}
if ((v_x & 32) != 0) {
status = WUFFS_BASE__MAKE_STATUS(
WUFFS_ZLIB__ERROR_TODO_UNSUPPORTED_PRESET_DICTIONARY);
status = wuffs_zlib__error__todo_unsupported_preset_dictionary;
goto exit;
}
if ((v_x % 31) != 0) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_ZLIB__ERROR_BAD_PARITY_CHECK);
status = wuffs_zlib__error__bad_parity_check;
goto exit;
}
v_checksum_got = 0;
@@ -9966,7 +9882,7 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self,
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ);
status = wuffs_base__suspension__short_read;
goto suspend;
}
uint64_t* scratch = &self->private_impl.c_decode[0].scratch;
@@ -9986,7 +9902,7 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self,
}
if (!self->private_impl.f_ignore_checksum &&
(v_checksum_got != v_checksum_want)) {
status = WUFFS_BASE__MAKE_STATUS(WUFFS_ZLIB__ERROR_BAD_CHECKSUM);
status = wuffs_zlib__error__bad_checksum;
goto exit;
}
+6 -8
View File
@@ -128,9 +128,8 @@ void test_wuffs_adler32_golden() {
wuffs_adler32__hasher checksum = ((wuffs_adler32__hasher){});
wuffs_base__status z = wuffs_adler32__hasher__check_wuffs_version(
&checksum, sizeof checksum, WUFFS_VERSION);
if (z.code) {
FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code,
wuffs_adler32__status__string(z.code));
if (z) {
FAIL("check_wuffs_version: \"%s\"", z);
return;
}
@@ -193,9 +192,8 @@ void test_wuffs_adler32_pi() {
wuffs_adler32__hasher checksum = ((wuffs_adler32__hasher){});
wuffs_base__status z = wuffs_adler32__hasher__check_wuffs_version(
&checksum, sizeof checksum, WUFFS_VERSION);
if (z.code) {
FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code,
wuffs_adler32__status__string(z.code));
if (z) {
FAIL("check_wuffs_version: \"%s\"", z);
return;
}
uint32_t got =
@@ -226,8 +224,8 @@ const char* wuffs_bench_adler32(wuffs_base__io_buffer* dst,
wuffs_adler32__hasher checksum = ((wuffs_adler32__hasher){});
wuffs_base__status z = wuffs_adler32__hasher__check_wuffs_version(
&checksum, sizeof checksum, WUFFS_VERSION);
if (z.code) {
return wuffs_adler32__status__string(z.code);
if (z) {
return z;
}
global_wuffs_adler32_unused_u32 =
wuffs_adler32__hasher__update(&checksum, ((wuffs_base__slice_u8){
+6 -8
View File
@@ -128,9 +128,8 @@ void test_wuffs_crc32_ieee_golden() {
wuffs_crc32__ieee_hasher checksum = ((wuffs_crc32__ieee_hasher){});
wuffs_base__status z = wuffs_crc32__ieee_hasher__check_wuffs_version(
&checksum, sizeof checksum, WUFFS_VERSION);
if (z.code) {
FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code,
wuffs_crc32__status__string(z.code));
if (z) {
FAIL("check_wuffs_version: \"%s\"", z);
return;
}
@@ -193,9 +192,8 @@ void test_wuffs_crc32_ieee_pi() {
wuffs_crc32__ieee_hasher checksum = ((wuffs_crc32__ieee_hasher){});
wuffs_base__status z = wuffs_crc32__ieee_hasher__check_wuffs_version(
&checksum, sizeof checksum, WUFFS_VERSION);
if (z.code) {
FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code,
wuffs_crc32__status__string(z.code));
if (z) {
FAIL("check_wuffs_version: \"%s\"", z);
return;
}
uint32_t got = wuffs_crc32__ieee_hasher__update(
@@ -226,8 +224,8 @@ const char* wuffs_bench_crc32_ieee(wuffs_base__io_buffer* dst,
wuffs_crc32__ieee_hasher checksum = ((wuffs_crc32__ieee_hasher){});
wuffs_base__status z = wuffs_crc32__ieee_hasher__check_wuffs_version(
&checksum, sizeof checksum, WUFFS_VERSION);
if (z.code) {
return wuffs_crc32__status__string(z.code);
if (z) {
return z;
}
global_wuffs_crc32_unused_u32 =
wuffs_crc32__ieee_hasher__update(&checksum, ((wuffs_base__slice_u8){
+26 -42
View File
@@ -133,9 +133,8 @@ const char* wuffs_deflate_decode(wuffs_base__io_buffer* dst,
wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){});
wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version(
&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code,
wuffs_deflate__status__string(z.code));
if (z) {
FAIL("check_wuffs_version: \"%s\"", z);
return false;
}
@@ -152,14 +151,11 @@ const char* wuffs_deflate_decode(wuffs_base__io_buffer* dst,
wuffs_base__status z =
wuffs_deflate__decoder__decode(&dec, dst_writer, src_reader);
if (z.code == WUFFS_BASE__STATUS_OK) {
return NULL;
}
if ((wlimit && (z.code == WUFFS_BASE__SUSPENSION_SHORT_WRITE)) ||
(rlimit && (z.code == WUFFS_BASE__SUSPENSION_SHORT_READ))) {
if ((wlimit && (z == wuffs_base__suspension__short_write)) ||
(rlimit && (z == wuffs_base__suspension__short_read))) {
continue;
}
return wuffs_deflate__status__string(z.code);
return z;
}
}
@@ -248,9 +244,8 @@ void test_wuffs_deflate_decode_split_src() {
wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){});
wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version(
&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code,
wuffs_deflate__status__string(z.code));
if (z) {
FAIL("check_wuffs_version: \"%s\"", z);
return;
}
@@ -266,18 +261,14 @@ void test_wuffs_deflate_decode_split_src() {
wuffs_base__status z1 =
wuffs_deflate__decoder__decode(&dec, dst_writer, src_reader);
if (z0.code != WUFFS_BASE__SUSPENSION_SHORT_READ) {
FAIL("i=%d: z0: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", i, z0.code,
wuffs_deflate__status__string(z0.code),
WUFFS_BASE__SUSPENSION_SHORT_READ,
wuffs_deflate__status__string(WUFFS_BASE__SUSPENSION_SHORT_READ));
if (z0 != wuffs_base__suspension__short_read) {
FAIL("i=%d: z0: got \"%s\", want \"%s\"", i, z0,
wuffs_base__suspension__short_read);
return;
}
if (z1.code != WUFFS_BASE__STATUS_OK) {
FAIL("i=%d: z1: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", i, z1.code,
wuffs_deflate__status__string(z1.code), WUFFS_BASE__STATUS_OK,
wuffs_deflate__status__string(WUFFS_BASE__STATUS_OK));
if (z1) {
FAIL("i=%d: z1: got \"%s\"", i, z1);
return;
}
@@ -296,7 +287,7 @@ bool do_test_wuffs_deflate_history(int i,
wuffs_deflate__decoder* dec,
uint32_t starting_history_index,
uint64_t limit,
int32_t want_z_code) {
const char* want_z) {
src->ri = gt->src_offset0;
src->wi = gt->src_offset1;
got->ri = 0;
@@ -311,12 +302,10 @@ bool do_test_wuffs_deflate_history(int i,
wuffs_base__status got_z =
wuffs_deflate__decoder__decode(dec, dst_writer, src_reader);
if (got_z.code != want_z_code) {
if (got_z != want_z) {
FAIL("i=%d: starting_history_index=0x%04" PRIX32
": decode status: got %" PRIi32 " (%s), want %" PRIi32 " (%s)",
i, starting_history_index, got_z.code,
wuffs_deflate__status__string(got_z.code), want_z_code,
wuffs_deflate__status__string(want_z_code));
": decode status: got \"%s\", want \"%s\"",
i, starting_history_index, got_z, want_z);
return false;
}
return true;
@@ -346,16 +335,14 @@ void test_wuffs_deflate_history_full() {
wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){});
wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version(
&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code,
wuffs_deflate__status__string(z.code));
if (z) {
FAIL("check_wuffs_version: \"%s\"", z);
return;
}
if (!do_test_wuffs_deflate_history(
i, gt, &src, &got, &dec, 0, want.wi + i,
i >= 0 ? WUFFS_BASE__STATUS_OK
: WUFFS_BASE__SUSPENSION_SHORT_WRITE)) {
i >= 0 ? NULL : wuffs_base__suspension__short_write)) {
return;
}
@@ -418,15 +405,14 @@ void test_wuffs_deflate_history_partial() {
wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){});
wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version(
&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code,
wuffs_deflate__status__string(z.code));
if (z) {
FAIL("check_wuffs_version: \"%s\"", z);
return;
}
if (!do_test_wuffs_deflate_history(i, gt, &src, &got, &dec,
starting_history_index, fragment_length,
WUFFS_BASE__SUSPENSION_SHORT_WRITE)) {
wuffs_base__suspension__short_write)) {
return;
}
@@ -507,9 +493,8 @@ void test_wuffs_deflate_table_redirect() {
wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){});
wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version(
&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code,
wuffs_deflate__status__string(z.code));
if (z) {
FAIL("check_wuffs_version: \"%s\"", z);
return;
}
@@ -531,9 +516,8 @@ void test_wuffs_deflate_table_redirect() {
dec.private_impl.f_code_lengths[n++] = 13;
z = wuffs_deflate__decoder__init_huff(&dec, 0, 0, n, 257);
if (z.code) {
FAIL("init_huff: %" PRIi32 " (%s)", z.code,
wuffs_deflate__status__string(z.code));
if (z) {
FAIL("init_huff: \"%s\"", z);
return;
}
+90 -139
View File
@@ -74,11 +74,9 @@ void test_basic_bad_receiver() {
wuffs_base__io_reader src = ((wuffs_base__io_reader){});
wuffs_base__status z =
wuffs_gif__decoder__decode_image_config(NULL, &ic, src);
if (z.code != WUFFS_BASE__ERROR_BAD_RECEIVER) {
FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)",
z.code, wuffs_gif__status__string(z.code),
WUFFS_BASE__ERROR_BAD_RECEIVER,
wuffs_gif__status__string(WUFFS_BASE__ERROR_BAD_RECEIVER));
if (z != wuffs_base__error__bad_receiver) {
FAIL("decode_image_config: got \"%s\", want \"%s\"", z,
wuffs_base__error__bad_receiver);
}
}
@@ -87,11 +85,9 @@ void test_basic_bad_sizeof_receiver() {
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_base__status z =
wuffs_gif__decoder__check_wuffs_version(&dec, 0, WUFFS_VERSION);
if (z.code != WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER) {
FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)",
z.code, wuffs_gif__status__string(z.code),
WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER,
wuffs_gif__status__string(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER));
if (z != wuffs_base__error__bad_sizeof_receiver) {
FAIL("decode_image_config: got \"%s\", want \"%s\"", z,
wuffs_base__error__bad_sizeof_receiver);
return;
}
}
@@ -101,11 +97,9 @@ void test_basic_bad_wuffs_version() {
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_base__status z = wuffs_gif__decoder__check_wuffs_version(
&dec, sizeof dec, WUFFS_VERSION ^ 0x123456789ABC);
if (z.code != WUFFS_BASE__ERROR_BAD_WUFFS_VERSION) {
FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)",
z.code, wuffs_gif__status__string(z.code),
WUFFS_BASE__ERROR_BAD_WUFFS_VERSION,
wuffs_gif__status__string(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION));
if (z != wuffs_base__error__bad_wuffs_version) {
FAIL("decode_image_config: got \"%s\", want \"%s\"", z,
wuffs_base__error__bad_wuffs_version);
return;
}
}
@@ -117,34 +111,27 @@ void test_basic_check_wuffs_version_not_called() {
wuffs_base__io_reader src = ((wuffs_base__io_reader){});
wuffs_base__status z =
wuffs_gif__decoder__decode_image_config(&dec, &ic, src);
if (z.code != WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING) {
FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)",
z.code, wuffs_gif__status__string(z.code),
WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING,
wuffs_gif__status__string(
WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING));
if (z != wuffs_base__error__check_wuffs_version_missing) {
FAIL("decode_image_config: got \"%s\", want \"%s\"", z,
wuffs_base__error__check_wuffs_version_missing);
}
}
void test_basic_status_is_error() {
CHECK_FOCUS(__func__);
if (wuffs_base__status__is_error(
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK))) {
FAIL("is_error(OK) returned true");
if (wuffs_base__status__is_error(NULL)) {
FAIL("is_error(NULL) returned true");
return;
}
if (!wuffs_base__status__is_error(
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION))) {
if (!wuffs_base__status__is_error(wuffs_base__error__bad_wuffs_version)) {
FAIL("is_error(BAD_WUFFS_VERSION) returned false");
return;
}
if (wuffs_base__status__is_error(
WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE))) {
if (wuffs_base__status__is_error(wuffs_base__suspension__short_write)) {
FAIL("is_error(SHORT_WRITE) returned true");
return;
}
if (!wuffs_base__status__is_error(
WUFFS_BASE__MAKE_STATUS(WUFFS_GIF__ERROR_BAD_HEADER))) {
if (!wuffs_base__status__is_error(wuffs_gif__error__bad_header)) {
FAIL("is_error(BAD_HEADER) returned false");
return;
}
@@ -152,45 +139,31 @@ void test_basic_status_is_error() {
void test_basic_status_strings() {
CHECK_FOCUS(__func__);
const char* s0 = wuffs_gif__status__string(WUFFS_BASE__STATUS_OK);
const char* t0 = "+base: ok";
if (strcmp(s0, t0)) {
FAIL("got \"%s\", want \"%s\"", s0, t0);
return;
}
const char* s1 =
wuffs_gif__status__string(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION);
const char* s1 = wuffs_base__error__bad_wuffs_version;
const char* t1 = "?base: bad wuffs version";
if (strcmp(s1, t1)) {
FAIL("got \"%s\", want \"%s\"", s1, t1);
return;
}
const char* s2 =
wuffs_gif__status__string(WUFFS_BASE__SUSPENSION_SHORT_WRITE);
const char* s2 = wuffs_base__suspension__short_write;
const char* t2 = "$base: short write";
if (strcmp(s2, t2)) {
FAIL("got \"%s\", want \"%s\"", s2, t2);
return;
}
const char* s3 = wuffs_gif__status__string(WUFFS_GIF__ERROR_BAD_HEADER);
const char* s3 = wuffs_gif__error__bad_header;
const char* t3 = "?gif: bad header";
if (strcmp(s3, t3)) {
FAIL("got \"%s\", want \"%s\"", s3, t3);
return;
}
const char* s4 = wuffs_gif__status__string(-254);
const char* t4 = "unknown status";
if (strcmp(s4, t4)) {
FAIL("got \"%s\", want \"%s\"", s4, t4);
return;
}
}
void test_basic_status_used_package() {
CHECK_FOCUS(__func__);
// The function call here is from "std/gif" but the argument is from
// "std/lzw". The former package depends on the latter.
const char* s0 = wuffs_gif__status__string(WUFFS_LZW__ERROR_BAD_CODE);
const char* s0 = wuffs_lzw__error__bad_code;
const char* t0 = "?lzw: bad code";
if (strcmp(s0, t0)) {
FAIL("got \"%s\", want \"%s\"", s0, t0);
@@ -203,9 +176,8 @@ void test_basic_sub_struct_initializer() {
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_base__status z =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code,
wuffs_gif__status__string(z.code));
if (z) {
FAIL("check_wuffs_version: \"%s\"", z);
return;
}
if (dec.private_impl.magic != WUFFS_BASE__MAGIC) {
@@ -227,16 +199,16 @@ const char* wuffs_gif_decode(wuffs_base__io_buffer* dst,
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_base__status z =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
return wuffs_gif__status__string(z.code);
if (z) {
return z;
}
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(src);
z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (z.code) {
return wuffs_gif__status__string(z.code);
if (z) {
return z;
}
z = wuffs_base__pixel_buffer__set_from_slice(
&pb, wuffs_base__image_config__pixel_config(&ic),
@@ -244,23 +216,23 @@ const char* wuffs_gif_decode(wuffs_base__io_buffer* dst,
.ptr = global_pixel_buffer,
.len = WUFFS_TESTLIB_ARRAY_SIZE(global_pixel_buffer),
}));
if (z.code) {
return wuffs_gif__status__string(z.code);
if (z) {
return z;
}
while (true) {
z = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader);
if (z.code) {
if (z.code == WUFFS_BASE__SUSPENSION_END_OF_DATA) {
if (z) {
if (z == wuffs_base__suspension__end_of_data) {
break;
}
return wuffs_gif__status__string(z.code);
return z;
}
z = wuffs_gif__decoder__decode_frame(&dec, &pb, 0, 0, src_reader,
((wuffs_base__slice_u8){}));
if (z.code) {
return wuffs_gif__status__string(z.code);
if (z) {
return z;
}
const char* msg = copy_to_io_buffer_from_pixel_buffer(
@@ -288,9 +260,8 @@ bool do_test_wuffs_gif_decode(const char* filename,
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_base__status z =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code,
wuffs_gif__status__string(z.code));
if (z) {
FAIL("check_wuffs_version: \"%s\"", z);
return false;
}
@@ -301,9 +272,8 @@ bool do_test_wuffs_gif_decode(const char* filename,
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (z.code != WUFFS_BASE__STATUS_OK) {
FAIL("decode_image_config: got %" PRIi32 " (%s)", z.code,
wuffs_gif__status__string(z.code));
if (z) {
FAIL("decode_image_config: got \"%s\"", z);
return false;
}
if (wuffs_base__image_config__pixel_format(&ic) !=
@@ -340,8 +310,8 @@ bool do_test_wuffs_gif_decode(const char* filename,
.ptr = global_pixel_buffer,
.len = WUFFS_TESTLIB_ARRAY_SIZE(global_pixel_buffer),
}));
if (z.code) {
FAIL("set_from_slice: %s", wuffs_gif__status__string(z.code));
if (z) {
FAIL("set_from_slice: \"%s\"", z);
return false;
}
}
@@ -358,14 +328,12 @@ bool do_test_wuffs_gif_decode(const char* filename,
wuffs_base__status z =
wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader);
if (z.code == WUFFS_BASE__STATUS_OK) {
if (!z) {
break;
}
if (z.code != WUFFS_BASE__SUSPENSION_SHORT_READ) {
FAIL("decode_frame_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)",
z.code, wuffs_gif__status__string(z.code),
WUFFS_BASE__SUSPENSION_SHORT_READ,
wuffs_gif__status__string(WUFFS_BASE__SUSPENSION_SHORT_READ));
if (z != wuffs_base__suspension__short_read) {
FAIL("decode_frame_config: got \"%s\", want \"%s\"", z,
wuffs_base__suspension__short_read);
return false;
}
@@ -390,13 +358,12 @@ bool do_test_wuffs_gif_decode(const char* filename,
wuffs_base__status z = wuffs_gif__decoder__decode_frame(
&dec, &pb, 0, 0, src_reader, ((wuffs_base__slice_u8){}));
if (z.code == WUFFS_BASE__STATUS_OK) {
if (!z) {
break;
}
if (z.code != WUFFS_BASE__SUSPENSION_SHORT_READ) {
FAIL("decode_frame: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", z.code,
wuffs_gif__status__string(z.code), WUFFS_BASE__SUSPENSION_SHORT_READ,
wuffs_gif__status__string(WUFFS_BASE__SUSPENSION_SHORT_READ));
if (z != wuffs_base__suspension__short_read) {
FAIL("decode_frame: got \"%s\", want \"%s\"", z,
wuffs_base__suspension__short_read);
return false;
}
@@ -461,11 +428,9 @@ bool do_test_wuffs_gif_decode(const char* filename,
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
wuffs_base__status z = wuffs_gif__decoder__decode_frame(
&dec, &pb, 0, 0, src_reader, ((wuffs_base__slice_u8){}));
if (z.code != WUFFS_BASE__SUSPENSION_END_OF_DATA) {
FAIL("decode_frame: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", z.code,
wuffs_gif__status__string(z.code),
WUFFS_BASE__SUSPENSION_END_OF_DATA,
wuffs_gif__status__string(WUFFS_BASE__SUSPENSION_END_OF_DATA));
if (z != wuffs_base__suspension__end_of_data) {
FAIL("decode_frame: got \"%s\", want \"%s\"", z,
wuffs_base__suspension__end_of_data);
return false;
}
if (src.ri != src.wi) {
@@ -490,28 +455,23 @@ void test_wuffs_gif_call_sequence() {
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_base__status z =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code,
wuffs_gif__status__string(z.code));
if (z) {
FAIL("check_wuffs_version: \"%s\"", z);
return;
}
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
z = wuffs_gif__decoder__decode_image_config(&dec, NULL, src_reader);
if (z.code != WUFFS_BASE__STATUS_OK) {
FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)",
z.code, wuffs_gif__status__string(z.code), WUFFS_BASE__STATUS_OK,
wuffs_gif__status__string(WUFFS_BASE__STATUS_OK));
if (z) {
FAIL("decode_image_config: got \"%s\"", z);
return;
}
z = wuffs_gif__decoder__decode_image_config(&dec, NULL, src_reader);
if (z.code != WUFFS_BASE__ERROR_INVALID_CALL_SEQUENCE) {
FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)",
z.code, wuffs_gif__status__string(z.code),
WUFFS_BASE__ERROR_INVALID_CALL_SEQUENCE,
wuffs_gif__status__string(WUFFS_BASE__ERROR_INVALID_CALL_SEQUENCE));
if (z != wuffs_base__error__invalid_call_sequence) {
FAIL("decode_image_config: got \"%s\", want \"%s\"", z,
wuffs_base__error__invalid_call_sequence);
return;
}
}
@@ -530,9 +490,8 @@ bool do_test_wuffs_gif_decode_animated(
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_base__status z =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code,
wuffs_gif__status__string(z.code));
if (z) {
FAIL("check_wuffs_version: \"%s\"", z);
return false;
}
@@ -541,9 +500,8 @@ bool do_test_wuffs_gif_decode_animated(
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (z.code != WUFFS_BASE__STATUS_OK) {
FAIL("decode_image_config: got %" PRIi32 " (%s)", z.code,
wuffs_gif__status__string(z.code));
if (z) {
FAIL("decode_image_config: got \"%s\"", z);
return false;
}
@@ -558,8 +516,8 @@ bool do_test_wuffs_gif_decode_animated(
.ptr = global_pixel_buffer,
.len = WUFFS_TESTLIB_ARRAY_SIZE(global_pixel_buffer),
}));
if (z.code) {
FAIL("set_from_slice: %s", wuffs_gif__status__string(z.code));
if (z) {
FAIL("set_from_slice: \"%s\"", z);
return false;
}
@@ -567,17 +525,15 @@ bool do_test_wuffs_gif_decode_animated(
for (i = 0; i < want_num_frames; i++) {
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
z = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader);
if (z.code != WUFFS_BASE__STATUS_OK) {
FAIL("decode_frame_config #%" PRIu32 ": got %" PRIi32 " (%s)", i, z.code,
wuffs_gif__status__string(z.code));
if (z) {
FAIL("decode_frame_config #%" PRIu32 ": got \"%s\"", i, z);
return false;
}
z = wuffs_gif__decoder__decode_frame(&dec, &pb, 0, 0, src_reader,
((wuffs_base__slice_u8){}));
if (z.code != WUFFS_BASE__STATUS_OK) {
FAIL("decode_frame #%" PRIu32 ": got %" PRIi32 " (%s)", i, z.code,
wuffs_gif__status__string(z.code));
if (z) {
FAIL("decode_frame #%" PRIu32 ": got \"%s\"", i, z);
return false;
}
@@ -599,10 +555,9 @@ bool do_test_wuffs_gif_decode_animated(
// There should be no more frames.
z = wuffs_gif__decoder__decode_frame(&dec, &pb, 0, 0, src_reader,
((wuffs_base__slice_u8){}));
if (z.code != WUFFS_BASE__SUSPENSION_END_OF_DATA) {
FAIL("decode_frame: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", z.code,
wuffs_gif__status__string(z.code), WUFFS_BASE__SUSPENSION_END_OF_DATA,
wuffs_gif__status__string(WUFFS_BASE__SUSPENSION_END_OF_DATA));
if (z != wuffs_base__suspension__end_of_data) {
FAIL("decode_frame: got \"%s\", want \"%s\"", z,
wuffs_base__suspension__end_of_data);
return false;
}
@@ -656,16 +611,15 @@ void test_wuffs_gif_decode_frame_out_of_bounds() {
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_base__status z =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code,
wuffs_gif__status__string(z.code));
if (z) {
FAIL("check_wuffs_version: \"%s\"", z);
return;
}
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (z.code) {
FAIL("decode_image_config: %s", wuffs_gif__status__string(z.code));
if (z) {
FAIL("decode_image_config: \"%s\"", z);
return;
}
@@ -731,19 +685,17 @@ void test_wuffs_gif_decode_input_is_a_png() {
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_base__status z =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code,
wuffs_gif__status__string(z.code));
if (z) {
FAIL("check_wuffs_version: \"%s\"", z);
return;
}
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (z.code != WUFFS_GIF__ERROR_BAD_HEADER) {
FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)",
z.code, wuffs_gif__status__string(z.code), WUFFS_GIF__ERROR_BAD_HEADER,
wuffs_gif__status__string(WUFFS_GIF__ERROR_BAD_HEADER));
if (z != wuffs_gif__error__bad_header) {
FAIL("decode_image_config: got \"%s\", want \"%s\"", z,
wuffs_gif__error__bad_header);
return;
}
}
@@ -759,9 +711,8 @@ bool do_test_wuffs_gif_num_decoded(bool frame_config) {
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_base__status z =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code,
wuffs_gif__status__string(z.code));
if (z) {
FAIL("check_wuffs_version: \"%s\"", z);
return false;
}
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
@@ -770,8 +721,8 @@ bool do_test_wuffs_gif_num_decoded(bool frame_config) {
if (!frame_config) {
wuffs_base__image_config ic = ((wuffs_base__image_config){});
z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (z.code != WUFFS_BASE__STATUS_OK) {
FAIL("decode_image_config: %s", wuffs_gif__status__string(z.code));
if (z) {
FAIL("decode_image_config: \"%s\"", z);
return false;
}
@@ -781,8 +732,8 @@ bool do_test_wuffs_gif_num_decoded(bool frame_config) {
.ptr = global_pixel_buffer,
.len = WUFFS_TESTLIB_ARRAY_SIZE(global_pixel_buffer),
}));
if (z.code) {
FAIL("set_from_slice: %s", wuffs_gif__status__string(z.code));
if (z) {
FAIL("set_from_slice: \"%s\"", z);
return false;
}
}
@@ -804,7 +755,7 @@ bool do_test_wuffs_gif_num_decoded(bool frame_config) {
break;
}
wuffs_base__status z = ((wuffs_base__status){});
wuffs_base__status z = NULL;
if (frame_config) {
z = wuffs_gif__decoder__decode_frame_config(&dec, NULL, src_reader);
} else {
@@ -812,14 +763,14 @@ bool do_test_wuffs_gif_num_decoded(bool frame_config) {
((wuffs_base__slice_u8){}));
}
if (z.code == WUFFS_BASE__STATUS_OK) {
if (!z) {
want++;
continue;
} else if (z.code == WUFFS_BASE__SUSPENSION_END_OF_DATA) {
} else if (z == wuffs_base__suspension__end_of_data) {
end_of_data = true;
continue;
}
FAIL("%s: %s", method, wuffs_gif__status__string(z.code));
FAIL("%s: \"%s\"", method, z);
return false;
}
+14 -20
View File
@@ -88,8 +88,8 @@ const char* wuffs_gzip_decode(wuffs_base__io_buffer* dst,
wuffs_gzip__decoder dec = ((wuffs_gzip__decoder){});
wuffs_base__status z =
wuffs_gzip__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
return wuffs_gzip__status__string(z.code);
if (z) {
return z;
}
while (true) {
@@ -105,14 +105,11 @@ const char* wuffs_gzip_decode(wuffs_base__io_buffer* dst,
wuffs_base__status z =
wuffs_gzip__decoder__decode(&dec, dst_writer, src_reader);
if (z.code == WUFFS_BASE__STATUS_OK) {
return NULL;
}
if ((wlimit && (z.code == WUFFS_BASE__SUSPENSION_SHORT_WRITE)) ||
(rlimit && (z.code == WUFFS_BASE__SUSPENSION_SHORT_READ))) {
if ((wlimit && (z == wuffs_base__suspension__short_write)) ||
(rlimit && (z == wuffs_base__suspension__short_read))) {
continue;
}
return wuffs_gzip__status__string(z.code);
return z;
}
}
@@ -140,9 +137,8 @@ bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) {
wuffs_gzip__decoder dec = ((wuffs_gzip__decoder){});
wuffs_base__status z = wuffs_gzip__decoder__check_wuffs_version(
&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code,
wuffs_gzip__status__string(z.code));
if (z) {
FAIL("check_wuffs_version: \"%s\"", z);
return false;
}
wuffs_gzip__decoder__set_ignore_checksum(&dec, ignore_checksum);
@@ -155,7 +151,7 @@ bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) {
int i;
for (i = 0; i < 2; i++) {
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
int32_t want_z_code = 0;
const char* want_z = NULL;
if (i == 0) {
if (end_limit == 0) {
continue;
@@ -165,19 +161,17 @@ bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) {
return false;
}
set_reader_limit(&src_reader, src.wi - (uint64_t)(end_limit));
want_z_code = WUFFS_BASE__SUSPENSION_SHORT_READ;
want_z = wuffs_base__suspension__short_read;
} else {
want_z_code = (bad_checksum && !ignore_checksum)
? WUFFS_GZIP__ERROR_BAD_CHECKSUM
: WUFFS_BASE__STATUS_OK;
want_z = (bad_checksum && !ignore_checksum)
? wuffs_gzip__error__bad_checksum
: NULL;
}
wuffs_base__status got_z =
wuffs_gzip__decoder__decode(&dec, got_writer, src_reader);
if (got_z.code != want_z_code) {
FAIL("end_limit=%d: got %" PRIi32 " (%s), want %" PRIi32 " (%s)",
end_limit, got_z.code, wuffs_gzip__status__string(got_z.code),
want_z_code, wuffs_gzip__status__string(want_z_code));
if (got_z != want_z) {
FAIL("end_limit=%d: got \"%s\", want \"%s\"", end_limit, got_z, want_z);
return false;
}
}
+12 -19
View File
@@ -103,9 +103,8 @@ bool do_test_wuffs_lzw_decode(const char* src_filename,
wuffs_lzw__decoder dec = ((wuffs_lzw__decoder){});
wuffs_base__status z =
wuffs_lzw__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code,
wuffs_lzw__status__string(z.code));
if (z) {
FAIL("check_wuffs_version: \"%s\"", z);
return false;
}
wuffs_lzw__decoder__set_literal_width(&dec, literal_width);
@@ -124,22 +123,18 @@ bool do_test_wuffs_lzw_decode(const char* src_filename,
size_t old_ri = src.ri;
z = wuffs_lzw__decoder__decode(&dec, got_writer, src_reader);
if (z.code == WUFFS_BASE__STATUS_OK) {
if (!z) {
if (src.ri != src.wi) {
FAIL("decode returned \"ok\" but src was not exhausted");
return false;
}
break;
}
if ((z.code != WUFFS_BASE__SUSPENSION_SHORT_READ) &&
(z.code != WUFFS_BASE__SUSPENSION_SHORT_WRITE)) {
FAIL("decode: got %" PRIi32 " (%s), want %" PRIi32 " (%s) or %" PRIi32
" (%s)",
z.code, wuffs_lzw__status__string(z.code),
WUFFS_BASE__SUSPENSION_SHORT_READ,
wuffs_lzw__status__string(WUFFS_BASE__SUSPENSION_SHORT_READ),
WUFFS_BASE__SUSPENSION_SHORT_WRITE,
wuffs_lzw__status__string(WUFFS_BASE__SUSPENSION_SHORT_WRITE));
if ((z != wuffs_base__suspension__short_read) &&
(z != wuffs_base__suspension__short_write)) {
FAIL("decode: got \"%s\", want \"%s\" or \"%s\"", z,
wuffs_base__suspension__short_read,
wuffs_base__suspension__short_write);
return false;
}
@@ -235,15 +230,13 @@ bool do_bench_wuffs_lzw_decode(const char* filename, uint64_t iters_unscaled) {
wuffs_lzw__decoder dec = ((wuffs_lzw__decoder){});
wuffs_base__status z = wuffs_lzw__decoder__check_wuffs_version(
&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code,
wuffs_lzw__status__string(z.code));
if (z) {
FAIL("check_wuffs_version: \"%s\"", z);
return false;
}
z = wuffs_lzw__decoder__decode(&dec, dst_writer, src_reader);
if (z.code) {
FAIL("decode: %" PRIi32 " (%s)", z.code,
wuffs_lzw__status__string(z.code));
if (z) {
FAIL("decode: \"%s\"", z);
return false;
}
n_bytes += dst.wi;
+14 -20
View File
@@ -88,8 +88,8 @@ const char* wuffs_zlib_decode(wuffs_base__io_buffer* dst,
wuffs_zlib__decoder dec = ((wuffs_zlib__decoder){});
wuffs_base__status z =
wuffs_zlib__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
return wuffs_zlib__status__string(z.code);
if (z) {
return z;
}
while (true) {
@@ -105,14 +105,11 @@ const char* wuffs_zlib_decode(wuffs_base__io_buffer* dst,
wuffs_base__status z =
wuffs_zlib__decoder__decode(&dec, dst_writer, src_reader);
if (z.code == WUFFS_BASE__STATUS_OK) {
return NULL;
}
if ((wlimit && (z.code == WUFFS_BASE__SUSPENSION_SHORT_WRITE)) ||
(rlimit && (z.code == WUFFS_BASE__SUSPENSION_SHORT_READ))) {
if ((wlimit && (z == wuffs_base__suspension__short_write)) ||
(rlimit && (z == wuffs_base__suspension__short_read))) {
continue;
}
return wuffs_zlib__status__string(z.code);
return z;
}
}
@@ -139,9 +136,8 @@ bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) {
wuffs_zlib__decoder dec = ((wuffs_zlib__decoder){});
wuffs_base__status z = wuffs_zlib__decoder__check_wuffs_version(
&dec, sizeof dec, WUFFS_VERSION);
if (z.code) {
FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code,
wuffs_zlib__status__string(z.code));
if (z) {
FAIL("check_wuffs_version: \"%s\"", z);
return false;
}
wuffs_zlib__decoder__set_ignore_checksum(&dec, ignore_checksum);
@@ -154,7 +150,7 @@ bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) {
int i;
for (i = 0; i < 2; i++) {
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
int32_t want_z_code = 0;
const char* want_z = NULL;
if (i == 0) {
if (end_limit == 0) {
continue;
@@ -164,19 +160,17 @@ bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) {
return false;
}
set_reader_limit(&src_reader, src.wi - (uint64_t)(end_limit));
want_z_code = WUFFS_BASE__SUSPENSION_SHORT_READ;
want_z = wuffs_base__suspension__short_read;
} else {
want_z_code = (bad_checksum && !ignore_checksum)
? WUFFS_ZLIB__ERROR_BAD_CHECKSUM
: WUFFS_BASE__STATUS_OK;
want_z = (bad_checksum && !ignore_checksum)
? wuffs_zlib__error__bad_checksum
: NULL;
}
wuffs_base__status got_z =
wuffs_zlib__decoder__decode(&dec, got_writer, src_reader);
if (got_z.code != want_z_code) {
FAIL("end_limit=%d: got %" PRIi32 " (%s), want %" PRIi32 " (%s)",
end_limit, got_z.code, wuffs_zlib__status__string(got_z.code),
want_z_code, wuffs_zlib__status__string(want_z_code));
if (got_z != want_z) {
FAIL("end_limit=%d: got \"%s\", want \"%s\"", end_limit, got_z, want_z);
return false;
}
}