diff --git a/cmd/wuffs-c/internal/cgen/base/core-private.h b/cmd/wuffs-c/internal/cgen/base/core-private.h index 97886a75..a48f55f3 100644 --- a/cmd/wuffs-c/internal/cgen/base/core-private.h +++ b/cmd/wuffs-c/internal/cgen/base/core-private.h @@ -14,8 +14,8 @@ // See the License for the specific language governing permissions and // limitations under the License. -static inline void wuffs_base__ignore_check_wuffs_version_status( - wuffs_base__status z) {} +static inline void // +wuffs_base__ignore_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, @@ -438,6 +438,7 @@ wuffs_base__acknowledge_potentially_unused_functions__core_private() static inline void wuffs_base__acknowledge_potentially_unused_functions__core_private() { + (void)(wuffs_base__ignore_status); (void)(wuffs_base__load_u16be); (void)(wuffs_base__load_u16le); (void)(wuffs_base__load_u24be); diff --git a/cmd/wuffs-c/internal/cgen/base/core-public.h b/cmd/wuffs-c/internal/cgen/base/core-public.h index 20f11a50..0f09e048 100644 --- a/cmd/wuffs-c/internal/cgen/base/core-public.h +++ b/cmd/wuffs-c/internal/cgen/base/core-public.h @@ -66,6 +66,14 @@ #define WUFFS_BASE__WARN_UNUSED_RESULT #endif +// Flags for wuffs_foo__bar__initialize functions. + +// WUFFS_INITIALIZE__ALREADY_ZEROED means that the "self" receiver struct value +// has already been set to all zeroes. +#define WUFFS_INITIALIZE__ALREADY_ZEROED ((uint32_t)0x00000001) + +// -------- + // 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 902f3d57..f0217498 100644 --- a/cmd/wuffs-c/internal/cgen/cgen.go +++ b/cmd/wuffs-c/internal/cgen/cgen.go @@ -470,6 +470,11 @@ func (g *gen) genHeader(b *buffer) error { } b.writes("// ---------------- Public Initializer Prototypes\n\n") + b.writes("// For any given \"wuffs_foo__bar* self\", \"wuffs_foo__bar__initialize(self,\n") + b.writes("// etc)\" should be called before any other \"wuffs_foo__bar__xxx(self, etc)\".\n") + b.writes("//\n") + b.writes("// Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version.\n") + b.writes("// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for initialize_flags.\n\n") for _, n := range g.structList { if n.Public() { if err := g.writeInitializerPrototype(b, n); err != nil { @@ -853,9 +858,16 @@ func (g *gen) writeCppMethods(b *buffer, n *a.Struct) error { // 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" + + "initialize(size_t sizeof_star_self, uint64_t wuffs_version, uint32_t initialize_flags) {\n") + b.printf("return %s%s__initialize(this, sizeof_star_self, wuffs_version, initialize_flags);\n}\n\n", + g.pkgPrefix, structName) + + // Deprecated: use wuffs_foo__bar__initialize instead of + // wuffs_foo__bar__check_wuffs_version. 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") - b.printf("return %s%s__check_wuffs_version(this, sizeof_star_self, wuffs_version);\n}\n\n", + b.printf("return %s%s__initialize(this, sizeof_star_self, wuffs_version, WUFFS_INITIALIZE__ALREADY_ZEROED);\n}\n\n", g.pkgPrefix, structName) structID := n.QID()[1] @@ -904,15 +916,8 @@ var ( func (g *gen) writeInitializerSignature(b *buffer, n *a.Struct, public bool) error { structName := n.QID().Str(g.tm) - if public { - b.printf("// %s%s__check_wuffs_version is an initializer function.\n", g.pkgPrefix, structName) - b.printf("//\n") - b.printf("// It should be called before any other %s%s__* function.\n", g.pkgPrefix, structName) - b.printf("//\n") - b.printf("// Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version.\n") - } 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)", + "%s%s__initialize(%s%s *self, size_t sizeof_star_self, uint64_t wuffs_version, uint32_t initialize_flags)", g.pkgPrefix, structName, g.pkgPrefix, structName) return nil } @@ -930,6 +935,13 @@ func (g *gen) writeInitializerPrototype(b *buffer, n *a.Struct) error { return err } b.writes(";\n\n") + + b.writes("// Deprecated: use wuffs_foo__bar__initialize instead of\n") + b.writes("// wuffs_foo__bar__check_wuffs_version.\n") + 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);\n\n", + g.pkgPrefix, n.QID().Str(g.tm), g.pkgPrefix, n.QID().Str(g.tm)) + if n.Public() { if err := g.writeSizeofSignature(b, n); err != nil { return err @@ -960,6 +972,8 @@ func (g *gen) writeInitializerImpl(b *buffer, n *a.Struct) error { b.writes("return wuffs_base__error__check_wuffs_version_not_applicable;\n") b.writes("}\n") + // TODO: examine (initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED). + // Call any ctors on sub-structs. for _, f := range n.Fields() { f := f.AsField() @@ -983,8 +997,8 @@ func (g *gen) writeInitializerImpl(b *buffer, n *a.Struct) error { } 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", + b.printf("wuffs_base__status z = %s%s__initialize("+ + "&self->private_impl.%s%s, sizeof(self->private_impl.%s%s), WUFFS_VERSION, initialize_flags);\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") @@ -994,6 +1008,15 @@ func (g *gen) writeInitializerImpl(b *buffer, n *a.Struct) error { b.writes("return NULL;\n") b.writes("}\n\n") + // Deprecated: use wuffs_foo__bar__initialize instead of + // wuffs_foo__bar__check_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, n.QID().Str(g.tm), g.pkgPrefix, n.QID().Str(g.tm)) + b.printf("return %s%s__initialize(self, sizeof_star_self, wuffs_version, WUFFS_INITIALIZE__ALREADY_ZEROED);\n", + g.pkgPrefix, n.QID().Str(g.tm)) + b.writes("}\n\n") + if n.Public() { if err := g.writeSizeofSignature(b, n); err != nil { return err diff --git a/cmd/wuffs-c/internal/cgen/data.go b/cmd/wuffs-c/internal/cgen/data.go index c4a79076..48e03536 100644 --- a/cmd/wuffs-c/internal/cgen/data.go +++ b/cmd/wuffs-c/internal/cgen/data.go @@ -32,9 +32,9 @@ const baseImageImplC = "" + "" const baseCorePrivateH = "" + - "static 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 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// WUFFS_BASE__DISABLED is a magic number to indicate that a non-recoverable\n// error was previously encountered.\n//\n// Its (non-zero) value is arbitrary, based on md5sum(\"disabled\").\n#define WUFFS_BASE__DISABLED ((uint32_t)0x075AE3D2)\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) { \\\n goto ok; \\\n } else if (*status != '$') { \\\n goto exit; \\\n } \\\n coro_susp_point = n; \\\n goto suspend; " + - " \\\n case n:;\n\n// Clang also defines \"__GNUC__\".\n#if defined(__GNUC__)\n#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1))\n#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))\n#else\n#define WUFFS_BASE__LIKELY(expr) (expr)\n#define WUFFS_BASE__UNLIKELY(expr) (expr)\n#endif\n\n// The helpers below are functions, instead of macros, because their arguments\n// can be an expression that we shouldn't 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" + + "static inline void //\nwuffs_base__ignore_status(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 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// WUFFS_BASE__DISABLED is a magic number to indicate that a non-recoverable\n// error was previously encountered.\n//\n// Its (non-zero) value is arbitrary, based on md5sum(\"disabled\").\n#define WUFFS_BASE__DISABLED ((uint32_t)0x075AE3D2)\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) { \\\n goto ok; \\\n } else if (*status != '$') { \\\n goto exit; \\\n } \\\n coro_susp_point = n; \\\n goto suspend; " + + " \\\n case n:;\n\n// Clang also defines \"__GNUC__\".\n#if defined(__GNUC__)\n#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1))\n#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))\n#else\n#define WUFFS_BASE__LIKELY(expr) (expr)\n#define WUFFS_BASE__UNLIKELY(expr) (expr)\n#endif\n\n// The helpers below are functions, instead of macros, because their arguments\n// can be an expression that we shouldn't 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" + "" + "// ---------------- 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" + @@ -56,15 +56,17 @@ const baseCorePrivateH = "" + "" + "// ---------------- Slices and Tables (Utility)\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__utility__null_slice_u8() {\n return ((wuffs_base__slice_u8){});\n}\n\n" + "" + - "// ---------------- Bureaucracy re -Wunused-function\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__core_private()\n WUFFS_BASE__POTENTIALLY_UNUSED;\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__core_private() {\n (void)(wuffs_base__load_u16be);\n (void)(wuffs_base__load_u16le);\n (void)(wuffs_base__load_u24be);\n (void)(wuffs_base__load_u24le);\n (void)(wuffs_base__load_u32be);\n (void)(wuffs_base__load_u32le);\n (void)(wuffs_base__load_u40be);\n (void)(wuffs_base__load_u40le);\n (void)(wuffs_base__load_u48be);\n (void)(wuffs_base__load_u48le);\n (void)(wuffs_base__load_u56be);\n (void)(wuffs_base__load_u56le);\n (void)(wuffs_base__load_u64be);\n (void)(wuffs_base__load_u64le);\n (void)(wuffs_base__load_u8be);\n (void)(wuffs_base__return_empty_struct);\n (void)(wuffs_base__slice_u8__copy_from_slice);\n (void)(wuffs_base__slice_u8__prefix);\n (void)(wuffs_base__slice_u8__suffix);\n (void)(wuffs_base__store_u16be);\n (void)(wuffs_base__store_u16le);\n (v" + - "oid)(wuffs_base__store_u24be);\n (void)(wuffs_base__store_u24le);\n (void)(wuffs_base__store_u32be);\n (void)(wuffs_base__store_u32le);\n (void)(wuffs_base__store_u40be);\n (void)(wuffs_base__store_u40le);\n (void)(wuffs_base__store_u48be);\n (void)(wuffs_base__store_u48le);\n (void)(wuffs_base__store_u56be);\n (void)(wuffs_base__store_u56le);\n (void)(wuffs_base__store_u64be);\n (void)(wuffs_base__store_u64le);\n (void)(wuffs_base__store_u8be);\n (void)(wuffs_base__table_u8__row);\n (void)(wuffs_base__u16__sat_add_indirect);\n (void)(wuffs_base__u16__sat_sub_indirect);\n (void)(wuffs_base__u32__sat_add_indirect);\n (void)(wuffs_base__u32__sat_sub_indirect);\n (void)(wuffs_base__u64__sat_add_indirect);\n (void)(wuffs_base__u64__sat_sub_indirect);\n (void)(wuffs_base__u8__sat_add_indirect);\n (void)(wuffs_base__u8__sat_sub_indirect);\n (void)(wuffs_base__utility__null_slice_u8);\n}\n" + + "// ---------------- Bureaucracy re -Wunused-function\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__core_private()\n WUFFS_BASE__POTENTIALLY_UNUSED;\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__core_private() {\n (void)(wuffs_base__ignore_status);\n (void)(wuffs_base__load_u16be);\n (void)(wuffs_base__load_u16le);\n (void)(wuffs_base__load_u24be);\n (void)(wuffs_base__load_u24le);\n (void)(wuffs_base__load_u32be);\n (void)(wuffs_base__load_u32le);\n (void)(wuffs_base__load_u40be);\n (void)(wuffs_base__load_u40le);\n (void)(wuffs_base__load_u48be);\n (void)(wuffs_base__load_u48le);\n (void)(wuffs_base__load_u56be);\n (void)(wuffs_base__load_u56le);\n (void)(wuffs_base__load_u64be);\n (void)(wuffs_base__load_u64le);\n (void)(wuffs_base__load_u8be);\n (void)(wuffs_base__return_empty_struct);\n (void)(wuffs_base__slice_u8__copy_from_slice);\n (void)(wuffs_base__slice_u8__prefix);\n (void)(wuffs_base__slice_u8__suffix);\n (void)(wuffs_base__store_u16be);\n " + + "(void)(wuffs_base__store_u16le);\n (void)(wuffs_base__store_u24be);\n (void)(wuffs_base__store_u24le);\n (void)(wuffs_base__store_u32be);\n (void)(wuffs_base__store_u32le);\n (void)(wuffs_base__store_u40be);\n (void)(wuffs_base__store_u40le);\n (void)(wuffs_base__store_u48be);\n (void)(wuffs_base__store_u48le);\n (void)(wuffs_base__store_u56be);\n (void)(wuffs_base__store_u56le);\n (void)(wuffs_base__store_u64be);\n (void)(wuffs_base__store_u64le);\n (void)(wuffs_base__store_u8be);\n (void)(wuffs_base__table_u8__row);\n (void)(wuffs_base__u16__sat_add_indirect);\n (void)(wuffs_base__u16__sat_sub_indirect);\n (void)(wuffs_base__u32__sat_add_indirect);\n (void)(wuffs_base__u32__sat_sub_indirect);\n (void)(wuffs_base__u64__sat_add_indirect);\n (void)(wuffs_base__u64__sat_sub_indirect);\n (void)(wuffs_base__u8__sat_add_indirect);\n (void)(wuffs_base__u8__sat_sub_indirect);\n (void)(wuffs_base__utility__null_slice_u8);\n}\n" + "" const baseCorePublicH = "" + "// 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 version, 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 pre-release label\n// and build metadata are part of the string representation (such as\n// \"1.2.3-beta+456.20181231\") but not the uint64_t representation.\n//\n// WUFFS_VERSION_PRE_RELEASE_LABEL (such as \"\", \"beta\" or \"rc.1\") being\n// non-empty denotes a developer preview, not a release version, and has no\n// backwards or forwards compatibility guarantees.\n//\n// WUFFS_VERSION_BUILD_METADATA_XXX, if non-zero, are the number of commits and\n// the last commit date in the repository used to build this library. Within\n// eac" + "h major.minor branch, the commit count should increase monotonically.\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_PRE_RELEASE_LABEL \"work.in.progress\"\n#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 0\n#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 0\n#define WUFFS_VERSION_STRING \"0.0.0+0.00000000\"\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.githubusercontent.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__POTENTIALLY_UNUSED __attribute__((unused))\n#define WUFFS_BASE" + - "__WARN_UNUSED_RESULT __attribute__((warn_unused_result))\n#else\n#define WUFFS_BASE__POTENTIALLY_UNUSED\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" + + "__WARN_UNUSED_RESULT __attribute__((warn_unused_result))\n#else\n#define WUFFS_BASE__POTENTIALLY_UNUSED\n#define WUFFS_BASE__WARN_UNUSED_RESULT\n#endif\n\n// Flags for wuffs_foo__bar__initialize functions.\n\n// WUFFS_INITIALIZE__ALREADY_ZEROED means that the \"self\" receiver struct value\n// has already been set to all zeroes.\n#define WUFFS_INITIALIZE__ALREADY_ZEROED ((uint32_t)0x00000001)\n\n" + + "" + + "// --------\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 pla" + + "ceholder 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 is either NULL (meaning OK) or a string message. That message is\n// human-readable, for programmers, but it is not for end users. It is not\n// localized, and does not contain additional contextual information such as a\n// source filename.\n//\n// Status strings are statically allocated and should never be free'd. They can\n// be compared by the == operator and not just by strcmp.\n//\n// Statuses come in four categories:\n// - OK: the request was completed, successfully.\n// - Warnings: the request was completed, unsuccessfully.\n// - Suspensions: the request was not completed, but can be re-tried.\n// - Errors: the request was not completed, permanently.\n//\n// When a function returns an incomplete status, a suspension means that that\n// function should be called again within a new context, such as after flushing\n// or re-filling an I/O buffer. An error means that an irrecoverable failure\n// state was reached.\ntypedef const char* wuffs_base__status;\n\n// !! INSERT wuffs_bas" + "e__status names.\n\nstatic inline bool //\nwuffs_base__status__is_complete(wuffs_base__status z) {\n return (z == NULL) || ((*z != '$') && (*z != '?'));\n}\n\nstatic inline bool //\nwuffs_base__status__is_error(wuffs_base__status z) {\n return z && (*z == '?');\n}\n\nstatic inline bool //\nwuffs_base__status__is_ok(wuffs_base__status z) {\n return z == NULL;\n}\n\nstatic inline bool //\nwuffs_base__status__is_suspension(wuffs_base__status z) {\n return z && (*z == '$');\n}\n\nstatic inline bool //\nwuffs_base__status__is_warning(wuffs_base__status z) {\n return z && (*z != '$') && (*z != '?');\n}\n\n" + diff --git a/cmd/wuffs-c/internal/cgen/expr.go b/cmd/wuffs-c/internal/cgen/expr.go index f89ab998..ba68674c 100644 --- a/cmd/wuffs-c/internal/cgen/expr.go +++ b/cmd/wuffs-c/internal/cgen/expr.go @@ -116,6 +116,8 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, depth uint32) error { // The middle part, the check_wuffs_version call, is optional, for // some built-in types. + // TODO: drop the memset and the WUFFS_INITIALIZE__ALREADY_ZEROED. + b.printf("(memset(%s", addr) // TODO: ensure that the recv expression is idempotent. if err := g.writeExpr(b, recv, depth); err != nil { @@ -124,14 +126,16 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, depth uint32) error { b.printf(", 0, sizeof ((%s%s){}))", g.packagePrefix(qid), qid[1].Str(g.tm)) if !isBaseRangeType(qid) { - b.printf(", wuffs_base__ignore_check_wuffs_version_status("+ - "%s%s__check_wuffs_version(%s", g.packagePrefix(qid), qid[1].Str(g.tm), addr) + b.printf(", wuffs_base__ignore_status("+ + "%s%s__initialize(%s", g.packagePrefix(qid), qid[1].Str(g.tm), addr) if err := g.writeExpr(b, recv, 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, WUFFS_INITIALIZE__ALREADY_ZEROED))", + g.packagePrefix(qid), qid[1].Str(g.tm)) } + // TODO: wuffs_base__ignore_status could return an empty_struct. b.writes(", wuffs_base__return_empty_struct())") return nil } diff --git a/lang/check/resolve.go b/lang/check/resolve.go index cf99f3d6..a1ce9c96 100644 --- a/lang/check/resolve.go +++ b/lang/check/resolve.go @@ -138,7 +138,9 @@ func (c *Checker) parseBuiltInFuncs(ss []string, generic bool) (map[t.QQID]*a.Fu } } } - file, err := parse.Parse(c.tm, filename, tokens, nil) + file, err := parse.Parse(c.tm, filename, tokens, &parse.Options{ + AllowBuiltInNames: true, + }) if err != nil { return nil, fmt.Errorf("check: parsing %q: could not parse built-in funcs: %v", s, err) } diff --git a/lang/generate/generate.go b/lang/generate/generate.go index 1ec3f80f..5f0f6166 100644 --- a/lang/generate/generate.go +++ b/lang/generate/generate.go @@ -90,7 +90,7 @@ func checkPackageName(s string) string { // Blacklist certain package names. switch s { case "base", "base_private", "base_private_header", "base_public", "base_public_header", - "config", "implementation", "include_guard", "version": + "config", "implementation", "include_guard", "initialize", "version": return "" } return s diff --git a/lang/parse/parse.go b/lang/parse/parse.go index 466c9d57..f09bf70f 100644 --- a/lang/parse/parse.go +++ b/lang/parse/parse.go @@ -24,6 +24,7 @@ import ( ) type Options struct { + AllowBuiltInNames bool AllowDoubleUnderscoreNames bool } @@ -156,6 +157,13 @@ func (p *parser) parseTopLevelDecl() (*a.Node, error) { if err != nil { return nil, err } + if !p.opts.AllowBuiltInNames { + switch id1 { + case t.IDInitialize, t.IDReset: + return nil, fmt.Errorf(`parse: cannot have a method named %q at %s:%d`, + id1.Str(p.tm), p.filename, p.line()) + } + } // TODO: should we require id0 != 0? In other words, always methods // (attached to receivers) and never free standing functions? if !p.opts.AllowDoubleUnderscoreNames && isDoubleUnderscore(p.tm.ByID(id1)) { diff --git a/lang/token/list.go b/lang/token/list.go index 254a0261..4ea4afbf 100644 --- a/lang/token/list.go +++ b/lang/token/list.go @@ -578,9 +578,10 @@ const ( // -------- 0x200 block. - IDReset = ID(0x200) - IDSet = ID(0x201) - IDUnroll = ID(0x202) + IDInitialize = ID(0x200) + IDReset = ID(0x201) + IDSet = ID(0x202) + IDUnroll = ID(0x203) // TODO: range/rect methods like intersection and contains? @@ -906,9 +907,10 @@ var builtInsByID = [nBuiltInIDs]string{ // -------- 0x200 block. - IDReset: "reset", - IDSet: "set", - IDUnroll: "unroll", + IDInitialize: "initialize", + IDReset: "reset", + IDSet: "set", + IDUnroll: "unroll", IDHighBits: "high_bits", IDLowBits: "low_bits", diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 440c5bee..41b1667f 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -82,6 +82,14 @@ extern "C" { #define WUFFS_BASE__WARN_UNUSED_RESULT #endif +// Flags for wuffs_foo__bar__initialize functions. + +// WUFFS_INITIALIZE__ALREADY_ZEROED means that the "self" receiver struct value +// has already been set to all zeroes. +#define WUFFS_INITIALIZE__ALREADY_ZEROED ((uint32_t)0x00000001) + +// -------- + // 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()". @@ -2422,11 +2430,20 @@ typedef struct wuffs_adler32__hasher__struct wuffs_adler32__hasher; // ---------------- Public Initializer Prototypes -// wuffs_adler32__hasher__check_wuffs_version is an initializer function. -// -// It should be called before any other wuffs_adler32__hasher__* function. +// For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, +// etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". // // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. +// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for initialize_flags. + +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_adler32__hasher__initialize(wuffs_adler32__hasher* self, + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags); + +// Deprecated: use wuffs_foo__bar__initialize instead of +// wuffs_foo__bar__check_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, @@ -2492,10 +2509,19 @@ struct wuffs_adler32__hasher__struct { #ifdef __cplusplus + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // + initialize(size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags) { + return wuffs_adler32__hasher__initialize(this, sizeof_star_self, + wuffs_version, initialize_flags); + } + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version) { - return wuffs_adler32__hasher__check_wuffs_version(this, sizeof_star_self, - wuffs_version); + return wuffs_adler32__hasher__initialize(this, sizeof_star_self, + wuffs_version, + WUFFS_INITIALIZE__ALREADY_ZEROED); } inline uint32_t // @@ -2534,11 +2560,20 @@ typedef struct wuffs_crc32__ieee_hasher__struct wuffs_crc32__ieee_hasher; // ---------------- Public Initializer Prototypes -// wuffs_crc32__ieee_hasher__check_wuffs_version is an initializer function. -// -// It should be called before any other wuffs_crc32__ieee_hasher__* function. +// For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, +// etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". // // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. +// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for initialize_flags. + +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_crc32__ieee_hasher__initialize(wuffs_crc32__ieee_hasher* self, + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags); + +// Deprecated: use wuffs_foo__bar__initialize instead of +// wuffs_foo__bar__check_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, @@ -2603,10 +2638,19 @@ struct wuffs_crc32__ieee_hasher__struct { #ifdef __cplusplus + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // + initialize(size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags) { + return wuffs_crc32__ieee_hasher__initialize( + this, sizeof_star_self, wuffs_version, initialize_flags); + } + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version) { - return wuffs_crc32__ieee_hasher__check_wuffs_version(this, sizeof_star_self, - wuffs_version); + return wuffs_crc32__ieee_hasher__initialize( + this, sizeof_star_self, wuffs_version, + WUFFS_INITIALIZE__ALREADY_ZEROED); } inline uint32_t // @@ -2666,11 +2710,20 @@ typedef struct wuffs_deflate__decoder__struct wuffs_deflate__decoder; // ---------------- Public Initializer Prototypes -// wuffs_deflate__decoder__check_wuffs_version is an initializer function. -// -// It should be called before any other wuffs_deflate__decoder__* function. +// For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, +// etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". // // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. +// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for initialize_flags. + +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_deflate__decoder__initialize(wuffs_deflate__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags); + +// Deprecated: use wuffs_foo__bar__initialize instead of +// wuffs_foo__bar__check_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, @@ -2787,10 +2840,19 @@ struct wuffs_deflate__decoder__struct { #ifdef __cplusplus + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // + initialize(size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags) { + return wuffs_deflate__decoder__initialize(this, sizeof_star_self, + wuffs_version, initialize_flags); + } + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version) { - return wuffs_deflate__decoder__check_wuffs_version(this, sizeof_star_self, - wuffs_version); + return wuffs_deflate__decoder__initialize(this, sizeof_star_self, + wuffs_version, + WUFFS_INITIALIZE__ALREADY_ZEROED); } inline wuffs_base__range_ii_u64 // @@ -2846,11 +2908,20 @@ typedef struct wuffs_lzw__decoder__struct wuffs_lzw__decoder; // ---------------- Public Initializer Prototypes -// wuffs_lzw__decoder__check_wuffs_version is an initializer function. -// -// It should be called before any other wuffs_lzw__decoder__* function. +// For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, +// etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". // // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. +// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for initialize_flags. + +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_lzw__decoder__initialize(wuffs_lzw__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags); + +// Deprecated: use wuffs_foo__bar__initialize instead of +// wuffs_foo__bar__check_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, @@ -2944,10 +3015,18 @@ struct wuffs_lzw__decoder__struct { #ifdef __cplusplus + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // + initialize(size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags) { + return wuffs_lzw__decoder__initialize(this, sizeof_star_self, wuffs_version, + initialize_flags); + } + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version) { - return wuffs_lzw__decoder__check_wuffs_version(this, sizeof_star_self, - wuffs_version); + return wuffs_lzw__decoder__initialize(this, sizeof_star_self, wuffs_version, + WUFFS_INITIALIZE__ALREADY_ZEROED); } inline wuffs_base__empty_struct // @@ -3017,11 +3096,20 @@ typedef struct wuffs_gif__decoder__struct wuffs_gif__decoder; // ---------------- Public Initializer Prototypes -// wuffs_gif__decoder__check_wuffs_version is an initializer function. -// -// It should be called before any other wuffs_gif__decoder__* function. +// For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, +// etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". // // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. +// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for initialize_flags. + +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_gif__decoder__initialize(wuffs_gif__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags); + +// Deprecated: use wuffs_foo__bar__initialize instead of +// wuffs_foo__bar__check_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, @@ -3204,10 +3292,18 @@ struct wuffs_gif__decoder__struct { #ifdef __cplusplus + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // + initialize(size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags) { + return wuffs_gif__decoder__initialize(this, sizeof_star_self, wuffs_version, + initialize_flags); + } + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version) { - return wuffs_gif__decoder__check_wuffs_version(this, sizeof_star_self, - wuffs_version); + return wuffs_gif__decoder__initialize(this, sizeof_star_self, wuffs_version, + WUFFS_INITIALIZE__ALREADY_ZEROED); } inline wuffs_base__status // @@ -3303,11 +3399,20 @@ typedef struct wuffs_gzip__decoder__struct wuffs_gzip__decoder; // ---------------- Public Initializer Prototypes -// wuffs_gzip__decoder__check_wuffs_version is an initializer function. -// -// It should be called before any other wuffs_gzip__decoder__* function. +// For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, +// etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". // // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. +// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for initialize_flags. + +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_gzip__decoder__initialize(wuffs_gzip__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags); + +// Deprecated: use wuffs_foo__bar__initialize instead of +// wuffs_foo__bar__check_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, @@ -3391,10 +3496,19 @@ struct wuffs_gzip__decoder__struct { #ifdef __cplusplus + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // + initialize(size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags) { + return wuffs_gzip__decoder__initialize(this, sizeof_star_self, + wuffs_version, initialize_flags); + } + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version) { - return wuffs_gzip__decoder__check_wuffs_version(this, sizeof_star_self, - wuffs_version); + return wuffs_gzip__decoder__initialize(this, sizeof_star_self, + wuffs_version, + WUFFS_INITIALIZE__ALREADY_ZEROED); } inline wuffs_base__empty_struct // @@ -3456,11 +3570,20 @@ typedef struct wuffs_zlib__decoder__struct wuffs_zlib__decoder; // ---------------- Public Initializer Prototypes -// wuffs_zlib__decoder__check_wuffs_version is an initializer function. -// -// It should be called before any other wuffs_zlib__decoder__* function. +// For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, +// etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". // // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. +// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for initialize_flags. + +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // +wuffs_zlib__decoder__initialize(wuffs_zlib__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags); + +// Deprecated: use wuffs_foo__bar__initialize instead of +// wuffs_foo__bar__check_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, @@ -3541,10 +3664,19 @@ struct wuffs_zlib__decoder__struct { #ifdef __cplusplus + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // + initialize(size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags) { + return wuffs_zlib__decoder__initialize(this, sizeof_star_self, + wuffs_version, initialize_flags); + } + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // check_wuffs_version(size_t sizeof_star_self, uint64_t wuffs_version) { - return wuffs_zlib__decoder__check_wuffs_version(this, sizeof_star_self, - wuffs_version); + return wuffs_zlib__decoder__initialize(this, sizeof_star_self, + wuffs_version, + WUFFS_INITIALIZE__ALREADY_ZEROED); } inline wuffs_base__empty_struct // @@ -3588,8 +3720,8 @@ struct wuffs_zlib__decoder__struct { extern "C" { #endif -static inline void wuffs_base__ignore_check_wuffs_version_status( - wuffs_base__status z) {} +static inline void // +wuffs_base__ignore_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, @@ -4012,6 +4144,7 @@ wuffs_base__acknowledge_potentially_unused_functions__core_private() static inline void wuffs_base__acknowledge_potentially_unused_functions__core_private() { + (void)(wuffs_base__ignore_status); (void)(wuffs_base__load_u16be); (void)(wuffs_base__load_u16le); (void)(wuffs_base__load_u24be); @@ -4717,9 +4850,10 @@ wuffs_base__pixel_swizzler__swizzle_packed(wuffs_base__pixel_swizzler* p, // ---------------- Initializer Implementations 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) { +wuffs_adler32__hasher__initialize(wuffs_adler32__hasher* self, + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags) { if (!self) { return wuffs_base__error__bad_receiver; } @@ -4737,6 +4871,14 @@ wuffs_adler32__hasher__check_wuffs_version(wuffs_adler32__hasher* self, return NULL; } +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) { + return wuffs_adler32__hasher__initialize( + self, sizeof_star_self, wuffs_version, WUFFS_INITIALIZE__ALREADY_ZEROED); +} + size_t // sizeof__wuffs_adler32__hasher() { return sizeof((wuffs_adler32__hasher){}); @@ -5705,9 +5847,10 @@ static const uint32_t // // ---------------- Initializer Implementations 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) { +wuffs_crc32__ieee_hasher__initialize(wuffs_crc32__ieee_hasher* self, + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags) { if (!self) { return wuffs_base__error__bad_receiver; } @@ -5725,6 +5868,14 @@ wuffs_crc32__ieee_hasher__check_wuffs_version(wuffs_crc32__ieee_hasher* self, return NULL; } +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) { + return wuffs_crc32__ieee_hasher__initialize( + self, sizeof_star_self, wuffs_version, WUFFS_INITIALIZE__ALREADY_ZEROED); +} + size_t // sizeof__wuffs_crc32__ieee_hasher() { return sizeof((wuffs_crc32__ieee_hasher){}); @@ -5972,9 +6123,10 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self, // ---------------- Initializer Implementations 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) { +wuffs_deflate__decoder__initialize(wuffs_deflate__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags) { if (!self) { return wuffs_base__error__bad_receiver; } @@ -5992,6 +6144,14 @@ wuffs_deflate__decoder__check_wuffs_version(wuffs_deflate__decoder* self, return NULL; } +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) { + return wuffs_deflate__decoder__initialize( + self, sizeof_star_self, wuffs_version, WUFFS_INITIALIZE__ALREADY_ZEROED); +} + size_t // sizeof__wuffs_deflate__decoder() { return sizeof((wuffs_deflate__decoder){}); @@ -7744,9 +7904,10 @@ wuffs_lzw__decoder__write_to(wuffs_lzw__decoder* self, // ---------------- Initializer Implementations 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) { +wuffs_lzw__decoder__initialize(wuffs_lzw__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags) { if (!self) { return wuffs_base__error__bad_receiver; } @@ -7764,6 +7925,14 @@ wuffs_lzw__decoder__check_wuffs_version(wuffs_lzw__decoder* self, return NULL; } +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) { + return wuffs_lzw__decoder__initialize(self, sizeof_star_self, wuffs_version, + WUFFS_INITIALIZE__ALREADY_ZEROED); +} + size_t // sizeof__wuffs_lzw__decoder() { return sizeof((wuffs_lzw__decoder){}); @@ -8308,9 +8477,10 @@ wuffs_gif__decoder__copy_to_image_buffer(wuffs_gif__decoder* self, // ---------------- Initializer Implementations 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) { +wuffs_gif__decoder__initialize(wuffs_gif__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags) { if (!self) { return wuffs_base__error__bad_receiver; } @@ -8325,9 +8495,9 @@ wuffs_gif__decoder__check_wuffs_version(wuffs_gif__decoder* self, return wuffs_base__error__check_wuffs_version_not_applicable; } { - wuffs_base__status z = wuffs_lzw__decoder__check_wuffs_version( + wuffs_base__status z = wuffs_lzw__decoder__initialize( &self->private_impl.f_lzw, sizeof(self->private_impl.f_lzw), - WUFFS_VERSION); + WUFFS_VERSION, initialize_flags); if (z) { return z; } @@ -8336,6 +8506,14 @@ wuffs_gif__decoder__check_wuffs_version(wuffs_gif__decoder* self, return NULL; } +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) { + return wuffs_gif__decoder__initialize(self, sizeof_star_self, wuffs_version, + WUFFS_INITIALIZE__ALREADY_ZEROED); +} + size_t // sizeof__wuffs_gif__decoder() { return sizeof((wuffs_gif__decoder){}); @@ -10050,10 +10228,9 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, })); if (self->private_impl.f_previous_lzw_decode_ended_abruptly) { (memset(&self->private_impl.f_lzw, 0, sizeof((wuffs_lzw__decoder){})), - 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__ignore_status(wuffs_lzw__decoder__initialize( + &self->private_impl.f_lzw, sizeof((wuffs_lzw__decoder){}), + WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED)), wuffs_base__return_empty_struct()); } { @@ -10456,9 +10633,10 @@ const char* wuffs_gzip__error__bad_header = "?gzip: bad header"; // ---------------- Initializer Implementations 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) { +wuffs_gzip__decoder__initialize(wuffs_gzip__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags) { if (!self) { return wuffs_base__error__bad_receiver; } @@ -10473,17 +10651,17 @@ wuffs_gzip__decoder__check_wuffs_version(wuffs_gzip__decoder* self, return wuffs_base__error__check_wuffs_version_not_applicable; } { - wuffs_base__status z = wuffs_crc32__ieee_hasher__check_wuffs_version( + wuffs_base__status z = wuffs_crc32__ieee_hasher__initialize( &self->private_impl.f_checksum, sizeof(self->private_impl.f_checksum), - WUFFS_VERSION); + WUFFS_VERSION, initialize_flags); if (z) { return z; } } { - wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version( + wuffs_base__status z = wuffs_deflate__decoder__initialize( &self->private_impl.f_flate, sizeof(self->private_impl.f_flate), - WUFFS_VERSION); + WUFFS_VERSION, initialize_flags); if (z) { return z; } @@ -10492,6 +10670,14 @@ wuffs_gzip__decoder__check_wuffs_version(wuffs_gzip__decoder* self, return NULL; } +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) { + return wuffs_gzip__decoder__initialize(self, sizeof_star_self, wuffs_version, + WUFFS_INITIALIZE__ALREADY_ZEROED); +} + size_t // sizeof__wuffs_gzip__decoder() { return sizeof((wuffs_gzip__decoder){}); @@ -10918,9 +11104,10 @@ const char* wuffs_zlib__error__todo_unsupported_preset_dictionary = // ---------------- Initializer Implementations 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) { +wuffs_zlib__decoder__initialize(wuffs_zlib__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t initialize_flags) { if (!self) { return wuffs_base__error__bad_receiver; } @@ -10935,17 +11122,17 @@ wuffs_zlib__decoder__check_wuffs_version(wuffs_zlib__decoder* self, return wuffs_base__error__check_wuffs_version_not_applicable; } { - wuffs_base__status z = wuffs_adler32__hasher__check_wuffs_version( + wuffs_base__status z = wuffs_adler32__hasher__initialize( &self->private_impl.f_checksum, sizeof(self->private_impl.f_checksum), - WUFFS_VERSION); + WUFFS_VERSION, initialize_flags); if (z) { return z; } } { - wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version( + wuffs_base__status z = wuffs_deflate__decoder__initialize( &self->private_impl.f_flate, sizeof(self->private_impl.f_flate), - WUFFS_VERSION); + WUFFS_VERSION, initialize_flags); if (z) { return z; } @@ -10954,6 +11141,14 @@ wuffs_zlib__decoder__check_wuffs_version(wuffs_zlib__decoder* self, return NULL; } +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) { + return wuffs_zlib__decoder__initialize(self, sizeof_star_self, wuffs_version, + WUFFS_INITIALIZE__ALREADY_ZEROED); +} + size_t // sizeof__wuffs_zlib__decoder() { return sizeof((wuffs_zlib__decoder){});