From 2a32a86a6c62efea72a0c3f15a0d2e0a4777fd86 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sat, 11 Aug 2018 13:27:29 +1000 Subject: [PATCH] Make the status type a struct, not an int32_t --- cmd/wuffs-c/internal/cgen/base/base-impl.c | 4 +- cmd/wuffs-c/internal/cgen/base/base-private.h | 4 +- cmd/wuffs-c/internal/cgen/base/base-public.h | 21 +- cmd/wuffs-c/internal/cgen/base/image-public.h | 9 +- cmd/wuffs-c/internal/cgen/builtin.go | 12 +- cmd/wuffs-c/internal/cgen/cgen.go | 24 +- cmd/wuffs-c/internal/cgen/data.go | 17 +- cmd/wuffs-c/internal/cgen/expr.go | 15 +- cmd/wuffs-c/internal/cgen/func.go | 14 +- cmd/wuffs-c/internal/cgen/statement.go | 10 +- doc/changelog.md | 1 + example/crc32/crc32.cc | 4 +- example/gifplayer/gifplayer.c | 24 +- example/library/library.c | 8 +- example/zcat/zcat.c | 12 +- fuzz/c/std/gif_fuzzer.c | 20 +- fuzz/c/std/zlib_fuzzer.c | 8 +- lang/ast/ast.go | 4 + release/c/wuffs-unsupported-snapshot.h | 855 ++++++++++-------- test/c/std/adler32.c | 16 +- test/c/std/crc32.c | 16 +- test/c/std/deflate.c | 65 +- test/c/std/gif.c | 202 +++-- test/c/std/gzip.c | 34 +- test/c/std/lzw.c | 26 +- test/c/std/zlib.c | 34 +- 26 files changed, 791 insertions(+), 668 deletions(-) diff --git a/cmd/wuffs-c/internal/cgen/base/base-impl.c b/cmd/wuffs-c/internal/cgen/base/base-impl.c index 8b45f58e..e8804f69 100644 --- a/cmd/wuffs-c/internal/cgen/base/base-impl.c +++ b/cmd/wuffs-c/internal/cgen/base/base-impl.c @@ -25,8 +25,8 @@ // !! INSERT wuffs_base__status__string data. const char* // -wuffs_base__status__string(wuffs_base__status s) { - uint16_t o = wuffs_base__status__string_offsets[(uint8_t)(s >> 24)]; +wuffs_base__status__string(int32_t status_code) { + uint16_t o = wuffs_base__status__string_offsets[(uint8_t)(status_code >> 24)]; return o ? wuffs_base__status__string_data + o : "unknown status"; } diff --git a/cmd/wuffs-c/internal/cgen/base/base-private.h b/cmd/wuffs-c/internal/cgen/base/base-private.h index 53efd0f5..70dd26ed 100644 --- a/cmd/wuffs-c/internal/cgen/base/base-private.h +++ b/cmd/wuffs-c/internal/cgen/base/base-private.h @@ -56,9 +56,9 @@ static inline void wuffs_base__ignore_check_wuffs_version_status( case n:; #define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \ - if (status < 0) { \ + if (status.code < 0) { \ goto exit; \ - } else if (status == 0) { \ + } else if (status.code == 0) { \ goto ok; \ } \ coro_susp_point = n; \ diff --git a/cmd/wuffs-c/internal/cgen/base/base-public.h b/cmd/wuffs-c/internal/cgen/base/base-public.h index 4628cc6b..33e6753d 100644 --- a/cmd/wuffs-c/internal/cgen/base/base-public.h +++ b/cmd/wuffs-c/internal/cgen/base/base-public.h @@ -108,27 +108,38 @@ typedef struct { // // Do not manipulate these bits directly; they are private implementation // details. Use methods such as wuffs_base__status__is_error instead. -typedef int32_t wuffs_base__status; +typedef struct { + int32_t code; +} 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, + }); +} + static inline bool // wuffs_base__status__is_error(wuffs_base__status s) { - return s < 0; + return s.code < 0; } static inline bool // wuffs_base__status__is_ok(wuffs_base__status s) { - return s == 0; + return s.code == 0; } static inline bool // wuffs_base__status__is_suspension(wuffs_base__status s) { - return s > 0; + return s.code > 0; } const char* // -wuffs_base__status__string(wuffs_base__status s); +wuffs_base__status__string(int32_t status_code); // -------- diff --git a/cmd/wuffs-c/internal/cgen/base/image-public.h b/cmd/wuffs-c/internal/cgen/base/image-public.h index 0178a5cf..3b844cde 100644 --- a/cmd/wuffs-c/internal/cgen/base/image-public.h +++ b/cmd/wuffs-c/internal/cgen/base/image-public.h @@ -809,17 +809,18 @@ 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__ERROR_BAD_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER); } *b = ((wuffs_base__pixel_buffer){}); if (!pixcfg) { - return WUFFS_BASE__ERROR_BAD_ARGUMENT; + return WUFFS_BASE__MAKE_STATUS(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__ERROR_BAD_ARGUMENT_LENGTH_TOO_SHORT; + return WUFFS_BASE__MAKE_STATUS( + WUFFS_BASE__ERROR_BAD_ARGUMENT_LENGTH_TOO_SHORT); } b->private_impl.pixcfg = *pixcfg; wuffs_base__table_u8* tab = &b->private_impl.planes[0]; @@ -827,7 +828,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__STATUS_OK; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); } // 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 326c4d32..74cb79b5 100644 --- a/cmd/wuffs-c/internal/cgen/builtin.go +++ b/cmd/wuffs-c/internal/cgen/builtin.go @@ -350,11 +350,11 @@ func (g *gen) writeBuiltinStatus(b *buffer, recv *a.Expr, method t.ID, args []*a } switch method { case t.IDIsError: - b.writes(" < 0") + b.writes(".code < 0") case t.IDIsOK: - b.writes(" == 0") + b.writes(".code == 0") case t.IDIsSuspension: - b.writes(" > 0") + b.writes(".code > 0") default: return fmt.Errorf("cgen: internal error for writeBuiltinStatus") } @@ -430,7 +430,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__SUSPENSION_SHORT_READ; goto suspend; }") + "status = WUFFS_BASE__MAKE_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. @@ -491,7 +491,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__SUSPENSION_SHORT_READ; goto suspend; }\n") + b.writes("status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; }\n") b.printf("iop_a_src += %s;\n", scratchName) return nil } @@ -500,7 +500,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__SUSPENSION_SHORT_WRITE; goto suspend; }\n" + + "status = WUFFS_BASE__MAKE_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 8916cf2d..0503dac1 100644 --- a/cmd/wuffs-c/internal/cgen/cgen.go +++ b/cmd/wuffs-c/internal/cgen/cgen.go @@ -378,7 +378,7 @@ func (g *gen) genHeader(b *buffer) error { } b.writes("\n") - b.printf("const char* %sstatus__string(wuffs_base__status s);\n\n", g.pkgPrefix) + b.printf("const char* %sstatus__string(int32_t status_code);\n\n", g.pkgPrefix) b.writes("// ---------------- Public Consts\n\n") if err := g.forEachConst(b, pubOnly, (*gen).writeConst); err != nil { @@ -435,18 +435,18 @@ func (g *gen) genImpl(b *buffer) error { } } - b.printf("const char* %sstatus__string(wuffs_base__status s) {\n", g.pkgPrefix) + b.printf("const char* %sstatus__string(int32_t status_code) {\n", g.pkgPrefix) b.printf("uint16_t o;") - b.printf("switch (s & 0x%X) {\n", (1<> 24)];\n", g.pkgPrefix) + b.printf("o = %sstatus__string_offsets[(uint8_t)(status_code >> 24)];\n", g.pkgPrefix) b.printf("if (o) { return %sstatus__string_data + o; } break;\n", g.pkgPrefix) for _, u := range g.usesList { // TODO: is path.Base always correct? Should we check // validName(packageName)? useePkgName := path.Base(u) - b.printf("case wuffs_%s__packageid: return wuffs_%s__status__string(s);\n", useePkgName, useePkgName) + b.printf("case wuffs_%s__packageid: return wuffs_%s__status__string(status_code);\n", useePkgName, useePkgName) } b.printf("}\n") b.printf("return \"unknown status\";\n") @@ -923,17 +923,17 @@ func (g *gen) writeInitializerImpl(b *buffer, n *a.Struct) error { return err } b.writes("{\n") - b.writes("if (!self) { return WUFFS_BASE__ERROR_BAD_RECEIVER; }\n") + b.writes("if (!self) { return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER); }\n") b.writes("if (sizeof(*self) != sizeof_star_self) {\n") - b.writes("return WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER;\n") + b.writes("return WUFFS_BASE__MAKE_STATUS(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__ERROR_BAD_WUFFS_VERSION;\n") + b.writes("return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION);\n") b.writes("}\n") b.writes("if (self->private_impl.magic != 0) {\n") - b.writes("return WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE;\n") + b.writes("return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE);\n") b.writes("}\n") // Call any ctors on sub-structs. @@ -962,12 +962,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) { return z; }\n") + b.printf("if (z.code) { return z; }\n") b.printf("}\n") } b.writes("self->private_impl.magic = WUFFS_BASE__MAGIC;\n") - b.writes("return WUFFS_BASE__STATUS_OK;\n") + b.writes("return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);\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 6f36162d..e5676a8d 100644 --- a/cmd/wuffs-c/internal/cgen/data.go +++ b/cmd/wuffs-c/internal/cgen/data.go @@ -22,7 +22,8 @@ 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 int32_t wuffs_base__status;\n\n// !! INSERT wuffs_base__status names.\n\nstatic inline bool //\nwuffs_base__status__is_error(wuffs_base__status s) {\n return s < 0;\n}\n\nstatic inline bool //\nwuffs_base__status__is_ok(wuffs_base__status s) {\n return s == 0;\n}\n\nstatic inline bool //\nwuffs_base__status__is_suspension(wuffs_base__status s) {\n return s > 0;\n}\n\nconst char* //\nwuffs_base__status__string(wuffs_base__status s);\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} 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 });\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_base__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// 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" + "" + @@ -73,7 +74,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 < 0) { \\\n goto exit; \\\n } else if (status == 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.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" + "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" + @@ -108,8 +109,8 @@ const baseBasePrivateH = "" + "" const baseBaseImplC = "" + - "// Copyright 2018 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// !! INSERT base-public.h.\n\n#ifdef WUFFS_IMPLEMENTATION\n\n// !! INSERT base-private.h.\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE)\n\n// !! INSERT wuffs_base__status__string data.\n\nconst char* //\nwuffs_base__status__string(wuffs_base__status s) {\n uint16_t o = wuffs_base__status__string_offsets[(uint8_t)(s >> 24)];\n return o ? wuffs_base__status__string_data + o : \"unknown status\";\n}\n\n#endif " + - " // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__BASE)\n\n#endif // WUFFS_IMPLEMENTATION\n" + + "// Copyright 2018 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// !! INSERT base-public.h.\n\n#ifdef WUFFS_IMPLEMENTATION\n\n// !! INSERT base-private.h.\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE)\n\n// !! INSERT wuffs_base__status__string data.\n\nconst char* //\nwuffs_base__status__string(int32_t status_code) {\n uint16_t o = wuffs_base__status__string_offsets[(uint8_t)(status_code >> 24)];\n return o ? wuffs_base__status__string_data + o : \"unknown status\";\n}" + + "\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__BASE)\n\n#endif // WUFFS_IMPLEMENTATION\n" + "" const baseImagePublicH = "" + @@ -154,8 +155,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__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 WUFFS_BASE__STATUS_OK;\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_pa" + - "lette(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__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" + "" diff --git a/cmd/wuffs-c/internal/cgen/expr.go b/cmd/wuffs-c/internal/cgen/expr.go index 62a8f56e..7435525d 100644 --- a/cmd/wuffs-c/internal/cgen/expr.go +++ b/cmd/wuffs-c/internal/cgen/expr.go @@ -219,7 +219,7 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, depth u } status.name = strings.ToUpper(cName(z.String(), "WUFFS_BASE__")) } - b.writes(status.name) + b.printf("WUFFS_BASE__MAKE_STATUS(%s)", status.name) return nil } return fmt.Errorf("unrecognized token (0x%X) for writeExprOther", n.Operator()) @@ -237,10 +237,16 @@ 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 := "" + opName, lhsExtra, rhsExtra := "", "", "" op := n.Operator() switch op { + case t.IDXBinaryEqEq, t.IDXBinaryNotEq: + if lhs := n.LHS().AsExpr(); lhs.MType().IsStatus() { + lhsExtra = ".code" + rhsExtra = ".code" + } + case t.IDXBinaryTildeSatPlus, t.IDXBinaryTildeSatMinus: uBits := uintBits(n.MType().QID()) if uBits == 0 { @@ -255,8 +261,9 @@ 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) + } - default: + if opName == "" { opName = cOpName(op) if opName == "" { return fmt.Errorf("unrecognized operator %q", op.AmbiguousForm().Str(g.tm)) @@ -267,10 +274,12 @@ 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(lhsExtra) b.writes(opName) if err := g.writeExpr(b, n.RHS().AsExpr(), rp, depth); err != nil { return err } + b.writes(rhsExtra) b.writeb(')') return nil } diff --git a/cmd/wuffs-c/internal/cgen/func.go b/cmd/wuffs-c/internal/cgen/func.go index f8d1aa8b..44273bd4 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__ERROR_BAD_RECEIVER") + b.writes("WUFFS_BASE__MAKE_STATUS(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__ERROR_CHECK_WUFFS_VERSION_MISSING; }") + "self->private_impl.status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING); }") - b.writes("if (self->private_impl.status < 0) { return ") + b.writes("if (self->private_impl.status.code < 0) { 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__STATUS_OK;\n") + b.printf("wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK);\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__ERROR_BAD_ARGUMENT;\n") + b.writes("self->private_impl.status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_ARGUMENT);\n") } - b.writes("return WUFFS_BASE__ERROR_BAD_ARGUMENT;\n\n") + b.writes("return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_ARGUMENT);\n\n") } else if !n.Receiver().IsZero() { // TODO: unused code path?? - b.writes("self->private_impl.status = WUFFS_BASE__ERROR_BAD_ARGUMENT; return;") + b.writes("self->private_impl.status = WUFFS_BASE__MAKE_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 d036f96e..3fc8e214 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__STATUS_OK") + b.writes("WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK)") } else { retKeyword = retExpr.Operator() // TODO: check that retExpr has no call-suspendibles. @@ -332,8 +332,8 @@ 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 == 0) { goto ok; } else if (status > 0) { " + - "status = WUFFS_BASE__ERROR_CANNOT_RETURN_A_SUSPENSION; } goto exit;") + 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;") } return nil } @@ -528,7 +528,7 @@ func (g *gen) writeCallSuspendibles(b *buffer, n *a.Expr, depth uint32) error { } if n.Operator() != t.IDTry { - b.writes("if (status) { goto suspend; }\n") + b.writes("if (status.code) { goto suspend; }\n") } return nil } @@ -571,7 +571,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__SUSPENSION_SHORT_READ; goto suspend; }", + "status = WUFFS_BASE__MAKE_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 025f2688..6b608f66 100644 --- a/doc/changelog.md +++ b/doc/changelog.md @@ -34,6 +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 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 8c2e8f52..98c4e46e 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) { - fprintf(stderr, "%s\n", wuffs_crc32__status__string(z)); + if (z.code) { + fprintf(stderr, "%s\n", wuffs_crc32__status__string(z.code)); return 1; } diff --git a/example/gifplayer/gifplayer.c b/example/gifplayer/gifplayer.c index f6d18cbc..3adb296f 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) { - return wuffs_gif__status__string(z); + if (z.code) { + return wuffs_gif__status__string(z.code); } 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) { - return wuffs_gif__status__string(z); + if (z.code) { + return wuffs_gif__status__string(z.code); } 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) { - return wuffs_gif__status__string(z); + if (z.code) { + return wuffs_gif__status__string(z.code); } 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) { - if (z == WUFFS_BASE__SUSPENSION_END_OF_DATA) { + if (z.code) { + if (z.code == WUFFS_BASE__SUSPENSION_END_OF_DATA) { break; } - return wuffs_gif__status__string(z); + return wuffs_gif__status__string(z.code); } 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) { - if (z == WUFFS_BASE__SUSPENSION_END_OF_DATA) { + if (z.code) { + if (z.code == WUFFS_BASE__SUSPENSION_END_OF_DATA) { break; } - return wuffs_gif__status__string(z); + return wuffs_gif__status__string(z.code); } compose(&pb, wuffs_base__frame_config__bounds(&fc)); diff --git a/example/library/library.c b/example/library/library.c index 2bb4f388..d87e1b84 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) { - return wuffs_deflate__status__string(z); + if (z.code) { + return wuffs_deflate__status__string(z.code); } z = wuffs_deflate__decoder__decode(&dec, dst_writer, src_reader); - if (z) { - return wuffs_deflate__status__string(z); + if (z.code) { + return wuffs_deflate__status__string(z.code); } ignore_return_value(write(1, dst.ptr, dst.wi)); return NULL; diff --git a/example/zcat/zcat.c b/example/zcat/zcat.c index 5d28a2e5..4c4d2912 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) { - return wuffs_gzip__status__string(z); + if (z.code) { + return wuffs_gzip__status__string(z.code); } wuffs_base__io_buffer src = @@ -112,16 +112,16 @@ static const char* decode() { ignore_return_value(write(stdout_fd, dst_buffer, dst.wi)); } - if (z == WUFFS_BASE__STATUS_OK) { + if (z.code == WUFFS_BASE__STATUS_OK) { return NULL; } - if (z == WUFFS_BASE__SUSPENSION_SHORT_READ) { + if (z.code == WUFFS_BASE__SUSPENSION_SHORT_READ) { break; } - if (z == WUFFS_BASE__SUSPENSION_SHORT_WRITE) { + if (z.code == WUFFS_BASE__SUSPENSION_SHORT_WRITE) { continue; } - return wuffs_gzip__status__string(z); + return wuffs_gzip__status__string(z.code); } wuffs_base__io_buffer__compact(&src); diff --git a/fuzz/c/std/gif_fuzzer.c b/fuzz/c/std/gif_fuzzer.c index 9d9bf760..e41ed1c9 100644 --- a/fuzz/c/std/gif_fuzzer.c +++ b/fuzz/c/std/gif_fuzzer.c @@ -56,14 +56,14 @@ 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) { - return wuffs_gif__status__string(z); + if (z.code) { + return wuffs_gif__status__string(z.code); } wuffs_base__image_config ic = ((wuffs_base__image_config){}); z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader); - if (z) { - ret = wuffs_gif__status__string(z); + if (z.code) { + ret = wuffs_gif__status__string(z.code); goto exit; } if (!wuffs_base__image_config__is_valid(&ic)) { @@ -87,8 +87,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) { - ret = wuffs_gif__status__string(z); + if (z.code) { + ret = wuffs_gif__status__string(z.code); goto exit; } @@ -96,11 +96,11 @@ 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) { - if ((z == WUFFS_BASE__SUSPENSION_END_OF_DATA) && seen_ok) { - z = WUFFS_BASE__STATUS_OK; + if (z.code) { + if ((z.code == WUFFS_BASE__SUSPENSION_END_OF_DATA) && seen_ok) { + z.code = WUFFS_BASE__STATUS_OK; } - ret = wuffs_gif__status__string(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 43a563b4..ba16cb5a 100644 --- a/fuzz/c/std/zlib_fuzzer.c +++ b/fuzz/c/std/zlib_fuzzer.c @@ -51,8 +51,8 @@ const char* fuzz(wuffs_base__io_reader src_reader, uint32_t hash) { wuffs_zlib__decoder dec = ((wuffs_zlib__decoder){}); wuffs_base__status z = wuffs_zlib__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); - if (z) { - return wuffs_zlib__status__string(z); + if (z.code) { + return wuffs_zlib__status__string(z.code); } // Ignore the checksum for 99.99%-ish of all input. When fuzzers generate @@ -68,8 +68,8 @@ 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 != WUFFS_BASE__SUSPENSION_SHORT_WRITE) { - ret = wuffs_zlib__status__string(z); + if (z.code != WUFFS_BASE__SUSPENSION_SHORT_WRITE) { + ret = wuffs_zlib__status__string(z.code); break; } if (dst.wi == 0) { diff --git a/lang/ast/ast.go b/lang/ast/ast.go index cb783136..9286c868 100644 --- a/lang/ast/ast.go +++ b/lang/ast/ast.go @@ -725,6 +725,10 @@ func (n *TypeExpr) IsRefined() bool { return n.id0 == 0 && n.id1 == t.IDBase && n.id2.IsNumType() && (n.lhs != nil || n.mhs != nil) } +func (n *TypeExpr) IsStatus() bool { + return n.id0 == 0 && n.id1 == t.IDBase && n.id2 == t.IDStatus +} + func (n *TypeExpr) IsArrayType() bool { return n.id0 == t.IDArray } diff --git a/release/c/wuffs-unsupported-snapshot.h b/release/c/wuffs-unsupported-snapshot.h index 94fd2865..5c2bf172 100644 --- a/release/c/wuffs-unsupported-snapshot.h +++ b/release/c/wuffs-unsupported-snapshot.h @@ -132,7 +132,9 @@ typedef struct { // // Do not manipulate these bits directly; they are private implementation // details. Use methods such as wuffs_base__status__is_error instead. -typedef int32_t wuffs_base__status; +typedef struct { + int32_t code; +} wuffs_base__status; #define WUFFS_BASE__STATUS_OK 0 // 0x00000000 #define WUFFS_BASE__ERROR_BAD_WUFFS_VERSION -16777216 // 0xFF000000 @@ -149,23 +151,32 @@ typedef int32_t wuffs_base__status; #define WUFFS_BASE__SUSPENSION_SHORT_READ 33554432 // 0x02000000 #define WUFFS_BASE__SUSPENSION_SHORT_WRITE 50331648 // 0x03000000 +// 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, + }); +} + static inline bool // wuffs_base__status__is_error(wuffs_base__status s) { - return s < 0; + return s.code < 0; } static inline bool // wuffs_base__status__is_ok(wuffs_base__status s) { - return s == 0; + return s.code == 0; } static inline bool // wuffs_base__status__is_suspension(wuffs_base__status s) { - return s > 0; + return s.code > 0; } const char* // -wuffs_base__status__string(wuffs_base__status s); +wuffs_base__status__string(int32_t status_code); // -------- @@ -1909,17 +1920,18 @@ 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__ERROR_BAD_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER); } *b = ((wuffs_base__pixel_buffer){}); if (!pixcfg) { - return WUFFS_BASE__ERROR_BAD_ARGUMENT; + return WUFFS_BASE__MAKE_STATUS(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__ERROR_BAD_ARGUMENT_LENGTH_TOO_SHORT; + return WUFFS_BASE__MAKE_STATUS( + WUFFS_BASE__ERROR_BAD_ARGUMENT_LENGTH_TOO_SHORT); } b->private_impl.pixcfg = *pixcfg; wuffs_base__table_u8* tab = &b->private_impl.planes[0]; @@ -1927,7 +1939,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__STATUS_OK; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); } // The palette argument is ignored unless its length is exactly 1024. @@ -2038,7 +2050,7 @@ extern "C" { #define wuffs_adler32__packageid 681002 // 0x000A642A -const char* wuffs_adler32__status__string(wuffs_base__status s); +const char* wuffs_adler32__status__string(int32_t status_code); // ---------------- Public Consts @@ -2121,7 +2133,7 @@ extern "C" { #define wuffs_crc32__packageid 810620 // 0x000C5E7C -const char* wuffs_crc32__status__string(wuffs_base__status s); +const char* wuffs_crc32__status__string(int32_t status_code); // ---------------- Public Consts @@ -2234,7 +2246,7 @@ extern "C" { #define WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS \ -1140002155 // 0xBC0CF295 -const char* wuffs_deflate__status__string(wuffs_base__status s); +const char* wuffs_deflate__status__string(int32_t status_code); // ---------------- Public Consts @@ -2387,7 +2399,7 @@ extern "C" { #define WUFFS_LZW__ERROR_BAD_CODE -15460440 // 0xFF1417A8 #define WUFFS_LZW__ERROR_CYCLICAL_PREFIX_CHAIN -32237656 // 0xFE1417A8 -const char* wuffs_lzw__status__string(wuffs_base__status s); +const char* wuffs_lzw__status__string(int32_t status_code); // ---------------- Public Consts @@ -2507,7 +2519,7 @@ extern "C" { #define WUFFS_GIF__ERROR_INTERNAL_ERROR_INCONSISTENT_RI_WI \ -1072724602 // 0xC00F8586 -const char* wuffs_gif__status__string(wuffs_base__status s); +const char* wuffs_gif__status__string(int32_t status_code); // ---------------- Public Consts @@ -2768,7 +2780,7 @@ extern "C" { #define WUFFS_GZIP__ERROR_BAD_ENCODING_FLAGS -49289737 // 0xFD0FE5F7 #define WUFFS_GZIP__ERROR_BAD_HEADER -66066953 // 0xFC0FE5F7 -const char* wuffs_gzip__status__string(wuffs_base__status s); +const char* wuffs_gzip__status__string(int32_t status_code); // ---------------- Public Consts @@ -2891,7 +2903,7 @@ extern "C" { #define WUFFS_ZLIB__ERROR_TODO_UNSUPPORTED_PRESET_DICTIONARY \ -1071677575 // 0xC01F7F79 -const char* wuffs_zlib__status__string(wuffs_base__status s); +const char* wuffs_zlib__status__string(int32_t status_code); // ---------------- Public Consts @@ -3038,9 +3050,9 @@ static inline void wuffs_base__ignore_check_wuffs_version_status( case n:; #define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \ - if (status < 0) { \ + if (status.code < 0) { \ goto exit; \ - } else if (status == 0) { \ + } else if (status.code == 0) { \ goto ok; \ } \ coro_susp_point = n; \ @@ -3771,8 +3783,8 @@ static const uint16_t wuffs_base__status__string_offsets[] = { }; const char* // -wuffs_base__status__string(wuffs_base__status s) { - uint16_t o = wuffs_base__status__string_offsets[(uint8_t)(s >> 24)]; +wuffs_base__status__string(int32_t status_code) { + uint16_t o = wuffs_base__status__string_offsets[(uint8_t)(status_code >> 24)]; return o ? wuffs_base__status__string_data + o : "unknown status"; } @@ -3819,13 +3831,13 @@ static const uint16_t wuffs_adler32__status__string_offsets[] = { 0x0000, 0x0000, 0x0000, 0x0000, }; -const char* wuffs_adler32__status__string(wuffs_base__status s) { +const char* wuffs_adler32__status__string(int32_t status_code) { uint16_t o; - switch (s & 0x1FFFFF) { + switch (status_code & 0x1FFFFF) { case 0: - return wuffs_base__status__string(s); + return wuffs_base__status__string(status_code); case wuffs_adler32__packageid: - o = wuffs_adler32__status__string_offsets[(uint8_t)(s >> 24)]; + o = wuffs_adler32__status__string_offsets[(uint8_t)(status_code >> 24)]; if (o) { return wuffs_adler32__status__string_data + o; } @@ -3847,20 +3859,21 @@ wuffs_adler32__hasher__check_wuffs_version(wuffs_adler32__hasher* self, size_t sizeof_star_self, uint64_t wuffs_version) { if (!self) { - return WUFFS_BASE__ERROR_BAD_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER); } if (sizeof(*self) != sizeof_star_self) { - return WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER); } if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) || (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) { - return WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION); } if (self->private_impl.magic != 0) { - return WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; + return WUFFS_BASE__MAKE_STATUS( + WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE); } self->private_impl.magic = WUFFS_BASE__MAGIC; - return WUFFS_BASE__STATUS_OK; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); } // ---------------- Function Implementations @@ -3874,9 +3887,10 @@ wuffs_adler32__hasher__update(wuffs_adler32__hasher* self, return 0; } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; + self->private_impl.status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING); } - if (self->private_impl.status < 0) { + if (self->private_impl.status.code < 0) { return 0; } @@ -3986,13 +4000,13 @@ static const uint16_t wuffs_crc32__status__string_offsets[] = { 0x0000, 0x0000, 0x0000, 0x0000, }; -const char* wuffs_crc32__status__string(wuffs_base__status s) { +const char* wuffs_crc32__status__string(int32_t status_code) { uint16_t o; - switch (s & 0x1FFFFF) { + switch (status_code & 0x1FFFFF) { case 0: - return wuffs_base__status__string(s); + return wuffs_base__status__string(status_code); case wuffs_crc32__packageid: - o = wuffs_crc32__status__string_offsets[(uint8_t)(s >> 24)]; + o = wuffs_crc32__status__string_offsets[(uint8_t)(status_code >> 24)]; if (o) { return wuffs_crc32__status__string_data + o; } @@ -4377,20 +4391,21 @@ 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__ERROR_BAD_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER); } if (sizeof(*self) != sizeof_star_self) { - return WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER); } if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) || (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) { - return WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION); } if (self->private_impl.magic != 0) { - return WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; + return WUFFS_BASE__MAKE_STATUS( + WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE); } self->private_impl.magic = WUFFS_BASE__MAGIC; - return WUFFS_BASE__STATUS_OK; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); } // ---------------- Function Implementations @@ -4404,9 +4419,10 @@ 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__ERROR_CHECK_WUFFS_VERSION_MISSING; + self->private_impl.status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING); } - if (self->private_impl.status < 0) { + if (self->private_impl.status.code < 0) { return 0; } @@ -4647,13 +4663,13 @@ static const uint16_t wuffs_deflate__status__string_offsets[] = { 0x0219, 0x0245, 0x026C, 0x0299, }; -const char* wuffs_deflate__status__string(wuffs_base__status s) { +const char* wuffs_deflate__status__string(int32_t status_code) { uint16_t o; - switch (s & 0x1FFFFF) { + switch (status_code & 0x1FFFFF) { case 0: - return wuffs_base__status__string(s); + return wuffs_base__status__string(status_code); case wuffs_deflate__packageid: - o = wuffs_deflate__status__string_offsets[(uint8_t)(s >> 24)]; + o = wuffs_deflate__status__string_offsets[(uint8_t)(status_code >> 24)]; if (o) { return wuffs_deflate__status__string_data + o; } @@ -4750,20 +4766,21 @@ wuffs_deflate__decoder__check_wuffs_version(wuffs_deflate__decoder* self, size_t sizeof_star_self, uint64_t wuffs_version) { if (!self) { - return WUFFS_BASE__ERROR_BAD_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER); } if (sizeof(*self) != sizeof_star_self) { - return WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER); } if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) || (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) { - return WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION); } if (self->private_impl.magic != 0) { - return WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; + return WUFFS_BASE__MAKE_STATUS( + WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE); } self->private_impl.magic = WUFFS_BASE__MAGIC; - return WUFFS_BASE__STATUS_OK; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); } // ---------------- Function Implementations @@ -4775,15 +4792,16 @@ 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__ERROR_BAD_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER); } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; + self->private_impl.status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING); } - if (self->private_impl.status < 0) { + if (self->private_impl.status.code < 0) { return self->private_impl.status; } - wuffs_base__status status = WUFFS_BASE__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); wuffs_base__status v_z; wuffs_base__slice_u8 v_written; @@ -4834,12 +4852,13 @@ wuffs_deflate__decoder__decode(wuffs_deflate__decoder* self, } v_z = t_0; } - if (!(v_z > 0)) { + if (!(v_z.code > 0)) { status = v_z; - if (status == 0) { + if (status.code == 0) { goto ok; - } else if (status > 0) { - status = WUFFS_BASE__ERROR_CANNOT_RETURN_A_SUSPENSION; + } else if (status.code > 0) { + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_BASE__ERROR_CANNOT_RETURN_A_SUSPENSION); } goto exit; } @@ -4912,7 +4931,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__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint32_t v_final; uint32_t v_type; @@ -4950,7 +4969,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_0 = *iop_a_src++; @@ -4973,14 +4992,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) { + if (status.code) { 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) { + if (status.code) { goto suspend; } } else if (v_type == 2) { @@ -4992,11 +5011,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) { + if (status.code) { goto suspend; } } else { - status = WUFFS_DEFLATE__ERROR_BAD_BLOCK; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_BLOCK); goto exit; } self->private_impl.f_end_of_block = false; @@ -5008,7 +5027,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) { + if (status.code) { goto suspend; } if (self->private_impl.f_end_of_block) { @@ -5022,14 +5041,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) { + if (status.code) { goto suspend; } if (self->private_impl.f_end_of_block) { goto label_0_continue; } - status = - WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_END_OF_BLOCK; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_END_OF_BLOCK); goto exit; } @@ -5060,7 +5079,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__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint32_t v_length; uint32_t v_n_copied; @@ -5111,7 +5130,8 @@ 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_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS); goto exit; } self->private_impl.f_n_bits = 0; @@ -5127,7 +5147,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint64_t* scratch = @@ -5148,7 +5168,8 @@ wuffs_deflate__decoder__decode_uncompressed(wuffs_deflate__decoder* self, } if ((((v_length) & ((1 << (16)) - 1)) + ((v_length) >> (32 - (16)))) != 65535) { - status = WUFFS_DEFLATE__ERROR_INCONSISTENT_STORED_BLOCK_LENGTH; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INCONSISTENT_STORED_BLOCK_LENGTH); goto exit; } v_length = ((v_length) & ((1 << (16)) - 1)); @@ -5156,15 +5177,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__STATUS_OK; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); goto ok; } v_length -= v_n_copied; if (((uint64_t)(io1_a_dst - iop_a_dst)) == 0) { - status = WUFFS_BASE__SUSPENSION_SHORT_WRITE; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE); WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3); } else { - status = WUFFS_BASE__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(4); } } @@ -5197,7 +5218,7 @@ exit: static wuffs_base__status // wuffs_deflate__decoder__init_fixed_huffman(wuffs_deflate__decoder* self) { - wuffs_base__status status = WUFFS_BASE__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint32_t v_i; @@ -5233,12 +5254,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) { + if (status.code) { goto suspend; } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); status = wuffs_deflate__decoder__init_huff(self, 1, 288, 320, 0); - if (status) { + if (status.code) { goto suspend; } @@ -5263,7 +5284,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__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint32_t v_bits; uint32_t v_n_bits; @@ -5322,7 +5343,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_0 = *iop_a_src++; @@ -5332,13 +5353,15 @@ 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_DEFLATE__ERROR_BAD_LITERAL_LENGTH_CODE_COUNT; + status = WUFFS_BASE__MAKE_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_DEFLATE__ERROR_BAD_DISTANCE_CODE_COUNT; + status = + WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_DISTANCE_CODE_COUNT); goto exit; } v_bits >>= 5; @@ -5351,7 +5374,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_1 = *iop_a_src++; @@ -5371,7 +5394,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) { + if (status.code) { goto suspend; } v_mask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1); @@ -5390,7 +5413,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_2 = *iop_a_src++; @@ -5400,8 +5423,8 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self, } label_1_break:; if ((v_table_entry >> 24) != 128) { - status = - WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } v_table_entry = ((v_table_entry >> 8) & 255); @@ -5416,7 +5439,8 @@ 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_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_REPETITION; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_REPETITION); goto exit; } v_rep_symbol = self->private_impl.f_code_lengths[(v_i - 1)]; @@ -5430,15 +5454,15 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self, v_rep_symbol = 0; v_rep_count = 11; } else { - status = - WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_3 = *iop_a_src++; @@ -5451,7 +5475,8 @@ 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_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_COUNT; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_COUNT); goto exit; } self->private_impl.f_code_lengths[v_i] = v_rep_symbol; @@ -5460,22 +5485,24 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self, } } if (v_i != (v_n_lit + v_n_dist)) { - status = WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_COUNT; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_LENGTH_COUNT); goto exit; } if (self->private_impl.f_code_lengths[256] == 0) { - status = WUFFS_DEFLATE__ERROR_MISSING_END_OF_BLOCK_CODE; + status = WUFFS_BASE__MAKE_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) { + if (status.code) { 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) { + if (status.code) { goto suspend; } self->private_impl.f_bits = v_bits; @@ -5522,7 +5549,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__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint16_t v_counts[16]; uint32_t v_i; @@ -5554,35 +5581,37 @@ 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_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_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_DEFLATE__ERROR_NO_HUFFMAN_CODES; + status = WUFFS_BASE__MAKE_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_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_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_DEFLATE__ERROR_BAD_HUFFMAN_CODE_OVER_SUBSCRIBED; + status = WUFFS_BASE__MAKE_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_DEFLATE__ERROR_BAD_HUFFMAN_CODE_UNDER_SUBSCRIBED; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE_UNDER_SUBSCRIBED); goto exit; } memset(v_offsets, 0, sizeof(v_offsets)); @@ -5592,30 +5621,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_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_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_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_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_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_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_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } v_symbols[v_offsets[self->private_impl.f_code_lengths[v_i]]] = @@ -5630,7 +5659,8 @@ wuffs_deflate__decoder__init_huff(wuffs_deflate__decoder* self, goto label_0_break; } if (v_min_cl >= 9) { - status = WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_MINIMUM_CODE_LENGTH; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_MINIMUM_CODE_LENGTH); goto exit; } v_min_cl += 1; @@ -5642,7 +5672,7 @@ label_0_break:; goto label_1_break; } if (v_max_cl <= 1) { - status = WUFFS_DEFLATE__ERROR_NO_HUFFMAN_CODES; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_NO_HUFFMAN_CODES); goto exit; } v_max_cl -= 1; @@ -5656,13 +5686,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_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } if ((a_n_codes0 + ((uint32_t)(v_symbols[0]))) >= 320) { - status = - WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } v_initial_high_bits = 512; @@ -5679,8 +5709,8 @@ label_1_break:; v_value = 0; while (true) { if ((a_n_codes0 + ((uint32_t)(v_symbols[v_i]))) >= 320) { - status = - WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } v_cl = ((uint32_t)(self->private_impl.f_code_lengths[( @@ -5688,8 +5718,8 @@ label_1_break:; if (v_cl > v_prev_cl) { v_code <<= (v_cl - v_prev_cl); if (v_code >= 32768) { - status = - WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } } @@ -5710,8 +5740,8 @@ label_1_break:; } v_remaining -= ((uint32_t)(v_counts[v_j])); if (v_remaining > 1073741824) { - status = - WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } v_remaining <<= 1; @@ -5719,16 +5749,16 @@ label_1_break:; } label_2_break:; if ((v_j <= 9) || (15 < v_j)) { - status = - WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_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_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } v_next_top = (v_top + (((uint32_t)(1)) << v_tmp)); @@ -5740,8 +5770,8 @@ label_1_break:; } } if ((v_key >= 512) || (v_counts[v_prev_cl] <= 0)) { - status = - WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } v_counts[v_prev_cl] -= 1; @@ -5761,8 +5791,8 @@ label_1_break:; v_value = (wuffs_deflate__dcode_magic_numbers[(v_symbol & 31)] | v_cl); } } else { - status = - WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } v_high_bits = v_initial_high_bits; @@ -5770,8 +5800,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_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } self->private_impl @@ -5784,8 +5814,8 @@ label_1_break:; } v_code += 1; if (v_code >= 32768) { - status = - WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } } @@ -5801,7 +5831,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__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint32_t v_bits; uint32_t v_n_bits; @@ -5853,7 +5883,8 @@ 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_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS); goto exit; } v_bits = self->private_impl.f_bits; @@ -5900,8 +5931,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_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } v_table_entry = self->private_impl @@ -5919,23 +5950,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_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } else if ((v_table_entry >> 27) != 0) { - status = WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE); goto exit; } else { - status = - WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } } else if ((v_table_entry >> 27) != 0) { - status = WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE); goto exit; } else { - status = - WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } v_length = ((v_table_entry >> 8) & 32767); @@ -5958,8 +5989,8 @@ label_0_continue:; } else { } if (v_length > 258) { - status = - WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } if (v_n_bits < 15) { @@ -5988,8 +6019,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_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } v_table_entry = self->private_impl @@ -6001,11 +6032,11 @@ label_0_continue:; } if ((v_table_entry >> 24) != 64) { if ((v_table_entry >> 24) == 8) { - status = WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE); goto exit; } - status = - WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } v_dist_minus_1 = ((v_table_entry >> 8) & 32767); @@ -6047,8 +6078,8 @@ label_0_continue:; v_length -= v_hdist; v_hlen = v_hdist; if (v_length > 258) { - status = - WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } } else { @@ -6056,7 +6087,7 @@ label_0_continue:; v_length = 0; } if (self->private_impl.f_history_index < v_hdist) { - status = WUFFS_DEFLATE__ERROR_BAD_DISTANCE; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_DISTANCE); goto exit; } v_hdist = (self->private_impl.f_history_index - v_hdist); @@ -6088,7 +6119,8 @@ label_0_continue:; .len = (size_t)(iop_a_dst - a_dst.private_impl.bounds[0]), }) .len))) { - status = WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_DISTANCE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_DISTANCE); goto exit; } } @@ -6105,7 +6137,8 @@ label_0_break:; if (iop_a_src > io0_a_src) { (iop_a_src--, wuffs_base__return_empty_struct()); } else { - status = WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_I_O; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_I_O); goto exit; } } @@ -6113,7 +6146,8 @@ 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_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS); goto exit; } goto exit; @@ -6134,7 +6168,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__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint32_t v_bits; uint32_t v_n_bits; @@ -6208,7 +6242,8 @@ 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_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS); goto exit; } v_bits = self->private_impl.f_bits; @@ -6230,7 +6265,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_0 = *iop_a_src++; @@ -6242,7 +6277,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__SUSPENSION_SHORT_WRITE; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE); goto suspend; } *iop_a_dst++ = ((uint8_t)(((v_table_entry >> 8) & 255))); @@ -6256,8 +6291,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_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } v_table_entry = @@ -6272,7 +6307,8 @@ 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__SUSPENSION_SHORT_READ; + status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_1 = *iop_a_src++; @@ -6284,7 +6320,8 @@ 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__SUSPENSION_SHORT_WRITE; + status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE); goto suspend; } *iop_a_dst++ = ((uint8_t)(((v_table_entry >> 8) & 255))); @@ -6294,23 +6331,24 @@ 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_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } else if ((v_table_entry >> 27) != 0) { - status = WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE; + status = + WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE); goto exit; } else { - status = - WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } } else if ((v_table_entry >> 27) != 0) { - status = WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE); goto exit; } else { - status = - WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } v_length = ((v_table_entry >> 8) & 32767); @@ -6320,7 +6358,8 @@ 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__SUSPENSION_SHORT_READ; + status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_2 = *iop_a_src++; @@ -6345,7 +6384,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_3 = *iop_a_src++; @@ -6359,8 +6398,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_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } v_table_entry = @@ -6375,7 +6414,8 @@ 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__SUSPENSION_SHORT_READ; + status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_4 = *iop_a_src++; @@ -6387,11 +6427,12 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self, } if ((v_table_entry >> 24) != 64) { if ((v_table_entry >> 24) == 8) { - status = WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE; + status = + WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_HUFFMAN_CODE); goto exit; } - status = - WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE); goto exit; } v_dist_minus_1 = ((v_table_entry >> 8) & 32767); @@ -6401,7 +6442,8 @@ 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__SUSPENSION_SHORT_READ; + status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_5 = *iop_a_src++; @@ -6441,7 +6483,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_DEFLATE__ERROR_BAD_DISTANCE; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_DEFLATE__ERROR_BAD_DISTANCE); goto exit; } v_hdist = (self->private_impl.f_history_index - v_hdist); @@ -6463,7 +6505,8 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self, goto label_5_break; } } - status = WUFFS_BASE__SUSPENSION_SHORT_WRITE; + status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE); WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9); } label_5_break:; @@ -6481,7 +6524,8 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self, } v_hlen -= v_n_copied; v_hdist += v_n_copied; - status = WUFFS_BASE__SUSPENSION_SHORT_WRITE; + status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE); WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(10); } label_6_break:; @@ -6498,7 +6542,7 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self, goto label_7_break; } v_length -= v_n_copied; - status = WUFFS_BASE__SUSPENSION_SHORT_WRITE; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE); WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(11); } label_7_break:; @@ -6508,7 +6552,8 @@ 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_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_DEFLATE__ERROR_INTERNAL_ERROR_INCONSISTENT_N_BITS); goto exit; } @@ -6607,19 +6652,19 @@ static const uint16_t wuffs_gif__status__string_offsets[] = { 0x0074, 0x0084, 0x009D, 0x00B6, }; -const char* wuffs_gif__status__string(wuffs_base__status s) { +const char* wuffs_gif__status__string(int32_t status_code) { uint16_t o; - switch (s & 0x1FFFFF) { + switch (status_code & 0x1FFFFF) { case 0: - return wuffs_base__status__string(s); + return wuffs_base__status__string(status_code); case wuffs_gif__packageid: - o = wuffs_gif__status__string_offsets[(uint8_t)(s >> 24)]; + o = wuffs_gif__status__string_offsets[(uint8_t)(status_code >> 24)]; if (o) { return wuffs_gif__status__string_data + o; } break; case wuffs_lzw__packageid: - return wuffs_lzw__status__string(s); + return wuffs_lzw__status__string(status_code); } return "unknown status"; } @@ -6698,28 +6743,29 @@ wuffs_gif__decoder__check_wuffs_version(wuffs_gif__decoder* self, size_t sizeof_star_self, uint64_t wuffs_version) { if (!self) { - return WUFFS_BASE__ERROR_BAD_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER); } if (sizeof(*self) != sizeof_star_self) { - return WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER); } if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) || (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) { - return WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION); } if (self->private_impl.magic != 0) { - return WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; + return WUFFS_BASE__MAKE_STATUS( + 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) { + if (z.code) { return z; } } self->private_impl.magic = WUFFS_BASE__MAGIC; - return WUFFS_BASE__STATUS_OK; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); } // ---------------- Function Implementations @@ -6731,15 +6777,16 @@ 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__ERROR_BAD_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER); } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; + self->private_impl.status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING); } - if (self->private_impl.status < 0) { + if (self->private_impl.status.code < 0) { return self->private_impl.status; } - wuffs_base__status status = WUFFS_BASE__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint32_t v_num_loops; bool v_ffio; @@ -6756,22 +6803,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__ERROR_INVALID_CALL_SEQUENCE; + status = WUFFS_BASE__MAKE_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) { + if (status.code) { goto suspend; } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); status = wuffs_gif__decoder__decode_lsd(self, a_src); - if (status) { + if (status.code) { goto suspend; } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); status = wuffs_gif__decoder__decode_up_to_id_part1(self, a_src); - if (status) { + if (status.code) { goto suspend; } v_num_loops = 1; @@ -6818,9 +6865,10 @@ 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__ERROR_CHECK_WUFFS_VERSION_MISSING; + self->private_impl.status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING); } - if (self->private_impl.status < 0) { + if (self->private_impl.status.code < 0) { return 0; } @@ -6835,9 +6883,10 @@ 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__ERROR_CHECK_WUFFS_VERSION_MISSING; + self->private_impl.status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING); } - if (self->private_impl.status < 0) { + if (self->private_impl.status.code < 0) { return 0; } @@ -6852,9 +6901,10 @@ 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__ERROR_CHECK_WUFFS_VERSION_MISSING; + self->private_impl.status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING); } - if (self->private_impl.status < 0) { + if (self->private_impl.status.code < 0) { return ((wuffs_base__range_ii_u64){}); } @@ -6869,15 +6919,16 @@ 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__ERROR_BAD_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER); } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; + self->private_impl.status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING); } - if (self->private_impl.status < 0) { + if (self->private_impl.status.code < 0) { return self->private_impl.status; } - wuffs_base__status status = WUFFS_BASE__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint32_t coro_susp_point = self->private_impl.c_decode_frame_config[0].coro_susp_point; @@ -6891,27 +6942,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) { + if (status.code) { 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) { + if (status.code) { goto suspend; } } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); status = wuffs_gif__decoder__decode_up_to_id_part1(self, a_src); - if (status) { + if (status.code) { goto suspend; } } } if (self->private_impl.f_end_of_data) { while (true) { - status = WUFFS_BASE__SUSPENSION_END_OF_DATA; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_END_OF_DATA); WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(4); } } @@ -6963,7 +7014,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__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint8_t v_lw; @@ -6994,7 +7045,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_0 = *iop_a_src++; @@ -7008,7 +7059,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) { + if (status.code) { goto suspend; } self->private_impl.f_seen_graphic_control = false; @@ -7050,19 +7101,21 @@ 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__ERROR_BAD_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER); } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; + self->private_impl.status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING); } - if (self->private_impl.status < 0) { + if (self->private_impl.status.code < 0) { return self->private_impl.status; } if (!a_dst) { - self->private_impl.status = WUFFS_BASE__ERROR_BAD_ARGUMENT; - return WUFFS_BASE__ERROR_BAD_ARGUMENT; + self->private_impl.status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_ARGUMENT); + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_ARGUMENT); } - wuffs_base__status status = WUFFS_BASE__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint32_t coro_susp_point = self->private_impl.c_decode_frame[0].coro_susp_point; @@ -7075,13 +7128,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) { + if (status.code) { goto suspend; } } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); status = wuffs_gif__decoder__decode_id_part1(self, a_dst, a_src); - if (status) { + if (status.code) { goto suspend; } self->private_impl.f_seen_graphic_control = false; @@ -7114,7 +7167,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__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint8_t v_block_type; @@ -7147,7 +7200,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_0 = *iop_a_src++; @@ -7162,7 +7215,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) { + if (status.code) { goto suspend; } } else if (v_block_type == 44) { @@ -7174,7 +7227,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) { + if (status.code) { goto suspend; } goto label_0_break; @@ -7182,7 +7235,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_GIF__ERROR_BAD_BLOCK; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_GIF__ERROR_BAD_BLOCK); goto exit; } } @@ -7214,7 +7267,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__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint8_t v_c[6]; uint32_t v_i; @@ -7251,7 +7304,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_0 = *iop_a_src++; @@ -7261,7 +7314,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_GIF__ERROR_BAD_HEADER; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_GIF__ERROR_BAD_HEADER); goto exit; } @@ -7291,7 +7344,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__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint8_t v_flags; uint32_t v_num_palette_entries; @@ -7337,7 +7390,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint64_t* scratch = &self->private_impl.c_decode_lsd[0].scratch; @@ -7366,7 +7419,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint64_t* scratch = &self->private_impl.c_decode_lsd[0].scratch; @@ -7387,7 +7440,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_4 = *iop_a_src++; @@ -7400,7 +7453,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } iop_a_src += self->private_impl.c_decode_lsd[0].scratch; @@ -7419,7 +7472,8 @@ 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__SUSPENSION_SHORT_READ; + status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint64_t* scratch = &self->private_impl.c_decode_lsd[0].scratch; @@ -7486,7 +7540,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__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint8_t v_label; @@ -7518,7 +7572,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_0 = *iop_a_src++; @@ -7533,10 +7587,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) { + if (status.code) { goto suspend; } - status = WUFFS_BASE__STATUS_OK; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); goto ok; } else if (v_label == 255) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); @@ -7547,10 +7601,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) { + if (status.code) { goto suspend; } - status = WUFFS_BASE__STATUS_OK; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); goto ok; } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); @@ -7561,7 +7615,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) { + if (status.code) { goto suspend; } @@ -7590,7 +7644,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__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint8_t v_block_size; @@ -7623,14 +7677,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_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__STATUS_OK; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); goto ok; } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); @@ -7640,7 +7694,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } iop_a_src += self->private_impl.c_skip_blocks[0].scratch; @@ -7671,7 +7725,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__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint8_t v_c; uint8_t v_block_size; @@ -7712,14 +7766,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_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__STATUS_OK; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); goto ok; } if (v_block_size != 11) { @@ -7730,7 +7784,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } iop_a_src += self->private_impl.c_decode_ae[0].scratch; @@ -7743,7 +7797,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_1 = *iop_a_src++; @@ -7761,7 +7815,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_2 = *iop_a_src++; @@ -7775,7 +7829,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } iop_a_src += self->private_impl.c_decode_ae[0].scratch; @@ -7784,7 +7838,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_3 = *iop_a_src++; @@ -7798,7 +7852,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } iop_a_src += self->private_impl.c_decode_ae[0].scratch; @@ -7815,7 +7869,8 @@ 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__SUSPENSION_SHORT_READ; + status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint64_t* scratch = &self->private_impl.c_decode_ae[0].scratch; @@ -7849,7 +7904,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) { + if (status.code) { goto suspend; } @@ -7881,7 +7936,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__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint8_t v_c; uint8_t v_flags; @@ -7912,26 +7967,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_GIF__ERROR_BAD_GRAPHIC_CONTROL; + status = WUFFS_BASE__MAKE_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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_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_GIF__ERROR_BAD_GRAPHIC_CONTROL; + status = WUFFS_BASE__MAKE_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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_1 = *iop_a_src++; @@ -7957,7 +8012,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint64_t* scratch = &self->private_impl.c_decode_gc[0].scratch; @@ -7978,7 +8033,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_4 = *iop_a_src++; @@ -7987,14 +8042,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_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_GIF__ERROR_BAD_GRAPHIC_CONTROL; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_GIF__ERROR_BAD_GRAPHIC_CONTROL); goto exit; } self->private_impl.f_seen_graphic_control = true; @@ -8025,7 +8080,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__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint8_t v_flags; uint32_t v_num_palette_entries; @@ -8072,7 +8127,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint64_t* scratch = &self->private_impl.c_decode_id_part0[0].scratch; @@ -8101,7 +8156,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint64_t* scratch = &self->private_impl.c_decode_id_part0[0].scratch; @@ -8130,7 +8185,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint64_t* scratch = &self->private_impl.c_decode_id_part0[0].scratch; @@ -8160,7 +8215,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint64_t* scratch = &self->private_impl.c_decode_id_part0[0].scratch; @@ -8190,7 +8245,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_8 = *iop_a_src++; @@ -8219,7 +8274,8 @@ 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__SUSPENSION_SHORT_READ; + status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint64_t* scratch = @@ -8288,7 +8344,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__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint8_t v_lw; uint64_t v_block_size; @@ -8367,14 +8423,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_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_GIF__ERROR_BAD_LITERAL_WIDTH; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_GIF__ERROR_BAD_LITERAL_WIDTH); goto exit; } wuffs_lzw__decoder__set_literal_width(&self->private_impl.f_lzw, @@ -8384,7 +8440,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_1 = *iop_a_src++; @@ -8441,19 +8497,26 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, io1_v_w = o_0_io1_v_w; a_src = o_0_a_src; } - if ((v_z == 0) || (v_z == WUFFS_BASE__SUSPENSION_SHORT_WRITE)) { + if ((v_z.code == 0) || + (v_z.code == + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE) + .code)) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); status = wuffs_gif__decoder__copy_to_image_buffer(self, a_dst); - if (status) { + if (status.code) { goto suspend; } - if (v_z == WUFFS_BASE__SUSPENSION_SHORT_WRITE) { + if (v_z.code == + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE) + .code) { 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 == WUFFS_BASE__SUSPENSION_SHORT_READ)) { + if ((v_block_size == 0) && + (v_z.code == + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ).code)) { goto label_1_break; } status = v_z; @@ -8466,7 +8529,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) { + if (status.code) { goto suspend; } } @@ -8498,7 +8561,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__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); wuffs_base__slice_u8 v_dst; wuffs_base__slice_u8 v_src; @@ -8520,7 +8583,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_GIF__ERROR_TOO_MUCH_PIXEL_DATA; + status = WUFFS_BASE__MAKE_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); @@ -8565,7 +8628,8 @@ label_0_continue:; goto label_0_break; } else if (self->private_impl.f_uncompressed_wi < self->private_impl.f_uncompressed_ri) { - status = WUFFS_GIF__ERROR_INTERNAL_ERROR_INCONSISTENT_RI_WI; + status = WUFFS_BASE__MAKE_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); @@ -8593,7 +8657,8 @@ label_0_continue:; } if (self->private_impl.f_uncompressed_ri != self->private_impl.f_uncompressed_wi) { - status = WUFFS_GIF__ERROR_INTERNAL_ERROR_INCONSISTENT_RI_WI; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_GIF__ERROR_INTERNAL_ERROR_INCONSISTENT_RI_WI); goto exit; } goto label_0_break; @@ -8655,21 +8720,21 @@ static const uint16_t wuffs_gzip__status__string_offsets[] = { 0x0001, 0x0012, 0x002B, 0x0048, }; -const char* wuffs_gzip__status__string(wuffs_base__status s) { +const char* wuffs_gzip__status__string(int32_t status_code) { uint16_t o; - switch (s & 0x1FFFFF) { + switch (status_code & 0x1FFFFF) { case 0: - return wuffs_base__status__string(s); + return wuffs_base__status__string(status_code); case wuffs_gzip__packageid: - o = wuffs_gzip__status__string_offsets[(uint8_t)(s >> 24)]; + o = wuffs_gzip__status__string_offsets[(uint8_t)(status_code >> 24)]; if (o) { return wuffs_gzip__status__string_data + o; } break; case wuffs_crc32__packageid: - return wuffs_crc32__status__string(s); + return wuffs_crc32__status__string(status_code); case wuffs_deflate__packageid: - return wuffs_deflate__status__string(s); + return wuffs_deflate__status__string(status_code); } return "unknown status"; } @@ -8687,23 +8752,24 @@ wuffs_gzip__decoder__check_wuffs_version(wuffs_gzip__decoder* self, size_t sizeof_star_self, uint64_t wuffs_version) { if (!self) { - return WUFFS_BASE__ERROR_BAD_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER); } if (sizeof(*self) != sizeof_star_self) { - return WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER); } if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) || (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) { - return WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION); } if (self->private_impl.magic != 0) { - return WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; + return WUFFS_BASE__MAKE_STATUS( + 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) { + if (z.code) { return z; } } @@ -8711,12 +8777,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) { + if (z.code) { return z; } } self->private_impl.magic = WUFFS_BASE__MAGIC; - return WUFFS_BASE__STATUS_OK; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); } // ---------------- Function Implementations @@ -8729,9 +8795,10 @@ 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__ERROR_CHECK_WUFFS_VERSION_MISSING; + self->private_impl.status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING); } - if (self->private_impl.status < 0) { + if (self->private_impl.status.code < 0) { return; } @@ -8745,15 +8812,16 @@ 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__ERROR_BAD_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER); } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; + self->private_impl.status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING); } - if (self->private_impl.status < 0) { + if (self->private_impl.status.code < 0) { return self->private_impl.status; } - wuffs_base__status status = WUFFS_BASE__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint8_t v_c; uint8_t v_flags; @@ -8817,46 +8885,47 @@ 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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_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_GZIP__ERROR_BAD_HEADER; + status = WUFFS_BASE__MAKE_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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_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_GZIP__ERROR_BAD_HEADER; + status = WUFFS_BASE__MAKE_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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_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_GZIP__ERROR_BAD_COMPRESSION_METHOD; + status = + WUFFS_BASE__MAKE_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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_3 = *iop_a_src++; @@ -8869,7 +8938,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } iop_a_src += self->private_impl.c_decode[0].scratch; @@ -8885,7 +8954,8 @@ 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__SUSPENSION_SHORT_READ; + status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint64_t* scratch = &self->private_impl.c_decode[0].scratch; @@ -8910,7 +8980,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } iop_a_src += self->private_impl.c_decode[0].scratch; @@ -8920,7 +8990,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_6 = *iop_a_src++; @@ -8937,7 +9007,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_7 = *iop_a_src++; @@ -8957,13 +9027,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_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_GZIP__ERROR_BAD_ENCODING_FLAGS; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_GZIP__ERROR_BAD_ENCODING_FLAGS); goto exit; } v_checksum_got = 0; @@ -9003,7 +9073,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, .len)) & 4294967295))); } - if (v_z == 0) { + if (v_z.code == 0) { goto label_2_break; } status = v_z; @@ -9021,7 +9091,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint64_t* scratch = &self->private_impl.c_decode[0].scratch; @@ -9050,7 +9120,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint64_t* scratch = &self->private_impl.c_decode[0].scratch; @@ -9071,7 +9141,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_GZIP__ERROR_BAD_CHECKSUM; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_GZIP__ERROR_BAD_CHECKSUM); goto exit; } @@ -9152,13 +9222,13 @@ static const uint16_t wuffs_lzw__status__string_offsets[] = { 0x0000, 0x0000, 0x0001, 0x001C, }; -const char* wuffs_lzw__status__string(wuffs_base__status s) { +const char* wuffs_lzw__status__string(int32_t status_code) { uint16_t o; - switch (s & 0x1FFFFF) { + switch (status_code & 0x1FFFFF) { case 0: - return wuffs_base__status__string(s); + return wuffs_base__status__string(status_code); case wuffs_lzw__packageid: - o = wuffs_lzw__status__string_offsets[(uint8_t)(s >> 24)]; + o = wuffs_lzw__status__string_offsets[(uint8_t)(status_code >> 24)]; if (o) { return wuffs_lzw__status__string_data + o; } @@ -9180,20 +9250,21 @@ wuffs_lzw__decoder__check_wuffs_version(wuffs_lzw__decoder* self, size_t sizeof_star_self, uint64_t wuffs_version) { if (!self) { - return WUFFS_BASE__ERROR_BAD_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER); } if (sizeof(*self) != sizeof_star_self) { - return WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER); } if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) || (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) { - return WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION); } if (self->private_impl.magic != 0) { - return WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; + return WUFFS_BASE__MAKE_STATUS( + WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE); } self->private_impl.magic = WUFFS_BASE__MAGIC; - return WUFFS_BASE__STATUS_OK; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); } // ---------------- Function Implementations @@ -9206,13 +9277,15 @@ 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__ERROR_CHECK_WUFFS_VERSION_MISSING; + self->private_impl.status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING); } - if (self->private_impl.status < 0) { + if (self->private_impl.status.code < 0) { return; } if (a_lw < 2 || a_lw > 8) { - self->private_impl.status = WUFFS_BASE__ERROR_BAD_ARGUMENT; + self->private_impl.status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_ARGUMENT); return; } @@ -9226,15 +9299,16 @@ 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__ERROR_BAD_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER); } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; + self->private_impl.status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING); } - if (self->private_impl.status < 0) { + if (self->private_impl.status.code < 0) { return self->private_impl.status; } - wuffs_base__status status = WUFFS_BASE__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint32_t v_literal_width; uint32_t v_clear_code; @@ -9321,7 +9395,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint8_t t_0 = *iop_a_src++; @@ -9335,7 +9409,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__SUSPENSION_SHORT_WRITE; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE); goto suspend; } *iop_a_dst++ = ((uint8_t)(v_code)); @@ -9351,7 +9425,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__STATUS_OK; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); goto ok; } v_save_code = v_end_code; @@ -9367,7 +9441,8 @@ 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_LZW__ERROR_CYCLICAL_PREFIX_CHAIN; + status = + WUFFS_BASE__MAKE_STATUS(WUFFS_LZW__ERROR_CYCLICAL_PREFIX_CHAIN); goto exit; } v_s -= 1; @@ -9388,7 +9463,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__SUSPENSION_SHORT_WRITE; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE); WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3); } label_0_break:; @@ -9403,7 +9478,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, v_prev_code = v_code; } } else { - status = WUFFS_LZW__ERROR_BAD_CODE; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_LZW__ERROR_BAD_CODE); goto exit; } } @@ -9497,21 +9572,21 @@ static const uint16_t wuffs_zlib__status__string_offsets[] = { 0x002B, 0x0042, 0x0064, 0x0081, }; -const char* wuffs_zlib__status__string(wuffs_base__status s) { +const char* wuffs_zlib__status__string(int32_t status_code) { uint16_t o; - switch (s & 0x1FFFFF) { + switch (status_code & 0x1FFFFF) { case 0: - return wuffs_base__status__string(s); + return wuffs_base__status__string(status_code); case wuffs_zlib__packageid: - o = wuffs_zlib__status__string_offsets[(uint8_t)(s >> 24)]; + o = wuffs_zlib__status__string_offsets[(uint8_t)(status_code >> 24)]; if (o) { return wuffs_zlib__status__string_data + o; } break; case wuffs_adler32__packageid: - return wuffs_adler32__status__string(s); + return wuffs_adler32__status__string(status_code); case wuffs_deflate__packageid: - return wuffs_deflate__status__string(s); + return wuffs_deflate__status__string(status_code); } return "unknown status"; } @@ -9529,23 +9604,24 @@ wuffs_zlib__decoder__check_wuffs_version(wuffs_zlib__decoder* self, size_t sizeof_star_self, uint64_t wuffs_version) { if (!self) { - return WUFFS_BASE__ERROR_BAD_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER); } if (sizeof(*self) != sizeof_star_self) { - return WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER); } if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) || (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) { - return WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION); } if (self->private_impl.magic != 0) { - return WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; + return WUFFS_BASE__MAKE_STATUS( + 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) { + if (z.code) { return z; } } @@ -9553,12 +9629,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) { + if (z.code) { return z; } } self->private_impl.magic = WUFFS_BASE__MAGIC; - return WUFFS_BASE__STATUS_OK; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); } // ---------------- Function Implementations @@ -9571,9 +9647,10 @@ 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__ERROR_CHECK_WUFFS_VERSION_MISSING; + self->private_impl.status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING); } - if (self->private_impl.status < 0) { + if (self->private_impl.status.code < 0) { return; } @@ -9587,15 +9664,16 @@ 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__ERROR_BAD_RECEIVER; + return WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_RECEIVER); } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; + self->private_impl.status = + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING); } - if (self->private_impl.status < 0) { + if (self->private_impl.status.code < 0) { return self->private_impl.status; } - wuffs_base__status status = WUFFS_BASE__STATUS_OK; + wuffs_base__status status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK); uint16_t v_x; uint32_t v_checksum_got; @@ -9658,7 +9736,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint64_t* scratch = &self->private_impl.c_decode[0].scratch; @@ -9677,19 +9755,22 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, v_x = t_1; } if (((v_x >> 8) & 15) != 8) { - status = WUFFS_ZLIB__ERROR_BAD_COMPRESSION_METHOD; + status = + WUFFS_BASE__MAKE_STATUS(WUFFS_ZLIB__ERROR_BAD_COMPRESSION_METHOD); goto exit; } if ((v_x >> 12) > 7) { - status = WUFFS_ZLIB__ERROR_BAD_COMPRESSION_WINDOW_SIZE; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_ZLIB__ERROR_BAD_COMPRESSION_WINDOW_SIZE); goto exit; } if ((v_x & 32) != 0) { - status = WUFFS_ZLIB__ERROR_TODO_UNSUPPORTED_PRESET_DICTIONARY; + status = WUFFS_BASE__MAKE_STATUS( + WUFFS_ZLIB__ERROR_TODO_UNSUPPORTED_PRESET_DICTIONARY); goto exit; } if ((v_x % 31) != 0) { - status = WUFFS_ZLIB__ERROR_BAD_PARITY_CHECK; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_ZLIB__ERROR_BAD_PARITY_CHECK); goto exit; } v_checksum_got = 0; @@ -9720,7 +9801,7 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, .len = (size_t)(iop_a_dst - a_dst.private_impl.bounds[0]), })); } - if (v_z == 0) { + if (v_z.code == 0) { goto label_0_break; } status = v_z; @@ -9738,7 +9819,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__SUSPENSION_SHORT_READ; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_READ); goto suspend; } uint64_t* scratch = &self->private_impl.c_decode[0].scratch; @@ -9758,7 +9839,7 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, } if (!self->private_impl.f_ignore_checksum && (v_checksum_got != v_checksum_want)) { - status = WUFFS_ZLIB__ERROR_BAD_CHECKSUM; + status = WUFFS_BASE__MAKE_STATUS(WUFFS_ZLIB__ERROR_BAD_CHECKSUM); goto exit; } diff --git a/test/c/std/adler32.c b/test/c/std/adler32.c index 070c690a..89b71024 100644 --- a/test/c/std/adler32.c +++ b/test/c/std/adler32.c @@ -128,9 +128,9 @@ 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) { - FAIL("check_wuffs_version: %" PRIi32 " (%s)", z, - wuffs_adler32__status__string(z)); + if (z.code) { + FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code, + wuffs_adler32__status__string(z.code)); return; } @@ -193,9 +193,9 @@ 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) { - FAIL("check_wuffs_version: %" PRIi32 " (%s)", z, - wuffs_adler32__status__string(z)); + if (z.code) { + FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code, + wuffs_adler32__status__string(z.code)); return; } uint32_t got = @@ -226,8 +226,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) { - return wuffs_adler32__status__string(z); + if (z.code) { + return wuffs_adler32__status__string(z.code); } 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 a3122feb..d76ec56b 100644 --- a/test/c/std/crc32.c +++ b/test/c/std/crc32.c @@ -128,9 +128,9 @@ 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) { - FAIL("check_wuffs_version: %" PRIi32 " (%s)", z, - wuffs_crc32__status__string(z)); + if (z.code) { + FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code, + wuffs_crc32__status__string(z.code)); return; } @@ -193,9 +193,9 @@ 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) { - FAIL("check_wuffs_version: %" PRIi32 " (%s)", z, - wuffs_crc32__status__string(z)); + if (z.code) { + FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code, + wuffs_crc32__status__string(z.code)); return; } uint32_t got = wuffs_crc32__ieee_hasher__update( @@ -226,8 +226,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) { - return wuffs_crc32__status__string(z); + if (z.code) { + return wuffs_crc32__status__string(z.code); } 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 bd454526..6c741912 100644 --- a/test/c/std/deflate.c +++ b/test/c/std/deflate.c @@ -133,9 +133,9 @@ 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) { - FAIL("check_wuffs_version: %" PRIi32 " (%s)", z, - wuffs_deflate__status__string(z)); + if (z.code) { + FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code, + wuffs_deflate__status__string(z.code)); return false; } @@ -152,14 +152,14 @@ 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 == WUFFS_BASE__STATUS_OK) { + if (z.code == WUFFS_BASE__STATUS_OK) { return NULL; } - if ((wlimit && (z == WUFFS_BASE__SUSPENSION_SHORT_WRITE)) || - (rlimit && (z == WUFFS_BASE__SUSPENSION_SHORT_READ))) { + if ((wlimit && (z.code == WUFFS_BASE__SUSPENSION_SHORT_WRITE)) || + (rlimit && (z.code == WUFFS_BASE__SUSPENSION_SHORT_READ))) { continue; } - return wuffs_deflate__status__string(z); + return wuffs_deflate__status__string(z.code); } } @@ -248,9 +248,9 @@ 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) { - FAIL("check_wuffs_version: %" PRIi32 " (%s)", z, - wuffs_deflate__status__string(z)); + if (z.code) { + FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code, + wuffs_deflate__status__string(z.code)); return; } @@ -266,16 +266,17 @@ void test_wuffs_deflate_decode_split_src() { wuffs_base__status z1 = wuffs_deflate__decoder__decode(&dec, dst_writer, src_reader); - if (z0 != WUFFS_BASE__SUSPENSION_SHORT_READ) { - FAIL("i=%d: z0: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", i, z0, - wuffs_deflate__status__string(z0), WUFFS_BASE__SUSPENSION_SHORT_READ, + 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)); return; } - if (z1 != WUFFS_BASE__STATUS_OK) { - FAIL("i=%d: z1: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", i, z1, - wuffs_deflate__status__string(z1), WUFFS_BASE__STATUS_OK, + 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)); return; } @@ -295,7 +296,7 @@ bool do_test_wuffs_deflate_history(int i, wuffs_deflate__decoder* dec, uint32_t starting_history_index, uint64_t limit, - wuffs_base__status want_z) { + int32_t want_z_code) { src->ri = gt->src_offset0; src->wi = gt->src_offset1; got->ri = 0; @@ -310,11 +311,12 @@ 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 != want_z) { + if (got_z.code != want_z_code) { FAIL("i=%d: starting_history_index=0x%04" PRIX32 ": decode status: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", - i, starting_history_index, got_z, wuffs_deflate__status__string(got_z), - want_z, wuffs_deflate__status__string(want_z)); + i, starting_history_index, got_z.code, + wuffs_deflate__status__string(got_z.code), want_z_code, + wuffs_deflate__status__string(want_z_code)); return false; } return true; @@ -344,9 +346,9 @@ 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) { - FAIL("check_wuffs_version: %" PRIi32 " (%s)", z, - wuffs_deflate__status__string(z)); + if (z.code) { + FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code, + wuffs_deflate__status__string(z.code)); return; } @@ -416,9 +418,9 @@ 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) { - FAIL("check_wuffs_version: %" PRIi32 " (%s)", z, - wuffs_deflate__status__string(z)); + if (z.code) { + FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code, + wuffs_deflate__status__string(z.code)); return; } @@ -505,9 +507,9 @@ 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) { - FAIL("check_wuffs_version: %" PRIi32 " (%s)", z, - wuffs_deflate__status__string(z)); + if (z.code) { + FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code, + wuffs_deflate__status__string(z.code)); return; } @@ -529,8 +531,9 @@ 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) { - FAIL("init_huff: %" PRIi32 " (%s)", z, wuffs_deflate__status__string(z)); + if (z.code) { + FAIL("init_huff: %" PRIi32 " (%s)", z.code, + wuffs_deflate__status__string(z.code)); return; } diff --git a/test/c/std/gif.c b/test/c/std/gif.c index 30b3b7c6..22931579 100644 --- a/test/c/std/gif.c +++ b/test/c/std/gif.c @@ -74,9 +74,10 @@ 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 != WUFFS_BASE__ERROR_BAD_RECEIVER) { - FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", z, - wuffs_gif__status__string(z), WUFFS_BASE__ERROR_BAD_RECEIVER, + 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)); } } @@ -86,9 +87,10 @@ 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 != WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER) { - FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", z, - wuffs_gif__status__string(z), WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER, + 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)); return; } @@ -99,9 +101,10 @@ 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 != WUFFS_BASE__ERROR_BAD_WUFFS_VERSION) { - FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", z, - wuffs_gif__status__string(z), WUFFS_BASE__ERROR_BAD_WUFFS_VERSION, + 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)); return; } @@ -114,9 +117,9 @@ 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 != WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING) { - FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", z, - wuffs_gif__status__string(z), + 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)); @@ -125,19 +128,23 @@ void test_basic_check_wuffs_version_not_called() { void test_basic_status_is_error() { CHECK_FOCUS(__func__); - if (wuffs_base__status__is_error(WUFFS_BASE__STATUS_OK)) { + if (wuffs_base__status__is_error( + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__STATUS_OK))) { FAIL("is_error(OK) returned true"); return; } - if (!wuffs_base__status__is_error(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION)) { + if (!wuffs_base__status__is_error( + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION))) { FAIL("is_error(BAD_WUFFS_VERSION) returned false"); return; } - if (wuffs_base__status__is_error(WUFFS_BASE__SUSPENSION_SHORT_WRITE)) { + if (wuffs_base__status__is_error( + WUFFS_BASE__MAKE_STATUS(WUFFS_BASE__SUSPENSION_SHORT_WRITE))) { FAIL("is_error(SHORT_WRITE) returned true"); return; } - if (!wuffs_base__status__is_error(WUFFS_GIF__ERROR_BAD_HEADER)) { + if (!wuffs_base__status__is_error( + WUFFS_BASE__MAKE_STATUS(WUFFS_GIF__ERROR_BAD_HEADER))) { FAIL("is_error(BAD_HEADER) returned false"); return; } @@ -196,9 +203,9 @@ 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) { - FAIL("check_wuffs_version: %" PRIi32 " (%s)", z, - wuffs_gif__status__string(z)); + if (z.code) { + FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code, + wuffs_gif__status__string(z.code)); return; } if (dec.private_impl.magic != WUFFS_BASE__MAGIC) { @@ -220,16 +227,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) { - return wuffs_gif__status__string(z); + if (z.code) { + return wuffs_gif__status__string(z.code); } 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) { - return wuffs_gif__status__string(z); + if (z.code) { + return wuffs_gif__status__string(z.code); } z = wuffs_base__pixel_buffer__set_from_slice( &pb, wuffs_base__image_config__pixel_config(&ic), @@ -237,23 +244,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) { - return wuffs_gif__status__string(z); + if (z.code) { + return wuffs_gif__status__string(z.code); } while (true) { z = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader); - if (z) { - if (z == WUFFS_BASE__SUSPENSION_END_OF_DATA) { + if (z.code) { + if (z.code == WUFFS_BASE__SUSPENSION_END_OF_DATA) { break; } - return wuffs_gif__status__string(z); + return wuffs_gif__status__string(z.code); } z = wuffs_gif__decoder__decode_frame(&dec, &pb, 0, 0, src_reader, ((wuffs_base__slice_u8){})); - if (z) { - return wuffs_gif__status__string(z); + if (z.code) { + return wuffs_gif__status__string(z.code); } const char* msg = copy_to_io_buffer_from_pixel_buffer( @@ -281,9 +288,9 @@ 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) { - FAIL("check_wuffs_version: %" PRIi32 " (%s)", z, - wuffs_gif__status__string(z)); + if (z.code) { + FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code, + wuffs_gif__status__string(z.code)); return false; } @@ -294,9 +301,9 @@ 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 != WUFFS_BASE__STATUS_OK) { - FAIL("decode_image_config: got %" PRIi32 " (%s)", z, - wuffs_gif__status__string(z)); + if (z.code != WUFFS_BASE__STATUS_OK) { + FAIL("decode_image_config: got %" PRIi32 " (%s)", z.code, + wuffs_gif__status__string(z.code)); return false; } if (wuffs_base__image_config__pixel_format(&ic) != @@ -333,8 +340,8 @@ bool do_test_wuffs_gif_decode(const char* filename, .ptr = global_pixel_buffer, .len = WUFFS_TESTLIB_ARRAY_SIZE(global_pixel_buffer), })); - if (z) { - FAIL("set_from_slice: %s", wuffs_gif__status__string(z)); + if (z.code) { + FAIL("set_from_slice: %s", wuffs_gif__status__string(z.code)); return false; } } @@ -351,12 +358,13 @@ 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 == WUFFS_BASE__STATUS_OK) { + if (z.code == WUFFS_BASE__STATUS_OK) { break; } - if (z != WUFFS_BASE__SUSPENSION_SHORT_READ) { + if (z.code != WUFFS_BASE__SUSPENSION_SHORT_READ) { FAIL("decode_frame_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", - z, wuffs_gif__status__string(z), WUFFS_BASE__SUSPENSION_SHORT_READ, + z.code, wuffs_gif__status__string(z.code), + WUFFS_BASE__SUSPENSION_SHORT_READ, wuffs_gif__status__string(WUFFS_BASE__SUSPENSION_SHORT_READ)); return false; } @@ -382,12 +390,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 == WUFFS_BASE__STATUS_OK) { + if (z.code == WUFFS_BASE__STATUS_OK) { break; } - if (z != WUFFS_BASE__SUSPENSION_SHORT_READ) { - FAIL("decode_frame: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", z, - wuffs_gif__status__string(z), WUFFS_BASE__SUSPENSION_SHORT_READ, + 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)); return false; } @@ -453,9 +461,10 @@ 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 != WUFFS_BASE__SUSPENSION_END_OF_DATA) { - FAIL("decode_frame: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", z, - wuffs_gif__status__string(z), WUFFS_BASE__SUSPENSION_END_OF_DATA, + 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)); return false; } @@ -481,26 +490,27 @@ 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) { - FAIL("check_wuffs_version: %" PRIi32 " (%s)", z, - wuffs_gif__status__string(z)); + if (z.code) { + FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code, + wuffs_gif__status__string(z.code)); 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 != WUFFS_BASE__STATUS_OK) { - FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", z, - wuffs_gif__status__string(z), WUFFS_BASE__STATUS_OK, + 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)); return; } z = wuffs_gif__decoder__decode_image_config(&dec, NULL, src_reader); - if (z != WUFFS_BASE__ERROR_INVALID_CALL_SEQUENCE) { - FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", z, - wuffs_gif__status__string(z), WUFFS_BASE__ERROR_INVALID_CALL_SEQUENCE, + 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)); return; } @@ -520,9 +530,9 @@ 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) { - FAIL("check_wuffs_version: %" PRIi32 " (%s)", z, - wuffs_gif__status__string(z)); + if (z.code) { + FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code, + wuffs_gif__status__string(z.code)); return false; } @@ -531,9 +541,9 @@ 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 != WUFFS_BASE__STATUS_OK) { - FAIL("decode_image_config: got %" PRIi32 " (%s)", z, - wuffs_gif__status__string(z)); + if (z.code != WUFFS_BASE__STATUS_OK) { + FAIL("decode_image_config: got %" PRIi32 " (%s)", z.code, + wuffs_gif__status__string(z.code)); return false; } @@ -548,8 +558,8 @@ bool do_test_wuffs_gif_decode_animated( .ptr = global_pixel_buffer, .len = WUFFS_TESTLIB_ARRAY_SIZE(global_pixel_buffer), })); - if (z) { - FAIL("set_from_slice: %s", wuffs_gif__status__string(z)); + if (z.code) { + FAIL("set_from_slice: %s", wuffs_gif__status__string(z.code)); return false; } @@ -557,17 +567,17 @@ 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 != WUFFS_BASE__STATUS_OK) { - FAIL("decode_frame_config #%" PRIu32 ": got %" PRIi32 " (%s)", i, z, - wuffs_gif__status__string(z)); + if (z.code != WUFFS_BASE__STATUS_OK) { + FAIL("decode_frame_config #%" PRIu32 ": got %" PRIi32 " (%s)", i, z.code, + wuffs_gif__status__string(z.code)); return false; } z = wuffs_gif__decoder__decode_frame(&dec, &pb, 0, 0, src_reader, ((wuffs_base__slice_u8){})); - if (z != WUFFS_BASE__STATUS_OK) { - FAIL("decode_frame #%" PRIu32 ": got %" PRIi32 " (%s)", i, z, - wuffs_gif__status__string(z)); + if (z.code != WUFFS_BASE__STATUS_OK) { + FAIL("decode_frame #%" PRIu32 ": got %" PRIi32 " (%s)", i, z.code, + wuffs_gif__status__string(z.code)); return false; } @@ -589,9 +599,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 != WUFFS_BASE__SUSPENSION_END_OF_DATA) { - FAIL("decode_frame: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", z, - wuffs_gif__status__string(z), WUFFS_BASE__SUSPENSION_END_OF_DATA, + 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)); return false; } @@ -646,16 +656,16 @@ 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) { - FAIL("check_wuffs_version: %" PRIi32 " (%s)", z, - wuffs_gif__status__string(z)); + if (z.code) { + FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code, + wuffs_gif__status__string(z.code)); 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) { - FAIL("decode_image_config: %s", wuffs_gif__status__string(z)); + if (z.code) { + FAIL("decode_image_config: %s", wuffs_gif__status__string(z.code)); return; } @@ -721,18 +731,18 @@ 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) { - FAIL("check_wuffs_version: %" PRIi32 " (%s)", z, - wuffs_gif__status__string(z)); + if (z.code) { + FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code, + wuffs_gif__status__string(z.code)); 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 != WUFFS_GIF__ERROR_BAD_HEADER) { - FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", z, - wuffs_gif__status__string(z), WUFFS_GIF__ERROR_BAD_HEADER, + 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)); return; } @@ -749,9 +759,9 @@ 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) { - FAIL("check_wuffs_version: %" PRIi32 " (%s)", z, - wuffs_gif__status__string(z)); + if (z.code) { + FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code, + wuffs_gif__status__string(z.code)); return false; } wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); @@ -760,8 +770,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 != WUFFS_BASE__STATUS_OK) { - FAIL("decode_image_config: %s", wuffs_gif__status__string(z)); + if (z.code != WUFFS_BASE__STATUS_OK) { + FAIL("decode_image_config: %s", wuffs_gif__status__string(z.code)); return false; } @@ -771,8 +781,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) { - FAIL("set_from_slice: %s", wuffs_gif__status__string(z)); + if (z.code) { + FAIL("set_from_slice: %s", wuffs_gif__status__string(z.code)); return false; } } @@ -794,7 +804,7 @@ bool do_test_wuffs_gif_num_decoded(bool frame_config) { break; } - wuffs_base__status z = 0; + wuffs_base__status z = ((wuffs_base__status){}); if (frame_config) { z = wuffs_gif__decoder__decode_frame_config(&dec, NULL, src_reader); } else { @@ -802,14 +812,14 @@ bool do_test_wuffs_gif_num_decoded(bool frame_config) { ((wuffs_base__slice_u8){})); } - if (z == WUFFS_BASE__STATUS_OK) { + if (z.code == WUFFS_BASE__STATUS_OK) { want++; continue; - } else if (z == WUFFS_BASE__SUSPENSION_END_OF_DATA) { + } else if (z.code == WUFFS_BASE__SUSPENSION_END_OF_DATA) { end_of_data = true; continue; } - FAIL("%s: %s", method, wuffs_gif__status__string(z)); + FAIL("%s: %s", method, wuffs_gif__status__string(z.code)); return false; } diff --git a/test/c/std/gzip.c b/test/c/std/gzip.c index fbd689f8..faa1751f 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) { - return wuffs_gzip__status__string(z); + if (z.code) { + return wuffs_gzip__status__string(z.code); } while (true) { @@ -105,14 +105,14 @@ 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 == WUFFS_BASE__STATUS_OK) { + if (z.code == WUFFS_BASE__STATUS_OK) { return NULL; } - if ((wlimit && (z == WUFFS_BASE__SUSPENSION_SHORT_WRITE)) || - (rlimit && (z == WUFFS_BASE__SUSPENSION_SHORT_READ))) { + if ((wlimit && (z.code == WUFFS_BASE__SUSPENSION_SHORT_WRITE)) || + (rlimit && (z.code == WUFFS_BASE__SUSPENSION_SHORT_READ))) { continue; } - return wuffs_gzip__status__string(z); + return wuffs_gzip__status__string(z.code); } } @@ -140,9 +140,9 @@ 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) { - FAIL("check_wuffs_version: %" PRIi32 " (%s)", z, - wuffs_gzip__status__string(z)); + if (z.code) { + FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code, + wuffs_gzip__status__string(z.code)); return false; } wuffs_gzip__decoder__set_ignore_checksum(&dec, ignore_checksum); @@ -155,7 +155,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); - wuffs_base__status want_z = 0; + int32_t want_z_code = 0; if (i == 0) { if (end_limit == 0) { continue; @@ -165,19 +165,19 @@ 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 = WUFFS_BASE__SUSPENSION_SHORT_READ; + want_z_code = WUFFS_BASE__SUSPENSION_SHORT_READ; } else { - want_z = (bad_checksum && !ignore_checksum) - ? WUFFS_GZIP__ERROR_BAD_CHECKSUM - : WUFFS_BASE__STATUS_OK; + want_z_code = (bad_checksum && !ignore_checksum) + ? WUFFS_GZIP__ERROR_BAD_CHECKSUM + : WUFFS_BASE__STATUS_OK; } wuffs_base__status got_z = wuffs_gzip__decoder__decode(&dec, got_writer, src_reader); - if (got_z != want_z) { + if (got_z.code != want_z_code) { FAIL("end_limit=%d: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", - end_limit, got_z, wuffs_gzip__status__string(got_z), want_z, - wuffs_gzip__status__string(want_z)); + end_limit, got_z.code, wuffs_gzip__status__string(got_z.code), + want_z_code, wuffs_gzip__status__string(want_z_code)); return false; } } diff --git a/test/c/std/lzw.c b/test/c/std/lzw.c index 744915c6..77584277 100644 --- a/test/c/std/lzw.c +++ b/test/c/std/lzw.c @@ -103,9 +103,9 @@ 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) { - FAIL("check_wuffs_version: %" PRIi32 " (%s)", z, - wuffs_lzw__status__string(z)); + if (z.code) { + FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code, + wuffs_lzw__status__string(z.code)); return false; } wuffs_lzw__decoder__set_literal_width(&dec, literal_width); @@ -124,18 +124,19 @@ 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 == WUFFS_BASE__STATUS_OK) { + if (z.code == WUFFS_BASE__STATUS_OK) { if (src.ri != src.wi) { FAIL("decode returned \"ok\" but src was not exhausted"); return false; } break; } - if ((z != WUFFS_BASE__SUSPENSION_SHORT_READ) && - (z != WUFFS_BASE__SUSPENSION_SHORT_WRITE)) { + 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, wuffs_lzw__status__string(z), WUFFS_BASE__SUSPENSION_SHORT_READ, + 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)); @@ -234,14 +235,15 @@ 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) { - FAIL("check_wuffs_version: %" PRIi32 " (%s)", z, - wuffs_lzw__status__string(z)); + if (z.code) { + FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code, + wuffs_lzw__status__string(z.code)); return false; } z = wuffs_lzw__decoder__decode(&dec, dst_writer, src_reader); - if (z) { - FAIL("decode: %" PRIi32 " (%s)", z, wuffs_lzw__status__string(z)); + if (z.code) { + FAIL("decode: %" PRIi32 " (%s)", z.code, + wuffs_lzw__status__string(z.code)); return false; } n_bytes += dst.wi; diff --git a/test/c/std/zlib.c b/test/c/std/zlib.c index 3ef2fff9..cabb5232 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) { - return wuffs_zlib__status__string(z); + if (z.code) { + return wuffs_zlib__status__string(z.code); } while (true) { @@ -105,14 +105,14 @@ 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 == WUFFS_BASE__STATUS_OK) { + if (z.code == WUFFS_BASE__STATUS_OK) { return NULL; } - if ((wlimit && (z == WUFFS_BASE__SUSPENSION_SHORT_WRITE)) || - (rlimit && (z == WUFFS_BASE__SUSPENSION_SHORT_READ))) { + if ((wlimit && (z.code == WUFFS_BASE__SUSPENSION_SHORT_WRITE)) || + (rlimit && (z.code == WUFFS_BASE__SUSPENSION_SHORT_READ))) { continue; } - return wuffs_zlib__status__string(z); + return wuffs_zlib__status__string(z.code); } } @@ -139,9 +139,9 @@ 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) { - FAIL("check_wuffs_version: %" PRIi32 " (%s)", z, - wuffs_zlib__status__string(z)); + if (z.code) { + FAIL("check_wuffs_version: %" PRIi32 " (%s)", z.code, + wuffs_zlib__status__string(z.code)); return false; } wuffs_zlib__decoder__set_ignore_checksum(&dec, ignore_checksum); @@ -154,7 +154,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); - wuffs_base__status want_z = 0; + int32_t want_z_code = 0; if (i == 0) { if (end_limit == 0) { continue; @@ -164,19 +164,19 @@ 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 = WUFFS_BASE__SUSPENSION_SHORT_READ; + want_z_code = WUFFS_BASE__SUSPENSION_SHORT_READ; } else { - want_z = (bad_checksum && !ignore_checksum) - ? WUFFS_ZLIB__ERROR_BAD_CHECKSUM - : WUFFS_BASE__STATUS_OK; + want_z_code = (bad_checksum && !ignore_checksum) + ? WUFFS_ZLIB__ERROR_BAD_CHECKSUM + : WUFFS_BASE__STATUS_OK; } wuffs_base__status got_z = wuffs_zlib__decoder__decode(&dec, got_writer, src_reader); - if (got_z != want_z) { + if (got_z.code != want_z_code) { FAIL("end_limit=%d: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", - end_limit, got_z, wuffs_zlib__status__string(got_z), want_z, - wuffs_zlib__status__string(want_z)); + end_limit, got_z.code, wuffs_zlib__status__string(got_z.code), + want_z_code, wuffs_zlib__status__string(want_z_code)); return false; } }