From b840c80040069a1ec7bc953656f68ef8bc62d1b3 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sun, 12 Aug 2018 16:05:14 +1000 Subject: [PATCH] Make the status type a const char*, not a struct --- cmd/wuffs-c/internal/cgen/base/base-private.h | 6 +- cmd/wuffs-c/internal/cgen/base/base-public.h | 42 +- cmd/wuffs-c/internal/cgen/base/image-public.h | 9 +- cmd/wuffs-c/internal/cgen/builtin.go | 6 +- cmd/wuffs-c/internal/cgen/cgen.go | 14 +- cmd/wuffs-c/internal/cgen/data.go | 13 +- cmd/wuffs-c/internal/cgen/expr.go | 33 +- cmd/wuffs-c/internal/cgen/func.go | 14 +- cmd/wuffs-c/internal/cgen/statement.go | 11 +- doc/changelog.md | 2 +- example/crc32/crc32.cc | 4 +- example/gifplayer/gifplayer.c | 24 +- example/library/library.c | 8 +- example/zcat/zcat.c | 13 +- fuzz/c/std/gif_fuzzer.c | 20 +- fuzz/c/std/zlib_fuzzer.c | 10 +- release/c/wuffs-unsupported-snapshot.h | 786 ++++++++---------- test/c/std/adler32.c | 14 +- test/c/std/crc32.c | 14 +- test/c/std/deflate.c | 68 +- test/c/std/gif.c | 229 ++--- test/c/std/gzip.c | 34 +- test/c/std/lzw.c | 31 +- test/c/std/zlib.c | 34 +- 24 files changed, 624 insertions(+), 815 deletions(-) diff --git a/cmd/wuffs-c/internal/cgen/base/base-private.h b/cmd/wuffs-c/internal/cgen/base/base-private.h index 70dd26ed..0cfbbe48 100644 --- a/cmd/wuffs-c/internal/cgen/base/base-private.h +++ b/cmd/wuffs-c/internal/cgen/base/base-private.h @@ -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; \ diff --git a/cmd/wuffs-c/internal/cgen/base/base-public.h b/cmd/wuffs-c/internal/cgen/base/base-public.h index 459253ee..eba0c2d1 100644 --- a/cmd/wuffs-c/internal/cgen/base/base-public.h +++ b/cmd/wuffs-c/internal/cgen/base/base-public.h @@ -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* // diff --git a/cmd/wuffs-c/internal/cgen/base/image-public.h b/cmd/wuffs-c/internal/cgen/base/image-public.h index 3b844cde..06b628c3 100644 --- a/cmd/wuffs-c/internal/cgen/base/image-public.h +++ b/cmd/wuffs-c/internal/cgen/base/image-public.h @@ -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. diff --git a/cmd/wuffs-c/internal/cgen/builtin.go b/cmd/wuffs-c/internal/cgen/builtin.go index 6b6d5628..282cf23d 100644 --- a/cmd/wuffs-c/internal/cgen/builtin.go +++ b/cmd/wuffs-c/internal/cgen/builtin.go @@ -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 { diff --git a/cmd/wuffs-c/internal/cgen/cgen.go b/cmd/wuffs-c/internal/cgen/cgen.go index 8096837e..6b103080 100644 --- a/cmd/wuffs-c/internal/cgen/cgen.go +++ b/cmd/wuffs-c/internal/cgen/cgen.go @@ -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 } diff --git a/cmd/wuffs-c/internal/cgen/data.go b/cmd/wuffs-c/internal/cgen/data.go index 99867536..665213bf 100644 --- a/cmd/wuffs-c/internal/cgen/data.go +++ b/cmd/wuffs-c/internal/cgen/data.go @@ -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" + "" diff --git a/cmd/wuffs-c/internal/cgen/expr.go b/cmd/wuffs-c/internal/cgen/expr.go index b4d12436..587e621b 100644 --- a/cmd/wuffs-c/internal/cgen/expr.go +++ b/cmd/wuffs-c/internal/cgen/expr.go @@ -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 } diff --git a/cmd/wuffs-c/internal/cgen/func.go b/cmd/wuffs-c/internal/cgen/func.go index 44273bd4..d5115ab3 100644 --- a/cmd/wuffs-c/internal/cgen/func.go +++ b/cmd/wuffs-c/internal/cgen/func.go @@ -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;") } diff --git a/cmd/wuffs-c/internal/cgen/statement.go b/cmd/wuffs-c/internal/cgen/statement.go index 3fc8e214..807e1d1c 100644 --- a/cmd/wuffs-c/internal/cgen/statement.go +++ b/cmd/wuffs-c/internal/cgen/statement.go @@ -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) diff --git a/doc/changelog.md b/doc/changelog.md index 6b608f66..69cfd478 100644 --- a/doc/changelog.md +++ b/doc/changelog.md @@ -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. diff --git a/example/crc32/crc32.cc b/example/crc32/crc32.cc index 98c4e46e..6bb43a77 100644 --- a/example/crc32/crc32.cc +++ b/example/crc32/crc32.cc @@ -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; } diff --git a/example/gifplayer/gifplayer.c b/example/gifplayer/gifplayer.c index 3adb296f..0c557479 100644 --- a/example/gifplayer/gifplayer.c +++ b/example/gifplayer/gifplayer.c @@ -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)); diff --git a/example/library/library.c b/example/library/library.c index d87e1b84..7991f50d 100644 --- a/example/library/library.c +++ b/example/library/library.c @@ -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; diff --git a/example/zcat/zcat.c b/example/zcat/zcat.c index 4c4d2912..2918891e 100644 --- a/example/zcat/zcat.c +++ b/example/zcat/zcat.c @@ -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); diff --git a/fuzz/c/std/gif_fuzzer.c b/fuzz/c/std/gif_fuzzer.c index e41ed1c9..935362dc 100644 --- a/fuzz/c/std/gif_fuzzer.c +++ b/fuzz/c/std/gif_fuzzer.c @@ -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; diff --git a/fuzz/c/std/zlib_fuzzer.c b/fuzz/c/std/zlib_fuzzer.c index ba16cb5a..2e34a166 100644 --- a/fuzz/c/std/zlib_fuzzer.c +++ b/fuzz/c/std/zlib_fuzzer.c @@ -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; } diff --git a/release/c/wuffs-unsupported-snapshot.h b/release/c/wuffs-unsupported-snapshot.h index 891ca333..a665f79a 100644 --- a/release/c/wuffs-unsupported-snapshot.h +++ b/release/c/wuffs-unsupported-snapshot.h @@ -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; } diff --git a/test/c/std/adler32.c b/test/c/std/adler32.c index 89b71024..e8d5fda9 100644 --- a/test/c/std/adler32.c +++ b/test/c/std/adler32.c @@ -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){ diff --git a/test/c/std/crc32.c b/test/c/std/crc32.c index d76ec56b..fc6e4580 100644 --- a/test/c/std/crc32.c +++ b/test/c/std/crc32.c @@ -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){ diff --git a/test/c/std/deflate.c b/test/c/std/deflate.c index 6c741912..afa98ef5 100644 --- a/test/c/std/deflate.c +++ b/test/c/std/deflate.c @@ -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; } diff --git a/test/c/std/gif.c b/test/c/std/gif.c index c71f44db..e5c61b59 100644 --- a/test/c/std/gif.c +++ b/test/c/std/gif.c @@ -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; } diff --git a/test/c/std/gzip.c b/test/c/std/gzip.c index faa1751f..e512a554 100644 --- a/test/c/std/gzip.c +++ b/test/c/std/gzip.c @@ -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; } } diff --git a/test/c/std/lzw.c b/test/c/std/lzw.c index 77584277..ee528390 100644 --- a/test/c/std/lzw.c +++ b/test/c/std/lzw.c @@ -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; diff --git a/test/c/std/zlib.c b/test/c/std/zlib.c index cabb5232..91a15ab9 100644 --- a/test/c/std/zlib.c +++ b/test/c/std/zlib.c @@ -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; } }