From fd43e777bc570440d197ead1ee2f8bddb4e01254 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sun, 5 Aug 2018 22:29:54 +1000 Subject: [PATCH] Have check_wuffs_version return a status code --- cmd/wuffs-c/internal/cgen/base/base-private.h | 3 + cmd/wuffs-c/internal/cgen/base/base-public.h | 7 + cmd/wuffs-c/internal/cgen/cgen.go | 33 +- cmd/wuffs-c/internal/cgen/data.go | 12 +- cmd/wuffs-c/internal/cgen/expr.go | 5 +- cmd/wuffs-c/internal/cgen/func.go | 2 +- example/crc32/crc32.cc | 6 +- example/gifplayer/gifplayer.c | 35 +- example/library/library.c | 13 +- example/zcat/zcat.c | 16 +- fuzz/c/std/gif_fuzzer.c | 29 +- fuzz/c/std/zlib_fuzzer.c | 13 +- lang/builtin/builtin.go | 2 +- release/c/wuffs-unsupported-snapshot.h | 401 +++++++++--------- test/c/std/adler32.c | 25 +- test/c/std/crc32.c | 25 +- test/c/std/deflate.c | 86 ++-- test/c/std/gif.c | 262 +++++++----- test/c/std/gzip.c | 42 +- test/c/std/lzw.c | 35 +- test/c/std/zlib.c | 42 +- 21 files changed, 628 insertions(+), 466 deletions(-) diff --git a/cmd/wuffs-c/internal/cgen/base/base-private.h b/cmd/wuffs-c/internal/cgen/base/base-private.h index 43fd2a55..53efd0f5 100644 --- a/cmd/wuffs-c/internal/cgen/base/base-private.h +++ b/cmd/wuffs-c/internal/cgen/base/base-private.h @@ -23,6 +23,9 @@ extern "C" { #define WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(x) (void)(x) +static inline void wuffs_base__ignore_check_wuffs_version_status( + wuffs_base__status z) {} + // WUFFS_BASE__MAGIC is a magic number to check that initializers are called. // It's not foolproof, given C doesn't automatically zero memory before use, // but it should catch 99.99% of cases. diff --git a/cmd/wuffs-c/internal/cgen/base/base-public.h b/cmd/wuffs-c/internal/cgen/base/base-public.h index 86640512..4628cc6b 100644 --- a/cmd/wuffs-c/internal/cgen/base/base-public.h +++ b/cmd/wuffs-c/internal/cgen/base/base-public.h @@ -59,6 +59,13 @@ extern "C" { #define WUFFS_BASE__MAYBE_STATIC #endif +// Clang also defines "__GNUC__". +#if defined(__GNUC__) +#define WUFFS_BASE__WARN_UNUSED_RESULT __attribute__((warn_unused_result)) +#else +#define WUFFS_BASE__WARN_UNUSED_RESULT +#endif + // wuffs_base__empty_struct is used when a Wuffs function returns an empty // struct. In C, if a function f returns void, you can't say "x = f()", but in // Wuffs, if a function g returns empty, you can say "y = g()". diff --git a/cmd/wuffs-c/internal/cgen/cgen.go b/cmd/wuffs-c/internal/cgen/cgen.go index bc51c4a4..c968b15d 100644 --- a/cmd/wuffs-c/internal/cgen/cgen.go +++ b/cmd/wuffs-c/internal/cgen/cgen.go @@ -706,7 +706,10 @@ func (g *gen) writeStruct(b *buffer, n *a.Struct) error { func (g *gen) writeCppPrototypes(b *buffer, n *a.Struct) error { b.writes("#ifdef __cplusplus\n") - b.writes("inline void check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version);\n") + // The empty // comment makes clang-format place the function name + // at the start of a line. + b.writes("inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT //\n" + + "check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version);\n") structID := n.QID()[1] for _, file := range g.files { @@ -747,10 +750,10 @@ func (g *gen) writeCppImpls(b *buffer) error { structName := structID.Str(g.tm) // The empty // comment makes clang-format place the function name // at the start of a line. - b.writes("inline void //\n") + b.writes("inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT //\n") b.printf("%s%s::check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version) {\n", g.pkgPrefix, structName) - b.printf("%s%s__check_wuffs_version(this, sizeof_star_self, wuffs_version);\n", + b.printf("return %s%s__check_wuffs_version(this, sizeof_star_self, wuffs_version);\n", g.pkgPrefix, structName) b.printf("}\n\n") @@ -865,7 +868,8 @@ func (g *gen) writeInitializerSignature(b *buffer, n *a.Struct, public bool) err b.printf("//\n") b.printf("// Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version.\n") } - b.printf("void %s%s__check_wuffs_version(%s%s *self, size_t sizeof_star_self, uint64_t wuffs_version)", + b.printf("wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT //\n"+ + "%s%s__check_wuffs_version(%s%s *self, size_t sizeof_star_self, uint64_t wuffs_version)", g.pkgPrefix, structName, g.pkgPrefix, structName) return nil } @@ -889,24 +893,19 @@ func (g *gen) writeInitializerImpl(b *buffer, n *a.Struct) error { return err } b.writes("{\n") - b.writes("if (!self) { return; }\n") + b.writes("if (!self) { return WUFFS_BASE__ERROR_BAD_RECEIVER; }\n") b.writes("if (sizeof(*self) != sizeof_star_self) {\n") - b.writes("self->private_impl.status = WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER;\n") - b.writes("return;\n") + b.writes("return WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER;\n") b.writes("}\n") b.writes("if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) || " + "(((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {\n") - b.writes("self->private_impl.status = WUFFS_BASE__ERROR_BAD_WUFFS_VERSION;\n") - b.writes("return;\n") + b.writes("return WUFFS_BASE__ERROR_BAD_WUFFS_VERSION;\n") b.writes("}\n") b.writes("if (self->private_impl.magic != 0) {\n") - b.writes("self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE;\n") - b.writes("return;\n") + b.writes("return WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE;\n") b.writes("}\n") - b.writes("self->private_impl.magic = WUFFS_BASE__MAGIC;\n") - // Call any ctors on sub-structs. for _, f := range n.Fields() { f := f.AsField() @@ -929,10 +928,16 @@ func (g *gen) writeInitializerImpl(b *buffer, n *a.Struct) error { continue } - b.printf("%s%s__check_wuffs_version(&self->private_impl.%s%s, sizeof(self->private_impl.%s%s), WUFFS_VERSION);\n", + b.printf("{\n") + 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("}\n") } + b.writes("self->private_impl.magic = WUFFS_BASE__MAGIC;\n") + b.writes("return 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 9062c686..6f36162d 100644 --- a/cmd/wuffs-c/internal/cgen/data.go +++ b/cmd/wuffs-c/internal/cgen/data.go @@ -19,8 +19,8 @@ package cgen const baseBasePublicH = "" + "// 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#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// Wuffs assumes that:\n// - converting a uint32_t to a size_t will never overflow.\n// - converting a size_t to a uint64_t will never overflow.\n#ifdef __WORDSIZE\n#if (__WORDSIZE != 32) && (__WORDSIZE != 64)\n#error \"Wuffs requires a word size of either 32 or 64 bits\"\n#endif\n#endif\n\n// WUFFS_VERSION is the major.minor.patch v" + "ersion, as per https://semver.org/,\n// as a uint64_t. The major number is the high 32 bits. The minor number is the\n// middle 16 bits. The patch number is the low 16 bits. The version extension\n// (such as \"\", \"beta\" or \"rc.1\") is part of the string representation (such as\n// \"1.2.3-beta\") but not the uint64_t representation.\n//\n// All three of major, minor and patch being zero means that this is a\n// work-in-progress version, not a release version, and has no backwards or\n// forwards compatibility guarantees.\n//\n// !! Some code generation programs can override WUFFS_VERSION.\n#define WUFFS_VERSION ((uint64_t)0)\n#define WUFFS_VERSION_MAJOR ((uint64_t)0)\n#define WUFFS_VERSION_MINOR ((uint64_t)0)\n#define WUFFS_VERSION_PATCH ((uint64_t)0)\n#define WUFFS_VERSION_EXTENSION \"\"\n#define WUFFS_VERSION_STRING \"0.0.0\"\n\n// Define WUFFS_CONFIG__STATIC_FUNCTIONS to make all of Wuffs' functions have\n// static storage. The motivation is discussed in the \"ALLOW STATIC\n// IMPLEMENTATION\" section of\n// https://raw.githubuserconte" + - "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// 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__ut" + - "ility 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" + + "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" + "" + @@ -71,10 +71,10 @@ 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\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 memory 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__CORO" + - "UTINE_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 evaluate 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" + + "#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" + + "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" + "t32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24);\n}\n\nstatic inline uint64_t //\nwuffs_base__load_u40be(uint8_t* p) {\n return ((uint64_t)(p[0]) << 32) | ((uint64_t)(p[1]) << 24) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 8) |\n ((uint64_t)(p[4]) << 0);\n}\n\nstatic inline uint64_t //\nwuffs_base__load_u40le(uint8_t* p) {\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32);\n}\n\nstatic inline uint64_t //\nwuffs_base__load_u48be(uint8_t* p) {\n return ((uint64_t)(p[0]) << 40) | ((uint64_t)(p[1]) << 32) |\n ((uint64_t)(p[2]) << 24) | ((uint64_t)(p[3]) << 16) |\n ((uint64_t)(p[4]) << 8) | ((uint64_t)(p[5]) << 0);\n}\n\nstatic inline uint64_t //\nwuffs_base__load_u48le(uint8_t* p) {\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40);\n}\n\nstatic inline u" + diff --git a/cmd/wuffs-c/internal/cgen/expr.go b/cmd/wuffs-c/internal/cgen/expr.go index 6d40d583..62a8f56e 100644 --- a/cmd/wuffs-c/internal/cgen/expr.go +++ b/cmd/wuffs-c/internal/cgen/expr.go @@ -117,11 +117,12 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, depth u } b.printf(", 0, sizeof ((%s%s){})),", g.packagePrefix(qid), qid[1].Str(g.tm)) - b.printf("%s%s__check_wuffs_version(%s", g.packagePrefix(qid), qid[1].Str(g.tm), addr) + b.printf("wuffs_base__ignore_check_wuffs_version_status("+ + "%s%s__check_wuffs_version(%s", g.packagePrefix(qid), qid[1].Str(g.tm), addr) if err := g.writeExpr(b, recv, rp, depth); err != nil { return err } - b.printf(", sizeof ((%s%s){}), WUFFS_VERSION)", g.packagePrefix(qid), qid[1].Str(g.tm)) + b.printf(", sizeof ((%s%s){}), WUFFS_VERSION))", g.packagePrefix(qid), qid[1].Str(g.tm)) b.writes(", wuffs_base__return_empty_struct())") return nil diff --git a/cmd/wuffs-c/internal/cgen/func.go b/cmd/wuffs-c/internal/cgen/func.go index 61713f66..84ee8ff2 100644 --- a/cmd/wuffs-c/internal/cgen/func.go +++ b/cmd/wuffs-c/internal/cgen/func.go @@ -230,7 +230,7 @@ func (g *gen) writeFuncImplHeader(b *buffer) error { b.writes(";}") b.writes("if (self->private_impl.magic != WUFFS_BASE__MAGIC) {" + - "self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_NOT_CALLED; }") + "self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; }") b.writes("if (self->private_impl.status < 0) { return ") if g.currFunk.suspendible { diff --git a/example/crc32/crc32.cc b/example/crc32/crc32.cc index f40747e3..8c2e8f52 100644 --- a/example/crc32/crc32.cc +++ b/example/crc32/crc32.cc @@ -57,7 +57,11 @@ uint8_t src_buffer[SRC_BUFFER_SIZE]; int main(int argc, char** argv) { wuffs_crc32__ieee_hasher h = ((wuffs_crc32__ieee_hasher){}); - h.check_wuffs_version(sizeof h, WUFFS_VERSION); + wuffs_base__status z = h.check_wuffs_version(sizeof h, WUFFS_VERSION); + if (z) { + fprintf(stderr, "%s\n", wuffs_crc32__status__string(z)); + return 1; + } while (true) { const int stdin_fd = 0; diff --git a/example/gifplayer/gifplayer.c b/example/gifplayer/gifplayer.c index d9cdb701..f6d18cbc 100644 --- a/example/gifplayer/gifplayer.c +++ b/example/gifplayer/gifplayer.c @@ -271,7 +271,11 @@ const char* allocate(wuffs_base__pixel_config* pc) { const char* play() { wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + wuffs_base__status z = + wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + if (z) { + return wuffs_gif__status__string(z); + } wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ .ptr = src_buffer, .len = src_len, .wi = src_len, .closed = true}); @@ -280,10 +284,9 @@ const char* play() { if (first_play) { first_play = false; wuffs_base__image_config ic = ((wuffs_base__image_config){}); - wuffs_base__status s = - wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader); - if (s) { - return wuffs_gif__status__string(s); + z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader); + if (z) { + return wuffs_gif__status__string(z); } if (!wuffs_base__image_config__is_valid(&ic)) { return "invalid image configuration"; @@ -297,11 +300,11 @@ const char* play() { if (msg) { return msg; } - s = wuffs_base__pixel_buffer__set_from_slice( + 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 (s) { - return wuffs_gif__status__string(s); + if (z) { + return wuffs_gif__status__string(z); } memset(image_buffer, 0, image_len); memset(dst_buffer, 0, dst_len); @@ -310,13 +313,13 @@ const char* play() { while (1) { wuffs_base__frame_config fc = ((wuffs_base__frame_config){}); - wuffs_base__status s = + wuffs_base__status z = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader); - if (s) { - if (s == WUFFS_BASE__SUSPENSION_END_OF_DATA) { + if (z) { + if (z == WUFFS_BASE__SUSPENSION_END_OF_DATA) { break; } - return wuffs_gif__status__string(s); + return wuffs_gif__status__string(z); } switch (wuffs_base__frame_config__disposal(&fc)) { @@ -326,13 +329,13 @@ const char* play() { } } - s = wuffs_gif__decoder__decode_frame(&dec, &pb, 0, 0, src_reader, + z = wuffs_gif__decoder__decode_frame(&dec, &pb, 0, 0, src_reader, ((wuffs_base__slice_u8){})); - if (s) { - if (s == WUFFS_BASE__SUSPENSION_END_OF_DATA) { + if (z) { + if (z == WUFFS_BASE__SUSPENSION_END_OF_DATA) { break; } - return wuffs_gif__status__string(s); + return wuffs_gif__status__string(z); } compose(&pb, wuffs_base__frame_config__bounds(&fc)); diff --git a/example/library/library.c b/example/library/library.c index a8929c76..2bb4f388 100644 --- a/example/library/library.c +++ b/example/library/library.c @@ -60,11 +60,14 @@ static const char* decode() { wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){}); - wuffs_deflate__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); - wuffs_base__status s = - wuffs_deflate__decoder__decode(&dec, dst_writer, src_reader); - if (s) { - return wuffs_deflate__status__string(s); + wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version( + &dec, sizeof dec, WUFFS_VERSION); + if (z) { + return wuffs_deflate__status__string(z); + } + z = wuffs_deflate__decoder__decode(&dec, dst_writer, src_reader); + if (z) { + return wuffs_deflate__status__string(z); } ignore_return_value(write(1, dst.ptr, dst.wi)); return NULL; diff --git a/example/zcat/zcat.c b/example/zcat/zcat.c index 1c738716..5d28a2e5 100644 --- a/example/zcat/zcat.c +++ b/example/zcat/zcat.c @@ -75,7 +75,11 @@ static void ignore_return_value(int ignored) {} static const char* decode() { wuffs_gzip__decoder dec = ((wuffs_gzip__decoder){}); - wuffs_gzip__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + wuffs_base__status z = + wuffs_gzip__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + if (z) { + return wuffs_gzip__status__string(z); + } wuffs_base__io_buffer src = ((wuffs_base__io_buffer){.ptr = src_buffer, .len = SRC_BUFFER_SIZE}); @@ -98,7 +102,7 @@ static const char* decode() { wuffs_base__io_buffer dst = ((wuffs_base__io_buffer){.ptr = dst_buffer, .len = DST_BUFFER_SIZE}); - wuffs_base__status s = + wuffs_base__status z = wuffs_gzip__decoder__decode(&dec, wuffs_base__io_buffer__writer(&dst), wuffs_base__io_buffer__reader(&src)); @@ -108,16 +112,16 @@ static const char* decode() { ignore_return_value(write(stdout_fd, dst_buffer, dst.wi)); } - if (s == WUFFS_BASE__STATUS_OK) { + if (z == WUFFS_BASE__STATUS_OK) { return NULL; } - if (s == WUFFS_BASE__SUSPENSION_SHORT_READ) { + if (z == WUFFS_BASE__SUSPENSION_SHORT_READ) { break; } - if (s == WUFFS_BASE__SUSPENSION_SHORT_WRITE) { + if (z == WUFFS_BASE__SUSPENSION_SHORT_WRITE) { continue; } - return wuffs_gzip__status__string(s); + return wuffs_gzip__status__string(z); } wuffs_base__io_buffer__compact(&src); diff --git a/fuzz/c/std/gif_fuzzer.c b/fuzz/c/std/gif_fuzzer.c index 53e629a2..9d9bf760 100644 --- a/fuzz/c/std/gif_fuzzer.c +++ b/fuzz/c/std/gif_fuzzer.c @@ -53,14 +53,17 @@ const char* fuzz(wuffs_base__io_reader src_reader, uint32_t hash) { // Use a {} code block so that "goto exit" doesn't trigger "jump bypasses // variable initialization" warnings. { - wuffs_base__status s = 0; wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + wuffs_base__status z = wuffs_gif__decoder__check_wuffs_version( + &dec, sizeof dec, WUFFS_VERSION); + if (z) { + return wuffs_gif__status__string(z); + } wuffs_base__image_config ic = ((wuffs_base__image_config){}); - s = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader); - if (s) { - ret = wuffs_gif__status__string(s); + z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader); + if (z) { + ret = wuffs_gif__status__string(z); goto exit; } if (!wuffs_base__image_config__is_valid(&ic)) { @@ -81,23 +84,23 @@ const char* fuzz(wuffs_base__io_reader src_reader, uint32_t hash) { goto exit; } wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){}); - s = wuffs_base__pixel_buffer__set_from_slice( + 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 (s) { - ret = wuffs_gif__status__string(s); + if (z) { + ret = wuffs_gif__status__string(z); goto exit; } bool seen_ok = false; while (true) { - s = wuffs_gif__decoder__decode_frame(&dec, &pb, 0, 0, src_reader, + z = wuffs_gif__decoder__decode_frame(&dec, &pb, 0, 0, src_reader, ((wuffs_base__slice_u8){})); - if (s) { - if ((s == WUFFS_BASE__SUSPENSION_END_OF_DATA) && seen_ok) { - s = WUFFS_BASE__STATUS_OK; + if (z) { + if ((z == WUFFS_BASE__SUSPENSION_END_OF_DATA) && seen_ok) { + z = WUFFS_BASE__STATUS_OK; } - ret = wuffs_gif__status__string(s); + ret = wuffs_gif__status__string(z); goto exit; } seen_ok = true; diff --git a/fuzz/c/std/zlib_fuzzer.c b/fuzz/c/std/zlib_fuzzer.c index 412c66fa..43a563b4 100644 --- a/fuzz/c/std/zlib_fuzzer.c +++ b/fuzz/c/std/zlib_fuzzer.c @@ -48,9 +48,12 @@ It should print "PASS", amongst other information, and exit(0). const char* fuzz(wuffs_base__io_reader src_reader, uint32_t hash) { const char* ret = NULL; - wuffs_base__status s = 0; wuffs_zlib__decoder dec = ((wuffs_zlib__decoder){}); - wuffs_zlib__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + wuffs_base__status z = + wuffs_zlib__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + if (z) { + return wuffs_zlib__status__string(z); + } // Ignore the checksum for 99.99%-ish of all input. When fuzzers generate // random input, the checkum is very unlikely to match. Still, it's useful to @@ -64,9 +67,9 @@ const char* fuzz(wuffs_base__io_reader src_reader, uint32_t hash) { while (true) { dst.wi = 0; - s = wuffs_zlib__decoder__decode(&dec, dst_writer, src_reader); - if (s != WUFFS_BASE__SUSPENSION_SHORT_WRITE) { - ret = wuffs_zlib__status__string(s); + z = wuffs_zlib__decoder__decode(&dec, dst_writer, src_reader); + if (z != WUFFS_BASE__SUSPENSION_SHORT_WRITE) { + ret = wuffs_zlib__status__string(z); break; } if (dst.wi == 0) { diff --git a/lang/builtin/builtin.go b/lang/builtin/builtin.go index 68de391f..9974296a 100644 --- a/lang/builtin/builtin.go +++ b/lang/builtin/builtin.go @@ -45,7 +45,7 @@ var StatusList = [...]Status{ {t.IDError, -0x04, "bad argument"}, {t.IDError, -0x04, "bad argument (length too short)"}, - {t.IDError, -0x10, "check_wuffs_version not called"}, + {t.IDError, -0x10, "check_wuffs_version missing"}, {t.IDError, -0x11, "check_wuffs_version called twice"}, {t.IDError, -0x12, "invalid call sequence"}, diff --git a/release/c/wuffs-unsupported-snapshot.h b/release/c/wuffs-unsupported-snapshot.h index 7561915f..e83ef242 100644 --- a/release/c/wuffs-unsupported-snapshot.h +++ b/release/c/wuffs-unsupported-snapshot.h @@ -83,6 +83,13 @@ extern "C" { #define WUFFS_BASE__MAYBE_STATIC #endif +// Clang also defines "__GNUC__". +#if defined(__GNUC__) +#define WUFFS_BASE__WARN_UNUSED_RESULT __attribute__((warn_unused_result)) +#else +#define WUFFS_BASE__WARN_UNUSED_RESULT +#endif + // wuffs_base__empty_struct is used when a Wuffs function returns an empty // struct. In C, if a function f returns void, you can't say "x = f()", but in // Wuffs, if a function g returns empty, you can say "y = g()". @@ -133,8 +140,7 @@ typedef int32_t wuffs_base__status; #define WUFFS_BASE__ERROR_BAD_RECEIVER -50331648 // 0xFD000000 #define WUFFS_BASE__ERROR_BAD_ARGUMENT -67108864 // 0xFC000000 #define WUFFS_BASE__ERROR_BAD_ARGUMENT_LENGTH_TOO_SHORT -67108864 // 0xFC000000 -#define WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_NOT_CALLED \ - -268435456 // 0xF0000000 +#define WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING -268435456 // 0xF0000000 #define WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE \ -285212672 // 0xEF000000 #define WUFFS_BASE__ERROR_INVALID_CALL_SEQUENCE -301989888 // 0xEE000000 @@ -2056,8 +2062,8 @@ typedef struct { } private_impl; #ifdef __cplusplus - inline void check_wuffs_version(size_t sizeof_star_self, - uint64_t wuffs_version); + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // + check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version); inline uint32_t update(wuffs_base__slice_u8 a_x); #endif // __cplusplus @@ -2070,9 +2076,10 @@ typedef struct { // It should be called before any other wuffs_adler32__hasher__* function. // // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. -void wuffs_adler32__hasher__check_wuffs_version(wuffs_adler32__hasher* self, - size_t sizeof_star_self, - uint64_t wuffs_version); +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_adler32__hasher__check_wuffs_version(wuffs_adler32__hasher* self, + size_t sizeof_star_self, + uint64_t wuffs_version); // ---------------- Public Function Prototypes @@ -2084,11 +2091,11 @@ wuffs_adler32__hasher__update(wuffs_adler32__hasher* self, #ifdef __cplusplus -inline void // +inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // wuffs_adler32__hasher::check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version) { - wuffs_adler32__hasher__check_wuffs_version(this, sizeof_star_self, - wuffs_version); + return wuffs_adler32__hasher__check_wuffs_version(this, sizeof_star_self, + wuffs_version); } inline uint32_t // @@ -2137,8 +2144,8 @@ typedef struct { } private_impl; #ifdef __cplusplus - inline void check_wuffs_version(size_t sizeof_star_self, - uint64_t wuffs_version); + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // + check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version); inline uint32_t update(wuffs_base__slice_u8 a_x); #endif // __cplusplus @@ -2151,10 +2158,10 @@ typedef struct { // It should be called before any other wuffs_crc32__ieee_hasher__* function. // // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. -void wuffs_crc32__ieee_hasher__check_wuffs_version( - wuffs_crc32__ieee_hasher* self, - size_t sizeof_star_self, - uint64_t wuffs_version); +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_crc32__ieee_hasher__check_wuffs_version(wuffs_crc32__ieee_hasher* self, + size_t sizeof_star_self, + uint64_t wuffs_version); // ---------------- Public Function Prototypes @@ -2166,11 +2173,11 @@ wuffs_crc32__ieee_hasher__update(wuffs_crc32__ieee_hasher* self, #ifdef __cplusplus -inline void // +inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // wuffs_crc32__ieee_hasher::check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version) { - wuffs_crc32__ieee_hasher__check_wuffs_version(this, sizeof_star_self, - wuffs_version); + return wuffs_crc32__ieee_hasher__check_wuffs_version(this, sizeof_star_self, + wuffs_version); } inline uint32_t // @@ -2309,8 +2316,8 @@ typedef struct { } private_impl; #ifdef __cplusplus - inline void check_wuffs_version(size_t sizeof_star_self, - uint64_t wuffs_version); + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // + check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version); inline wuffs_base__status decode(wuffs_base__io_writer a_dst, wuffs_base__io_reader a_src); #endif // __cplusplus @@ -2324,9 +2331,10 @@ typedef struct { // It should be called before any other wuffs_deflate__decoder__* function. // // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. -void wuffs_deflate__decoder__check_wuffs_version(wuffs_deflate__decoder* self, - size_t sizeof_star_self, - uint64_t wuffs_version); +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_deflate__decoder__check_wuffs_version(wuffs_deflate__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version); // ---------------- Public Function Prototypes @@ -2339,11 +2347,11 @@ wuffs_deflate__decoder__decode(wuffs_deflate__decoder* self, #ifdef __cplusplus -inline void // +inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // wuffs_deflate__decoder::check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version) { - wuffs_deflate__decoder__check_wuffs_version(this, sizeof_star_self, - wuffs_version); + return wuffs_deflate__decoder__check_wuffs_version(this, sizeof_star_self, + wuffs_version); } inline wuffs_base__status // @@ -2420,8 +2428,8 @@ typedef struct { } private_impl; #ifdef __cplusplus - inline void check_wuffs_version(size_t sizeof_star_self, - uint64_t wuffs_version); + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // + check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version); inline void set_literal_width(uint32_t a_lw); inline wuffs_base__status decode(wuffs_base__io_writer a_dst, wuffs_base__io_reader a_src); @@ -2436,9 +2444,10 @@ typedef struct { // It should be called before any other wuffs_lzw__decoder__* function. // // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. -void wuffs_lzw__decoder__check_wuffs_version(wuffs_lzw__decoder* self, - size_t sizeof_star_self, - uint64_t wuffs_version); +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_lzw__decoder__check_wuffs_version(wuffs_lzw__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version); // ---------------- Public Function Prototypes @@ -2454,11 +2463,11 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, #ifdef __cplusplus -inline void // +inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // wuffs_lzw__decoder::check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version) { - wuffs_lzw__decoder__check_wuffs_version(this, sizeof_star_self, - wuffs_version); + return wuffs_lzw__decoder__check_wuffs_version(this, sizeof_star_self, + wuffs_version); } inline void // @@ -2621,8 +2630,8 @@ typedef struct { } private_impl; #ifdef __cplusplus - inline void check_wuffs_version(size_t sizeof_star_self, - uint64_t wuffs_version); + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // + check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version); inline wuffs_base__status decode_image_config(wuffs_base__image_config* a_dst, wuffs_base__io_reader a_src); inline uint64_t num_decoded_frame_configs(); @@ -2646,9 +2655,10 @@ typedef struct { // It should be called before any other wuffs_gif__decoder__* function. // // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. -void wuffs_gif__decoder__check_wuffs_version(wuffs_gif__decoder* self, - size_t sizeof_star_self, - uint64_t wuffs_version); +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_gif__decoder__check_wuffs_version(wuffs_gif__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version); // ---------------- Public Function Prototypes @@ -2683,11 +2693,11 @@ wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self, #ifdef __cplusplus -inline void // +inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // wuffs_gif__decoder::check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version) { - wuffs_gif__decoder__check_wuffs_version(this, sizeof_star_self, - wuffs_version); + return wuffs_gif__decoder__check_wuffs_version(this, sizeof_star_self, + wuffs_version); } inline wuffs_base__status // @@ -2795,8 +2805,8 @@ typedef struct { } private_impl; #ifdef __cplusplus - inline void check_wuffs_version(size_t sizeof_star_self, - uint64_t wuffs_version); + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // + check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version); inline void set_ignore_checksum(bool a_ic); inline wuffs_base__status decode(wuffs_base__io_writer a_dst, wuffs_base__io_reader a_src); @@ -2811,9 +2821,10 @@ typedef struct { // It should be called before any other wuffs_gzip__decoder__* function. // // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. -void wuffs_gzip__decoder__check_wuffs_version(wuffs_gzip__decoder* self, - size_t sizeof_star_self, - uint64_t wuffs_version); +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_gzip__decoder__check_wuffs_version(wuffs_gzip__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version); // ---------------- Public Function Prototypes @@ -2829,11 +2840,11 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, #ifdef __cplusplus -inline void // +inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // wuffs_gzip__decoder::check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version) { - wuffs_gzip__decoder__check_wuffs_version(this, sizeof_star_self, - wuffs_version); + return wuffs_gzip__decoder__check_wuffs_version(this, sizeof_star_self, + wuffs_version); } inline void // @@ -2913,8 +2924,8 @@ typedef struct { } private_impl; #ifdef __cplusplus - inline void check_wuffs_version(size_t sizeof_star_self, - uint64_t wuffs_version); + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // + check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version); inline void set_ignore_checksum(bool a_ic); inline wuffs_base__status decode(wuffs_base__io_writer a_dst, wuffs_base__io_reader a_src); @@ -2929,9 +2940,10 @@ typedef struct { // It should be called before any other wuffs_zlib__decoder__* function. // // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. -void wuffs_zlib__decoder__check_wuffs_version(wuffs_zlib__decoder* self, - size_t sizeof_star_self, - uint64_t wuffs_version); +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_zlib__decoder__check_wuffs_version(wuffs_zlib__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version); // ---------------- Public Function Prototypes @@ -2947,11 +2959,11 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, #ifdef __cplusplus -inline void // +inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // wuffs_zlib__decoder::check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version) { - wuffs_zlib__decoder__check_wuffs_version(this, sizeof_star_self, - wuffs_version); + return wuffs_zlib__decoder__check_wuffs_version(this, sizeof_star_self, + wuffs_version); } inline void // @@ -2993,6 +3005,9 @@ extern "C" { #define WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(x) (void)(x) +static inline void wuffs_base__ignore_check_wuffs_version_status( + wuffs_base__status z) {} + // WUFFS_BASE__MAGIC is a magic number to check that initializers are called. // It's not foolproof, given C doesn't automatically zero memory before use, // but it should catch 99.99% of cases. @@ -3712,15 +3727,15 @@ static const char wuffs_base__status__string_data[] = { 0x66, 0x66, 0x73, 0x5F, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x74, 0x77, 0x69, 0x63, 0x65, 0x00, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x5F, 0x77, 0x75, 0x66, 0x66, 0x73, - 0x5F, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x6E, 0x6F, 0x74, - 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x65, 0x64, 0x00, 0x62, 0x61, 0x64, 0x20, - 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x28, 0x6C, 0x65, - 0x6E, 0x67, 0x74, 0x68, 0x20, 0x74, 0x6F, 0x6F, 0x20, 0x73, 0x68, 0x6F, - 0x72, 0x74, 0x29, 0x00, 0x62, 0x61, 0x64, 0x20, 0x72, 0x65, 0x63, 0x65, - 0x69, 0x76, 0x65, 0x72, 0x00, 0x62, 0x61, 0x64, 0x20, 0x73, 0x69, 0x7A, - 0x65, 0x6F, 0x66, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, - 0x00, 0x62, 0x61, 0x64, 0x20, 0x77, 0x75, 0x66, 0x66, 0x73, 0x20, 0x76, - 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x00, + 0x5F, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x6D, 0x69, 0x73, + 0x73, 0x69, 0x6E, 0x67, 0x00, 0x62, 0x61, 0x64, 0x20, 0x61, 0x72, 0x67, + 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x28, 0x6C, 0x65, 0x6E, 0x67, 0x74, + 0x68, 0x20, 0x74, 0x6F, 0x6F, 0x20, 0x73, 0x68, 0x6F, 0x72, 0x74, 0x29, + 0x00, 0x62, 0x61, 0x64, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, + 0x72, 0x00, 0x62, 0x61, 0x64, 0x20, 0x73, 0x69, 0x7A, 0x65, 0x6F, 0x66, + 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x00, 0x62, 0x61, + 0x64, 0x20, 0x77, 0x75, 0x66, 0x66, 0x73, 0x20, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6F, 0x6E, 0x00, }; static const uint16_t wuffs_base__status__string_offsets[] = { @@ -3752,7 +3767,7 @@ static const uint16_t wuffs_base__status__string_offsets[] = { 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0042, 0x0058, 0x0079, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, - 0x0098, 0x00B8, 0x00C5, 0x00D9, + 0x0095, 0x00B5, 0x00C2, 0x00D6, }; const char* // @@ -3827,27 +3842,25 @@ const char* wuffs_adler32__status__string(wuffs_base__status s) { // ---------------- Initializer Implementations -void wuffs_adler32__hasher__check_wuffs_version(wuffs_adler32__hasher* self, - size_t sizeof_star_self, - uint64_t wuffs_version) { +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_adler32__hasher__check_wuffs_version(wuffs_adler32__hasher* self, + size_t sizeof_star_self, + uint64_t wuffs_version) { if (!self) { - return; + return WUFFS_BASE__ERROR_BAD_RECEIVER; } if (sizeof(*self) != sizeof_star_self) { - self->private_impl.status = WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; - return; + return WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; } if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) || (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) { - self->private_impl.status = WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; - return; + return WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; } if (self->private_impl.magic != 0) { - self->private_impl.status = - WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; - return; + return WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; } self->private_impl.magic = WUFFS_BASE__MAGIC; + return WUFFS_BASE__STATUS_OK; } // ---------------- Function Implementations @@ -3861,8 +3874,7 @@ 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_NOT_CALLED; + self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; } if (self->private_impl.status < 0) { return 0; @@ -4360,28 +4372,25 @@ static const uint32_t wuffs_crc32__ieee_table[8][256] = { // ---------------- Initializer Implementations -void wuffs_crc32__ieee_hasher__check_wuffs_version( - wuffs_crc32__ieee_hasher* self, - size_t sizeof_star_self, - uint64_t wuffs_version) { +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_crc32__ieee_hasher__check_wuffs_version(wuffs_crc32__ieee_hasher* self, + size_t sizeof_star_self, + uint64_t wuffs_version) { if (!self) { - return; + return WUFFS_BASE__ERROR_BAD_RECEIVER; } if (sizeof(*self) != sizeof_star_self) { - self->private_impl.status = WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; - return; + return WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; } if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) || (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) { - self->private_impl.status = WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; - return; + return WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; } if (self->private_impl.magic != 0) { - self->private_impl.status = - WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; - return; + return WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; } self->private_impl.magic = WUFFS_BASE__MAGIC; + return WUFFS_BASE__STATUS_OK; } // ---------------- Function Implementations @@ -4395,8 +4404,7 @@ 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_NOT_CALLED; + self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; } if (self->private_impl.status < 0) { return 0; @@ -4737,27 +4745,25 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self, // ---------------- Initializer Implementations -void wuffs_deflate__decoder__check_wuffs_version(wuffs_deflate__decoder* self, - size_t sizeof_star_self, - uint64_t wuffs_version) { +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_deflate__decoder__check_wuffs_version(wuffs_deflate__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version) { if (!self) { - return; + return WUFFS_BASE__ERROR_BAD_RECEIVER; } if (sizeof(*self) != sizeof_star_self) { - self->private_impl.status = WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; - return; + return WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; } if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) || (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) { - self->private_impl.status = WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; - return; + return WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; } if (self->private_impl.magic != 0) { - self->private_impl.status = - WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; - return; + return WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; } self->private_impl.magic = WUFFS_BASE__MAGIC; + return WUFFS_BASE__STATUS_OK; } // ---------------- Function Implementations @@ -4772,8 +4778,7 @@ wuffs_deflate__decoder__decode(wuffs_deflate__decoder* self, return WUFFS_BASE__ERROR_BAD_RECEIVER; } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - self->private_impl.status = - WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_NOT_CALLED; + self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; } if (self->private_impl.status < 0) { return self->private_impl.status; @@ -6688,30 +6693,33 @@ wuffs_gif__decoder__copy_to_image_buffer(wuffs_gif__decoder* self, // ---------------- Initializer Implementations -void wuffs_gif__decoder__check_wuffs_version(wuffs_gif__decoder* self, - size_t sizeof_star_self, - uint64_t wuffs_version) { +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_gif__decoder__check_wuffs_version(wuffs_gif__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version) { if (!self) { - return; + return WUFFS_BASE__ERROR_BAD_RECEIVER; } if (sizeof(*self) != sizeof_star_self) { - self->private_impl.status = WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; - return; + return WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; } if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) || (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) { - self->private_impl.status = WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; - return; + return WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; } if (self->private_impl.magic != 0) { - self->private_impl.status = - WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; - return; + return WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; + } + { + wuffs_base__status z = wuffs_lzw__decoder__check_wuffs_version( + &self->private_impl.f_lzw, sizeof(self->private_impl.f_lzw), + WUFFS_VERSION); + if (z) { + return z; + } } self->private_impl.magic = WUFFS_BASE__MAGIC; - wuffs_lzw__decoder__check_wuffs_version(&self->private_impl.f_lzw, - sizeof(self->private_impl.f_lzw), - WUFFS_VERSION); + return WUFFS_BASE__STATUS_OK; } // ---------------- Function Implementations @@ -6726,8 +6734,7 @@ wuffs_gif__decoder__decode_image_config(wuffs_gif__decoder* self, return WUFFS_BASE__ERROR_BAD_RECEIVER; } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - self->private_impl.status = - WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_NOT_CALLED; + self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; } if (self->private_impl.status < 0) { return self->private_impl.status; @@ -6811,8 +6818,7 @@ 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_NOT_CALLED; + self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; } if (self->private_impl.status < 0) { return 0; @@ -6829,8 +6835,7 @@ 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_NOT_CALLED; + self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; } if (self->private_impl.status < 0) { return 0; @@ -6847,8 +6852,7 @@ 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_NOT_CALLED; + self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; } if (self->private_impl.status < 0) { return ((wuffs_base__range_ii_u64){}); @@ -6868,8 +6872,7 @@ wuffs_gif__decoder__decode_frame_config(wuffs_gif__decoder* self, return WUFFS_BASE__ERROR_BAD_RECEIVER; } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - self->private_impl.status = - WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_NOT_CALLED; + self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; } if (self->private_impl.status < 0) { return self->private_impl.status; @@ -7050,8 +7053,7 @@ wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self, return WUFFS_BASE__ERROR_BAD_RECEIVER; } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - self->private_impl.status = - WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_NOT_CALLED; + self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; } if (self->private_impl.status < 0) { return self->private_impl.status; @@ -8360,9 +8362,10 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, .len = 1024})); if (self->private_impl.f_previous_lzw_decode_ended_abruptly) { (memset(&self->private_impl.f_lzw, 0, sizeof((wuffs_lzw__decoder){})), - wuffs_lzw__decoder__check_wuffs_version(&self->private_impl.f_lzw, - sizeof((wuffs_lzw__decoder){}), - WUFFS_VERSION), + wuffs_base__ignore_check_wuffs_version_status( + wuffs_lzw__decoder__check_wuffs_version( + &self->private_impl.f_lzw, sizeof((wuffs_lzw__decoder){}), + WUFFS_VERSION)), wuffs_base__return_empty_struct()); } { @@ -8683,33 +8686,41 @@ const char* wuffs_gzip__status__string(wuffs_base__status s) { // ---------------- Initializer Implementations -void wuffs_gzip__decoder__check_wuffs_version(wuffs_gzip__decoder* self, - size_t sizeof_star_self, - uint64_t wuffs_version) { +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_gzip__decoder__check_wuffs_version(wuffs_gzip__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version) { if (!self) { - return; + return WUFFS_BASE__ERROR_BAD_RECEIVER; } if (sizeof(*self) != sizeof_star_self) { - self->private_impl.status = WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; - return; + return WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; } if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) || (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) { - self->private_impl.status = WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; - return; + return WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; } if (self->private_impl.magic != 0) { - self->private_impl.status = - WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; - return; + return WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; + } + { + wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version( + &self->private_impl.f_flate, sizeof(self->private_impl.f_flate), + WUFFS_VERSION); + if (z) { + return z; + } + } + { + 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) { + return z; + } } self->private_impl.magic = WUFFS_BASE__MAGIC; - wuffs_deflate__decoder__check_wuffs_version( - &self->private_impl.f_flate, sizeof(self->private_impl.f_flate), - WUFFS_VERSION); - wuffs_crc32__ieee_hasher__check_wuffs_version( - &self->private_impl.f_checksum, sizeof(self->private_impl.f_checksum), - WUFFS_VERSION); + return WUFFS_BASE__STATUS_OK; } // ---------------- Function Implementations @@ -8722,8 +8733,7 @@ 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_NOT_CALLED; + self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; } if (self->private_impl.status < 0) { return; @@ -8742,8 +8752,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, return WUFFS_BASE__ERROR_BAD_RECEIVER; } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - self->private_impl.status = - WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_NOT_CALLED; + self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; } if (self->private_impl.status < 0) { return self->private_impl.status; @@ -9170,27 +9179,25 @@ const char* wuffs_lzw__status__string(wuffs_base__status s) { // ---------------- Initializer Implementations -void wuffs_lzw__decoder__check_wuffs_version(wuffs_lzw__decoder* self, - size_t sizeof_star_self, - uint64_t wuffs_version) { +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_lzw__decoder__check_wuffs_version(wuffs_lzw__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version) { if (!self) { - return; + return WUFFS_BASE__ERROR_BAD_RECEIVER; } if (sizeof(*self) != sizeof_star_self) { - self->private_impl.status = WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; - return; + return WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; } if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) || (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) { - self->private_impl.status = WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; - return; + return WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; } if (self->private_impl.magic != 0) { - self->private_impl.status = - WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; - return; + return WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; } self->private_impl.magic = WUFFS_BASE__MAGIC; + return WUFFS_BASE__STATUS_OK; } // ---------------- Function Implementations @@ -9203,8 +9210,7 @@ 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_NOT_CALLED; + self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; } if (self->private_impl.status < 0) { return; @@ -9227,8 +9233,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, return WUFFS_BASE__ERROR_BAD_RECEIVER; } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - self->private_impl.status = - WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_NOT_CALLED; + self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; } if (self->private_impl.status < 0) { return self->private_impl.status; @@ -9523,33 +9528,41 @@ const char* wuffs_zlib__status__string(wuffs_base__status s) { // ---------------- Initializer Implementations -void wuffs_zlib__decoder__check_wuffs_version(wuffs_zlib__decoder* self, - size_t sizeof_star_self, - uint64_t wuffs_version) { +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_zlib__decoder__check_wuffs_version(wuffs_zlib__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version) { if (!self) { - return; + return WUFFS_BASE__ERROR_BAD_RECEIVER; } if (sizeof(*self) != sizeof_star_self) { - self->private_impl.status = WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; - return; + return WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER; } if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) || (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) { - self->private_impl.status = WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; - return; + return WUFFS_BASE__ERROR_BAD_WUFFS_VERSION; } if (self->private_impl.magic != 0) { - self->private_impl.status = - WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; - return; + return WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_CALLED_TWICE; + } + { + wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version( + &self->private_impl.f_flate, sizeof(self->private_impl.f_flate), + WUFFS_VERSION); + if (z) { + return z; + } + } + { + 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) { + return z; + } } self->private_impl.magic = WUFFS_BASE__MAGIC; - wuffs_deflate__decoder__check_wuffs_version( - &self->private_impl.f_flate, sizeof(self->private_impl.f_flate), - WUFFS_VERSION); - wuffs_adler32__hasher__check_wuffs_version( - &self->private_impl.f_checksum, sizeof(self->private_impl.f_checksum), - WUFFS_VERSION); + return WUFFS_BASE__STATUS_OK; } // ---------------- Function Implementations @@ -9562,8 +9575,7 @@ 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_NOT_CALLED; + self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; } if (self->private_impl.status < 0) { return; @@ -9582,8 +9594,7 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, return WUFFS_BASE__ERROR_BAD_RECEIVER; } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - self->private_impl.status = - WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_NOT_CALLED; + self->private_impl.status = WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING; } if (self->private_impl.status < 0) { return self->private_impl.status; diff --git a/test/c/std/adler32.c b/test/c/std/adler32.c index 9babfd1b..070c690a 100644 --- a/test/c/std/adler32.c +++ b/test/c/std/adler32.c @@ -126,8 +126,13 @@ void test_wuffs_adler32_golden() { int j; for (j = 0; j < 2; j++) { wuffs_adler32__hasher checksum = ((wuffs_adler32__hasher){}); - wuffs_adler32__hasher__check_wuffs_version(&checksum, sizeof checksum, - WUFFS_VERSION); + 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)); + return; + } uint32_t got = 0; size_t num_fragments = 0; @@ -186,8 +191,13 @@ void test_wuffs_adler32_pi() { int i; for (i = 0; i < 64; i++) { wuffs_adler32__hasher checksum = ((wuffs_adler32__hasher){}); - wuffs_adler32__hasher__check_wuffs_version(&checksum, sizeof checksum, - WUFFS_VERSION); + 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)); + return; + } uint32_t got = wuffs_adler32__hasher__update(&checksum, ((wuffs_base__slice_u8){ .ptr = (uint8_t*)(digits), @@ -214,8 +224,11 @@ const char* wuffs_bench_adler32(wuffs_base__io_buffer* dst, len = wuffs_base__u64__min(len, rlimit); } wuffs_adler32__hasher checksum = ((wuffs_adler32__hasher){}); - wuffs_adler32__hasher__check_wuffs_version(&checksum, sizeof checksum, - WUFFS_VERSION); + wuffs_base__status z = wuffs_adler32__hasher__check_wuffs_version( + &checksum, sizeof checksum, WUFFS_VERSION); + if (z) { + return wuffs_adler32__status__string(z); + } global_wuffs_adler32_unused_u32 = wuffs_adler32__hasher__update(&checksum, ((wuffs_base__slice_u8){ .ptr = src->ptr + src->ri, diff --git a/test/c/std/crc32.c b/test/c/std/crc32.c index 642f8089..a3122feb 100644 --- a/test/c/std/crc32.c +++ b/test/c/std/crc32.c @@ -126,8 +126,13 @@ void test_wuffs_crc32_ieee_golden() { int j; for (j = 0; j < 2; j++) { wuffs_crc32__ieee_hasher checksum = ((wuffs_crc32__ieee_hasher){}); - wuffs_crc32__ieee_hasher__check_wuffs_version(&checksum, sizeof checksum, - WUFFS_VERSION); + 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)); + return; + } uint32_t got = 0; size_t num_fragments = 0; @@ -186,8 +191,13 @@ void test_wuffs_crc32_ieee_pi() { int i; for (i = 0; i < 64; i++) { wuffs_crc32__ieee_hasher checksum = ((wuffs_crc32__ieee_hasher){}); - wuffs_crc32__ieee_hasher__check_wuffs_version(&checksum, sizeof checksum, - WUFFS_VERSION); + 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)); + return; + } uint32_t got = wuffs_crc32__ieee_hasher__update( &checksum, ((wuffs_base__slice_u8){ .ptr = (uint8_t*)(digits), @@ -214,8 +224,11 @@ const char* wuffs_bench_crc32_ieee(wuffs_base__io_buffer* dst, len = wuffs_base__u64__min(len, rlimit); } wuffs_crc32__ieee_hasher checksum = ((wuffs_crc32__ieee_hasher){}); - wuffs_crc32__ieee_hasher__check_wuffs_version(&checksum, sizeof checksum, - WUFFS_VERSION); + wuffs_base__status z = wuffs_crc32__ieee_hasher__check_wuffs_version( + &checksum, sizeof checksum, WUFFS_VERSION); + if (z) { + return wuffs_crc32__status__string(z); + } global_wuffs_crc32_unused_u32 = wuffs_crc32__ieee_hasher__update(&checksum, ((wuffs_base__slice_u8){ .ptr = src->ptr + src->ri, diff --git a/test/c/std/deflate.c b/test/c/std/deflate.c index df143984..bd454526 100644 --- a/test/c/std/deflate.c +++ b/test/c/std/deflate.c @@ -131,7 +131,14 @@ const char* wuffs_deflate_decode(wuffs_base__io_buffer* dst, uint64_t wlimit, uint64_t rlimit) { wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){}); - wuffs_deflate__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + 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)); + return false; + } + while (true) { wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(dst); if (wlimit) { @@ -142,17 +149,17 @@ const char* wuffs_deflate_decode(wuffs_base__io_buffer* dst, set_reader_limit(&src_reader, rlimit); } - wuffs_base__status s = + wuffs_base__status z = wuffs_deflate__decoder__decode(&dec, dst_writer, src_reader); - if (s == WUFFS_BASE__STATUS_OK) { + if (z == WUFFS_BASE__STATUS_OK) { return NULL; } - if ((wlimit && (s == WUFFS_BASE__SUSPENSION_SHORT_WRITE)) || - (rlimit && (s == WUFFS_BASE__SUSPENSION_SHORT_READ))) { + if ((wlimit && (z == WUFFS_BASE__SUSPENSION_SHORT_WRITE)) || + (rlimit && (z == WUFFS_BASE__SUSPENSION_SHORT_READ))) { continue; } - return wuffs_deflate__status__string(s); + return wuffs_deflate__status__string(z); } } @@ -239,31 +246,36 @@ void test_wuffs_deflate_decode_split_src() { got.wi = 0; wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){}); - wuffs_deflate__decoder__check_wuffs_version(&dec, sizeof dec, - WUFFS_VERSION); + 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)); + return; + } src.closed = false; src.ri = gt->src_offset0; src.wi = split; - wuffs_base__status s0 = + wuffs_base__status z0 = wuffs_deflate__decoder__decode(&dec, dst_writer, src_reader); src.closed = true; src.ri = split; src.wi = gt->src_offset1; - wuffs_base__status s1 = + wuffs_base__status z1 = wuffs_deflate__decoder__decode(&dec, dst_writer, src_reader); - if (s0 != WUFFS_BASE__SUSPENSION_SHORT_READ) { - FAIL("i=%d: s0: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", i, s0, - wuffs_deflate__status__string(s0), WUFFS_BASE__SUSPENSION_SHORT_READ, + 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, wuffs_deflate__status__string(WUFFS_BASE__SUSPENSION_SHORT_READ)); return; } - if (s1 != WUFFS_BASE__STATUS_OK) { - FAIL("i=%d: s1: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", i, s1, - wuffs_deflate__status__string(s1), WUFFS_BASE__STATUS_OK, + 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, wuffs_deflate__status__string(WUFFS_BASE__STATUS_OK)); return; } @@ -283,7 +295,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_s) { + wuffs_base__status want_z) { src->ri = gt->src_offset0; src->wi = gt->src_offset1; got->ri = 0; @@ -296,13 +308,13 @@ bool do_test_wuffs_deflate_history(int i, set_writer_limit(&dst_writer, limit); - wuffs_base__status got_s = + wuffs_base__status got_z = wuffs_deflate__decoder__decode(dec, dst_writer, src_reader); - if (got_s != want_s) { + if (got_z != want_z) { FAIL("i=%d: starting_history_index=0x%04" PRIX32 ": decode status: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", - i, starting_history_index, got_s, wuffs_deflate__status__string(got_s), - want_s, wuffs_deflate__status__string(want_s)); + i, starting_history_index, got_z, wuffs_deflate__status__string(got_z), + want_z, wuffs_deflate__status__string(want_z)); return false; } return true; @@ -330,8 +342,13 @@ void test_wuffs_deflate_history_full() { int i; for (i = -2; i <= +2; i++) { wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){}); - wuffs_deflate__decoder__check_wuffs_version(&dec, sizeof dec, - WUFFS_VERSION); + 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)); + return; + } if (!do_test_wuffs_deflate_history( i, gt, &src, &got, &dec, 0, want.wi + i, @@ -397,8 +414,13 @@ void test_wuffs_deflate_history_partial() { const uint32_t fragment_length = 4; wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){}); - wuffs_deflate__decoder__check_wuffs_version(&dec, sizeof dec, - WUFFS_VERSION); + 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)); + return; + } if (!do_test_wuffs_deflate_history(i, gt, &src, &got, &dec, starting_history_index, fragment_length, @@ -481,7 +503,13 @@ void test_wuffs_deflate_table_redirect() { // 2nd is the key in the second level table (variable bits). wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){}); - wuffs_deflate__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + 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)); + return; + } int i; int n = 0; @@ -500,9 +528,9 @@ void test_wuffs_deflate_table_redirect() { dec.private_impl.f_code_lengths[n++] = 13; dec.private_impl.f_code_lengths[n++] = 13; - wuffs_base__status s = wuffs_deflate__decoder__init_huff(&dec, 0, 0, n, 257); - if (s) { - FAIL("%s", wuffs_deflate__status__string(s)); + z = wuffs_deflate__decoder__init_huff(&dec, 0, 0, n, 257); + if (z) { + FAIL("init_huff: %" PRIi32 " (%s)", z, wuffs_deflate__status__string(z)); return; } diff --git a/test/c/std/gif.c b/test/c/std/gif.c index 231a6d7b..30b3b7c6 100644 --- a/test/c/std/gif.c +++ b/test/c/std/gif.c @@ -72,12 +72,11 @@ void test_basic_bad_receiver() { CHECK_FOCUS(__func__); wuffs_base__image_config ic = ((wuffs_base__image_config){}); wuffs_base__io_reader src = ((wuffs_base__io_reader){}); - wuffs_base__status status = + wuffs_base__status z = wuffs_gif__decoder__decode_image_config(NULL, &ic, src); - if (status != WUFFS_BASE__ERROR_BAD_RECEIVER) { - FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", - status, wuffs_gif__status__string(status), - WUFFS_BASE__ERROR_BAD_RECEIVER, + 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, wuffs_gif__status__string(WUFFS_BASE__ERROR_BAD_RECEIVER)); } } @@ -85,12 +84,11 @@ void test_basic_bad_receiver() { void test_basic_bad_sizeof_receiver() { CHECK_FOCUS(__func__); wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_gif__decoder__check_wuffs_version(&dec, 0, WUFFS_VERSION); - if (dec.private_impl.status != WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER) { - FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", - dec.private_impl.status, - wuffs_gif__status__string(dec.private_impl.status), - WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER, + 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, wuffs_gif__status__string(WUFFS_BASE__ERROR_BAD_SIZEOF_RECEIVER)); return; } @@ -99,13 +97,11 @@ void test_basic_bad_sizeof_receiver() { void test_basic_bad_wuffs_version() { CHECK_FOCUS(__func__); wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, - WUFFS_VERSION ^ 0x123456789ABC); - if (dec.private_impl.status != WUFFS_BASE__ERROR_BAD_WUFFS_VERSION) { - FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", - dec.private_impl.status, - wuffs_gif__status__string(dec.private_impl.status), - WUFFS_BASE__ERROR_BAD_WUFFS_VERSION, + 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, wuffs_gif__status__string(WUFFS_BASE__ERROR_BAD_WUFFS_VERSION)); return; } @@ -116,14 +112,14 @@ void test_basic_check_wuffs_version_not_called() { wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); wuffs_base__image_config ic = ((wuffs_base__image_config){}); wuffs_base__io_reader src = ((wuffs_base__io_reader){}); - wuffs_base__status status = + wuffs_base__status z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src); - if (status != WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_NOT_CALLED) { - FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", - status, wuffs_gif__status__string(status), - WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_NOT_CALLED, + 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), + WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING, wuffs_gif__status__string( - WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_NOT_CALLED)); + WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_MISSING)); } } @@ -198,14 +194,20 @@ void test_basic_status_used_package() { void test_basic_sub_struct_initializer() { CHECK_FOCUS(__func__); wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + 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)); + return; + } if (dec.private_impl.magic != WUFFS_BASE__MAGIC) { - FAIL("outer magic: got %u, want %u", dec.private_impl.magic, - WUFFS_BASE__MAGIC); + FAIL("outer magic: got %" PRIu32 ", want %" PRIu32 "", + dec.private_impl.magic, WUFFS_BASE__MAGIC); return; } if (dec.private_impl.f_lzw.private_impl.magic != WUFFS_BASE__MAGIC) { - FAIL("inner magic: got %u, want %u", + FAIL("inner magic: got %" PRIu32 ", want %" PRIu32, dec.private_impl.f_lzw.private_impl.magic, WUFFS_BASE__MAGIC); return; } @@ -216,39 +218,42 @@ void test_basic_sub_struct_initializer() { const char* wuffs_gif_decode(wuffs_base__io_buffer* dst, wuffs_base__io_buffer* src) { wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + wuffs_base__status z = + wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + if (z) { + return wuffs_gif__status__string(z); + } wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){}); wuffs_base__image_config ic = ((wuffs_base__image_config){}); wuffs_base__frame_config fc = ((wuffs_base__frame_config){}); wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(src); - wuffs_base__status s = - wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader); - if (s) { - return wuffs_gif__status__string(s); + z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader); + if (z) { + return wuffs_gif__status__string(z); } - s = wuffs_base__pixel_buffer__set_from_slice( + z = wuffs_base__pixel_buffer__set_from_slice( &pb, wuffs_base__image_config__pixel_config(&ic), ((wuffs_base__slice_u8){ .ptr = global_pixel_buffer, .len = WUFFS_TESTLIB_ARRAY_SIZE(global_pixel_buffer), })); - if (s) { - return wuffs_gif__status__string(s); + if (z) { + return wuffs_gif__status__string(z); } while (true) { - s = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader); - if (s) { - if (s == WUFFS_BASE__SUSPENSION_END_OF_DATA) { + z = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader); + if (z) { + if (z == WUFFS_BASE__SUSPENSION_END_OF_DATA) { break; } - return wuffs_gif__status__string(s); + return wuffs_gif__status__string(z); } - s = wuffs_gif__decoder__decode_frame(&dec, &pb, 0, 0, src_reader, + z = wuffs_gif__decoder__decode_frame(&dec, &pb, 0, 0, src_reader, ((wuffs_base__slice_u8){})); - if (s) { - return wuffs_gif__status__string(s); + if (z) { + return wuffs_gif__status__string(z); } const char* msg = copy_to_io_buffer_from_pixel_buffer( @@ -274,7 +279,13 @@ bool do_test_wuffs_gif_decode(const char* filename, } wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + 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)); + return false; + } wuffs_base__frame_config fc = ((wuffs_base__frame_config){}); wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){}); @@ -282,11 +293,10 @@ 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); - wuffs_base__status status = - wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader); - if (status != WUFFS_BASE__STATUS_OK) { - FAIL("decode_image_config: got %" PRIi32 " (%s)", status, - wuffs_gif__status__string(status)); + 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)); return false; } if (wuffs_base__image_config__pixel_format(&ic) != @@ -317,14 +327,14 @@ bool do_test_wuffs_gif_decode(const char* filename, FAIL("first_frame_is_opaque: got false, want true"); return false; } - status = wuffs_base__pixel_buffer__set_from_slice( + z = wuffs_base__pixel_buffer__set_from_slice( &pb, wuffs_base__image_config__pixel_config(&ic), ((wuffs_base__slice_u8){ .ptr = global_pixel_buffer, .len = WUFFS_TESTLIB_ARRAY_SIZE(global_pixel_buffer), })); - if (status) { - FAIL("set_from_slice: %s", wuffs_gif__status__string(status)); + if (z) { + FAIL("set_from_slice: %s", wuffs_gif__status__string(z)); return false; } } @@ -338,16 +348,15 @@ bool do_test_wuffs_gif_decode(const char* filename, } size_t old_ri = src.ri; - wuffs_base__status status = + wuffs_base__status z = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader); - if (status == WUFFS_BASE__STATUS_OK) { + if (z == WUFFS_BASE__STATUS_OK) { break; } - if (status != WUFFS_BASE__SUSPENSION_SHORT_READ) { + if (z != WUFFS_BASE__SUSPENSION_SHORT_READ) { FAIL("decode_frame_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", - status, wuffs_gif__status__string(status), - WUFFS_BASE__SUSPENSION_SHORT_READ, + z, wuffs_gif__status__string(z), WUFFS_BASE__SUSPENSION_SHORT_READ, wuffs_gif__status__string(WUFFS_BASE__SUSPENSION_SHORT_READ)); return false; } @@ -370,15 +379,15 @@ bool do_test_wuffs_gif_decode(const char* filename, } size_t old_ri = src.ri; - wuffs_base__status status = wuffs_gif__decoder__decode_frame( + wuffs_base__status z = wuffs_gif__decoder__decode_frame( &dec, &pb, 0, 0, src_reader, ((wuffs_base__slice_u8){})); - if (status == WUFFS_BASE__STATUS_OK) { + if (z == WUFFS_BASE__STATUS_OK) { break; } - if (status != WUFFS_BASE__SUSPENSION_SHORT_READ) { - FAIL("decode_frame: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", status, - wuffs_gif__status__string(status), WUFFS_BASE__SUSPENSION_SHORT_READ, + 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, wuffs_gif__status__string(WUFFS_BASE__SUSPENSION_SHORT_READ)); return false; } @@ -442,12 +451,11 @@ bool do_test_wuffs_gif_decode(const char* filename, return false; } wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); - wuffs_base__status status = wuffs_gif__decoder__decode_frame( + wuffs_base__status z = wuffs_gif__decoder__decode_frame( &dec, &pb, 0, 0, src_reader, ((wuffs_base__slice_u8){})); - if (status != WUFFS_BASE__SUSPENSION_END_OF_DATA) { - FAIL("decode_frame: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", status, - wuffs_gif__status__string(status), - WUFFS_BASE__SUSPENSION_END_OF_DATA, + 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, wuffs_gif__status__string(WUFFS_BASE__SUSPENSION_END_OF_DATA)); return false; } @@ -471,24 +479,28 @@ void test_wuffs_gif_call_sequence() { } wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + 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)); + return; + } wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); - wuffs_base__status status = - wuffs_gif__decoder__decode_image_config(&dec, NULL, src_reader); - if (status != WUFFS_BASE__STATUS_OK) { - FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", - status, wuffs_gif__status__string(status), WUFFS_BASE__STATUS_OK, + 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, wuffs_gif__status__string(WUFFS_BASE__STATUS_OK)); return; } - status = wuffs_gif__decoder__decode_image_config(&dec, NULL, src_reader); - if (status != WUFFS_BASE__ERROR_INVALID_CALL_SEQUENCE) { - FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", - status, wuffs_gif__status__string(status), - WUFFS_BASE__ERROR_INVALID_CALL_SEQUENCE, + 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, wuffs_gif__status__string(WUFFS_BASE__ERROR_INVALID_CALL_SEQUENCE)); return; } @@ -506,17 +518,22 @@ bool do_test_wuffs_gif_decode_animated( } wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + 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)); + return false; + } wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){}); wuffs_base__image_config ic = ((wuffs_base__image_config){}); wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); - wuffs_base__status status = - wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader); - if (status != WUFFS_BASE__STATUS_OK) { - FAIL("decode_image_config: got %" PRIi32 " (%s)", status, - wuffs_gif__status__string(status)); + 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)); return false; } @@ -525,32 +542,32 @@ bool do_test_wuffs_gif_decode_animated( wuffs_base__image_config__num_loops(&ic), want_num_loops); return false; } - status = wuffs_base__pixel_buffer__set_from_slice( + z = wuffs_base__pixel_buffer__set_from_slice( &pb, wuffs_base__image_config__pixel_config(&ic), ((wuffs_base__slice_u8){ .ptr = global_pixel_buffer, .len = WUFFS_TESTLIB_ARRAY_SIZE(global_pixel_buffer), })); - if (status) { - FAIL("set_from_slice: %s", wuffs_gif__status__string(status)); + if (z) { + FAIL("set_from_slice: %s", wuffs_gif__status__string(z)); return false; } uint32_t i; for (i = 0; i < want_num_frames; i++) { wuffs_base__frame_config fc = ((wuffs_base__frame_config){}); - status = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader); - if (status != WUFFS_BASE__STATUS_OK) { - FAIL("decode_frame_config #%" PRIu32 ": got %" PRIi32 " (%s)", i, status, - wuffs_gif__status__string(status)); + 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)); return false; } - status = wuffs_gif__decoder__decode_frame(&dec, &pb, 0, 0, src_reader, - ((wuffs_base__slice_u8){})); - if (status != WUFFS_BASE__STATUS_OK) { - FAIL("decode_frame #%" PRIu32 ": got %" PRIi32 " (%s)", i, status, - wuffs_gif__status__string(status)); + 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)); return false; } @@ -570,11 +587,11 @@ bool do_test_wuffs_gif_decode_animated( } // There should be no more frames. - status = wuffs_gif__decoder__decode_frame(&dec, &pb, 0, 0, src_reader, - ((wuffs_base__slice_u8){})); - if (status != WUFFS_BASE__SUSPENSION_END_OF_DATA) { - FAIL("decode_frame: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", status, - wuffs_gif__status__string(status), WUFFS_BASE__SUSPENSION_END_OF_DATA, + 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, wuffs_gif__status__string(WUFFS_BASE__SUSPENSION_END_OF_DATA)); return false; } @@ -627,13 +644,18 @@ void test_wuffs_gif_decode_frame_out_of_bounds() { } wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + 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)); + return; + } wuffs_base__image_config ic = ((wuffs_base__image_config){}); wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); - wuffs_base__status s = - wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader); - if (s) { - FAIL("decode_image_config: %s", wuffs_gif__status__string(s)); + z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader); + if (z) { + FAIL("decode_image_config: %s", wuffs_gif__status__string(z)); return; } @@ -697,15 +719,20 @@ void test_wuffs_gif_decode_input_is_a_png() { } wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + 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)); + return; + } wuffs_base__image_config ic = ((wuffs_base__image_config){}); wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); - wuffs_base__status status = - wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader); - if (status != WUFFS_GIF__ERROR_BAD_HEADER) { - FAIL("decode_image_config: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", - status, wuffs_gif__status__string(status), WUFFS_GIF__ERROR_BAD_HEADER, + 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, wuffs_gif__status__string(WUFFS_GIF__ERROR_BAD_HEADER)); return; } @@ -720,14 +747,19 @@ bool do_test_wuffs_gif_num_decoded(bool frame_config) { } wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + 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)); + return false; + } wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){}); if (!frame_config) { wuffs_base__image_config ic = ((wuffs_base__image_config){}); - wuffs_base__status z = - wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader); + 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)); return false; diff --git a/test/c/std/gzip.c b/test/c/std/gzip.c index d10e1680..fbd689f8 100644 --- a/test/c/std/gzip.c +++ b/test/c/std/gzip.c @@ -86,7 +86,11 @@ const char* wuffs_gzip_decode(wuffs_base__io_buffer* dst, uint64_t wlimit, uint64_t rlimit) { wuffs_gzip__decoder dec = ((wuffs_gzip__decoder){}); - wuffs_gzip__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + wuffs_base__status z = + wuffs_gzip__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + if (z) { + return wuffs_gzip__status__string(z); + } while (true) { wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(dst); @@ -98,17 +102,17 @@ const char* wuffs_gzip_decode(wuffs_base__io_buffer* dst, set_reader_limit(&src_reader, rlimit); } - wuffs_base__status s = + wuffs_base__status z = wuffs_gzip__decoder__decode(&dec, dst_writer, src_reader); - if (s == WUFFS_BASE__STATUS_OK) { + if (z == WUFFS_BASE__STATUS_OK) { return NULL; } - if ((wlimit && (s == WUFFS_BASE__SUSPENSION_SHORT_WRITE)) || - (rlimit && (s == WUFFS_BASE__SUSPENSION_SHORT_READ))) { + if ((wlimit && (z == WUFFS_BASE__SUSPENSION_SHORT_WRITE)) || + (rlimit && (z == WUFFS_BASE__SUSPENSION_SHORT_READ))) { continue; } - return wuffs_gzip__status__string(s); + return wuffs_gzip__status__string(z); } } @@ -134,7 +138,13 @@ bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) { int end_limit; for (end_limit = 0; end_limit < 10; end_limit++) { wuffs_gzip__decoder dec = ((wuffs_gzip__decoder){}); - wuffs_gzip__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + 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)); + return false; + } wuffs_gzip__decoder__set_ignore_checksum(&dec, ignore_checksum); got.wi = 0; wuffs_base__io_writer got_writer = wuffs_base__io_buffer__writer(&got); @@ -145,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 = 0; + wuffs_base__status want_z = 0; if (i == 0) { if (end_limit == 0) { continue; @@ -155,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 = WUFFS_BASE__SUSPENSION_SHORT_READ; + want_z = WUFFS_BASE__SUSPENSION_SHORT_READ; } else { - want = (bad_checksum && !ignore_checksum) - ? WUFFS_GZIP__ERROR_BAD_CHECKSUM - : WUFFS_BASE__STATUS_OK; + want_z = (bad_checksum && !ignore_checksum) + ? WUFFS_GZIP__ERROR_BAD_CHECKSUM + : WUFFS_BASE__STATUS_OK; } - wuffs_base__status status = + wuffs_base__status got_z = wuffs_gzip__decoder__decode(&dec, got_writer, src_reader); - if (status != want) { + if (got_z != want_z) { FAIL("end_limit=%d: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", - end_limit, status, wuffs_gzip__status__string(status), want, - wuffs_gzip__status__string(want)); + end_limit, got_z, wuffs_gzip__status__string(got_z), want_z, + wuffs_gzip__status__string(want_z)); return false; } } diff --git a/test/c/std/lzw.c b/test/c/std/lzw.c index 45562d2c..744915c6 100644 --- a/test/c/std/lzw.c +++ b/test/c/std/lzw.c @@ -101,7 +101,13 @@ bool do_test_wuffs_lzw_decode(const char* src_filename, } wuffs_lzw__decoder dec = ((wuffs_lzw__decoder){}); - wuffs_lzw__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + 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)); + return false; + } wuffs_lzw__decoder__set_literal_width(&dec, literal_width); int num_iters = 0; while (true) { @@ -117,21 +123,19 @@ bool do_test_wuffs_lzw_decode(const char* src_filename, size_t old_wi = got.wi; size_t old_ri = src.ri; - wuffs_base__status status = - wuffs_lzw__decoder__decode(&dec, got_writer, src_reader); - if (status == WUFFS_BASE__STATUS_OK) { + z = wuffs_lzw__decoder__decode(&dec, got_writer, src_reader); + if (z == WUFFS_BASE__STATUS_OK) { if (src.ri != src.wi) { FAIL("decode returned \"ok\" but src was not exhausted"); return false; } break; } - if ((status != WUFFS_BASE__SUSPENSION_SHORT_READ) && - (status != WUFFS_BASE__SUSPENSION_SHORT_WRITE)) { + if ((z != WUFFS_BASE__SUSPENSION_SHORT_READ) && + (z != WUFFS_BASE__SUSPENSION_SHORT_WRITE)) { FAIL("decode: got %" PRIi32 " (%s), want %" PRIi32 " (%s) or %" PRIi32 " (%s)", - status, wuffs_lzw__status__string(status), - WUFFS_BASE__SUSPENSION_SHORT_READ, + z, wuffs_lzw__status__string(z), 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)); @@ -228,11 +232,16 @@ bool do_bench_wuffs_lzw_decode(const char* filename, uint64_t iters_unscaled) { dst.wi = 0; src.ri = 1; // Skip the literal width. wuffs_lzw__decoder dec = ((wuffs_lzw__decoder){}); - wuffs_lzw__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); - wuffs_base__status s = - wuffs_lzw__decoder__decode(&dec, dst_writer, src_reader); - if (s) { - FAIL("decode: %" PRIi32 " (%s)", s, wuffs_lzw__status__string(s)); + 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)); + return false; + } + z = wuffs_lzw__decoder__decode(&dec, dst_writer, src_reader); + if (z) { + FAIL("decode: %" PRIi32 " (%s)", z, wuffs_lzw__status__string(z)); return false; } n_bytes += dst.wi; diff --git a/test/c/std/zlib.c b/test/c/std/zlib.c index aa59c0e9..3ef2fff9 100644 --- a/test/c/std/zlib.c +++ b/test/c/std/zlib.c @@ -86,7 +86,11 @@ const char* wuffs_zlib_decode(wuffs_base__io_buffer* dst, uint64_t wlimit, uint64_t rlimit) { wuffs_zlib__decoder dec = ((wuffs_zlib__decoder){}); - wuffs_zlib__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + wuffs_base__status z = + wuffs_zlib__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + if (z) { + return wuffs_zlib__status__string(z); + } while (true) { wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(dst); @@ -98,17 +102,17 @@ const char* wuffs_zlib_decode(wuffs_base__io_buffer* dst, set_reader_limit(&src_reader, rlimit); } - wuffs_base__status s = + wuffs_base__status z = wuffs_zlib__decoder__decode(&dec, dst_writer, src_reader); - if (s == WUFFS_BASE__STATUS_OK) { + if (z == WUFFS_BASE__STATUS_OK) { return NULL; } - if ((wlimit && (s == WUFFS_BASE__SUSPENSION_SHORT_WRITE)) || - (rlimit && (s == WUFFS_BASE__SUSPENSION_SHORT_READ))) { + if ((wlimit && (z == WUFFS_BASE__SUSPENSION_SHORT_WRITE)) || + (rlimit && (z == WUFFS_BASE__SUSPENSION_SHORT_READ))) { continue; } - return wuffs_zlib__status__string(s); + return wuffs_zlib__status__string(z); } } @@ -133,7 +137,13 @@ bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) { int end_limit; for (end_limit = 0; end_limit < 10; end_limit++) { wuffs_zlib__decoder dec = ((wuffs_zlib__decoder){}); - wuffs_zlib__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + 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)); + return false; + } wuffs_zlib__decoder__set_ignore_checksum(&dec, ignore_checksum); got.wi = 0; wuffs_base__io_writer got_writer = wuffs_base__io_buffer__writer(&got); @@ -144,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 = 0; + wuffs_base__status want_z = 0; if (i == 0) { if (end_limit == 0) { continue; @@ -154,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 = WUFFS_BASE__SUSPENSION_SHORT_READ; + want_z = WUFFS_BASE__SUSPENSION_SHORT_READ; } else { - want = (bad_checksum && !ignore_checksum) - ? WUFFS_ZLIB__ERROR_BAD_CHECKSUM - : WUFFS_BASE__STATUS_OK; + want_z = (bad_checksum && !ignore_checksum) + ? WUFFS_ZLIB__ERROR_BAD_CHECKSUM + : WUFFS_BASE__STATUS_OK; } - wuffs_base__status status = + wuffs_base__status got_z = wuffs_zlib__decoder__decode(&dec, got_writer, src_reader); - if (status != want) { + if (got_z != want_z) { FAIL("end_limit=%d: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", - end_limit, status, wuffs_zlib__status__string(status), want, - wuffs_zlib__status__string(want)); + end_limit, got_z, wuffs_zlib__status__string(got_z), want_z, + wuffs_zlib__status__string(want_z)); return false; } }