diff --git a/internal/cgen/base/fundamental-public.h b/internal/cgen/base/fundamental-public.h index bd78a3a7..f69e2e44 100644 --- a/internal/cgen/base/fundamental-public.h +++ b/internal/cgen/base/fundamental-public.h @@ -76,7 +76,9 @@ #define WUFFS_BASE__WARN_UNUSED_RESULT #endif -// Flags for wuffs_foo__bar__initialize functions. +// -------- + +// Options (bitwise or'ed together) for wuffs_foo__bar__initialize functions. #define WUFFS_INITIALIZE__DEFAULT_OPTIONS ((uint32_t)0x00000000) diff --git a/internal/cgen/cgen.go b/internal/cgen/cgen.go index fdf59200..9b4ce960 100644 --- a/internal/cgen/cgen.go +++ b/internal/cgen/cgen.go @@ -706,7 +706,7 @@ func (g *gen) genHeader(b *buffer) error { 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") + b.writes("// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options.\n\n") for _, n := range g.structList { if n.Public() { if err := g.writeInitializerPrototype(b, n); err != nil { @@ -1207,8 +1207,8 @@ func (g *gen) writeCppMethods(b *buffer, n *a.Struct) error { b.writes("#endif // (__cplusplus >= 201103L) && !defined(WUFFS_IMPLEMENTATION)\n\n") b.writes("inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT\n" + - "initialize(\nsize_t sizeof_star_self,\nuint64_t wuffs_version,\nuint32_t initialize_flags) {\n") - b.printf("return %s%s__initialize(\nthis, sizeof_star_self, wuffs_version, initialize_flags);\n}\n\n", + "initialize(\nsize_t sizeof_star_self,\nuint64_t wuffs_version,\nuint32_t options) {\n") + b.printf("return %s%s__initialize(\nthis, sizeof_star_self, wuffs_version, options);\n}\n\n", g.pkgPrefix, structName) for _, impl := range n.Implements() { @@ -1297,7 +1297,7 @@ func (g *gen) writeInitializerSignature(b *buffer, n *a.Struct, public bool) err " %s%s* self,\n"+ " size_t sizeof_star_self,\n"+ " uint64_t wuffs_version,\n"+ - " uint32_t initialize_flags)", + " uint32_t options)", g.pkgPrefix, structName, g.pkgPrefix, structName) return nil } @@ -1352,7 +1352,7 @@ func (g *gen) writeInitializerImpl(b *buffer, n *a.Struct) error { b.writes(" return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version);\n") b.writes("}\n\n") - b.writes("if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {\n") + b.writes("if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {\n") b.writes(" // The whole point of this if-check is to detect an uninitialized *self.\n") b.writes(" // We disable the warning on GCC. Clang-5.0 does not have this warning.\n") b.writes(" #if !defined(__clang__) && defined(__GNUC__)\n") @@ -1366,9 +1366,9 @@ func (g *gen) writeInitializerImpl(b *buffer, n *a.Struct) error { b.writes(" #pragma GCC diagnostic pop\n") b.writes(" #endif\n") b.writes("} else {\n") - b.writes(" if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {\n") + b.writes(" if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {\n") b.writes(" memset(self, 0, sizeof(*self));\n") - b.writes(" initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;\n") + b.writes(" options |= WUFFS_INITIALIZE__ALREADY_ZEROED;\n") b.writes(" } else {\n") b.writes(" memset(&(self->private_impl), 0, sizeof(self->private_impl));\n") b.writes(" }\n") @@ -1398,7 +1398,7 @@ func (g *gen) writeInitializerImpl(b *buffer, n *a.Struct) error { b.printf("{\n") b.printf("wuffs_base__status z = %s%s__initialize(\n"+ - "&self->private_data.%s%s, sizeof(self->private_data.%s%s), WUFFS_VERSION, initialize_flags);\n", + "&self->private_data.%s%s, sizeof(self->private_data.%s%s), WUFFS_VERSION, options);\n", prefix, qid[1].Str(g.tm), fPrefix, f.Name().Str(g.tm), fPrefix, f.Name().Str(g.tm)) b.printf("if (z.repr) {\nreturn z;\n}\n") b.printf("}\n") diff --git a/internal/cgen/data/data.go b/internal/cgen/data/data.go index e32eae09..469c2f72 100644 --- a/internal/cgen/data/data.go +++ b/internal/cgen/data/data.go @@ -211,8 +211,9 @@ const BaseFundamentalPublicH = "" + "// ---------------- Fundamentals\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// each major.minor branch, the commit count should increase monotonically.\n//\n// !! Some code generation programs can override WUFFS_VERSION.\n#define WUFFS_VERSION 0\n#define WUFFS_VERSION_MAJOR 0\n#define WUFFS_VERSION_MINOR 0\n#define WUFFS_VERSION_PATCH " + "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" + "" + - "// --------\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#if defined(__clang__)\n#define WUFFS_BASE__POTENTIALLY_UNUSED_FIELD __attribute__((unused))\n#else\n#define WUFFS_BASE__POTENTIALLY_UNUSED_FIELD\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// Flags for wuffs_foo__bar__initialize functions.\n\n#define WUFFS_INITIALIZE__DEFAULT_OPTIONS ((uint32_t)0x00000000)\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)0x" + - "00000001)\n\n// WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED means that, absent\n// WUFFS_INITIALIZE__ALREADY_ZEROED, only some of the \"self\" receiver struct\n// value will be set to all zeroes. Internal buffers, which tend to be a large\n// proportion of the struct's size, will be left uninitialized. Internal means\n// that the buffer is contained by the receiver struct, as opposed to being\n// passed as a separately allocated \"work buffer\".\n//\n// For more detail, see:\n// https://github.com/google/wuffs/blob/master/doc/note/initialization.md\n#define WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED \\\n ((uint32_t)0x00000002)\n\n" + + "// --------\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#if defined(__clang__)\n#define WUFFS_BASE__POTENTIALLY_UNUSED_FIELD __attribute__((unused))\n#else\n#define WUFFS_BASE__POTENTIALLY_UNUSED_FIELD\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" + + "" + + "// --------\n\n// Options (bitwise or'ed together) for wuffs_foo__bar__initialize functions.\n\n#define WUFFS_INITIALIZE__DEFAULT_OPTIONS ((uint32_t)0x00000000)\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// WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED means that, absent\n// WUFFS_INITIALIZE__ALREADY_ZEROED, only some of the \"self\" receiver struct\n// value will be set to all zeroes. Internal buffers, which tend to be a large\n// proportion of the struct's size, will be left uninitialized. Internal means\n// that the buffer is contained by the receiver struct, as opposed to being\n// passed as a separately allocated \"work buffer\".\n//\n// For more detail, see:\n// https://github.com/google/wuffs/blob/master/doc/note/initialization.md\n#define WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED \\\n ((uint32_t)0x00000002)\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\nstatic inline wuffs_base__empty_struct //\nwuffs_base__make_empty_struct() {\n wuffs_base__empty_struct ret;\n ret.private_impl = 0;\n return ret;\n}\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\ntypedef struct {\n const char* vtable_name;\n const void* function_pointers;\n} wuffs_base__vtable;\n\n" + diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 7588b06f..4a17194a 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -110,7 +110,9 @@ extern "C" { #define WUFFS_BASE__WARN_UNUSED_RESULT #endif -// Flags for wuffs_foo__bar__initialize functions. +// -------- + +// Options (bitwise or'ed together) for wuffs_foo__bar__initialize functions. #define WUFFS_INITIALIZE__DEFAULT_OPTIONS ((uint32_t)0x00000000) @@ -4646,14 +4648,14 @@ typedef struct wuffs_adler32__hasher__struct wuffs_adler32__hasher; // 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. +// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. 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); + uint32_t options); size_t sizeof__wuffs_adler32__hasher(); @@ -4772,9 +4774,9 @@ struct wuffs_adler32__hasher__struct { initialize( size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags) { + uint32_t options) { return wuffs_adler32__hasher__initialize( - this, sizeof_star_self, wuffs_version, initialize_flags); + this, sizeof_star_self, wuffs_version, options); } inline wuffs_base__hasher_u32* @@ -4827,14 +4829,14 @@ typedef struct wuffs_bmp__decoder__struct wuffs_bmp__decoder; // 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. +// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT wuffs_bmp__decoder__initialize( wuffs_bmp__decoder* self, size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags); + uint32_t options); size_t sizeof__wuffs_bmp__decoder(); @@ -5047,9 +5049,9 @@ struct wuffs_bmp__decoder__struct { initialize( size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags) { + uint32_t options) { return wuffs_bmp__decoder__initialize( - this, sizeof_star_self, wuffs_version, initialize_flags); + this, sizeof_star_self, wuffs_version, options); } inline wuffs_base__image_decoder* @@ -5162,14 +5164,14 @@ typedef struct wuffs_crc32__ieee_hasher__struct wuffs_crc32__ieee_hasher; // 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. +// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. 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); + uint32_t options); size_t sizeof__wuffs_crc32__ieee_hasher(); @@ -5287,9 +5289,9 @@ struct wuffs_crc32__ieee_hasher__struct { initialize( size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags) { + uint32_t options) { return wuffs_crc32__ieee_hasher__initialize( - this, sizeof_star_self, wuffs_version, initialize_flags); + this, sizeof_star_self, wuffs_version, options); } inline wuffs_base__hasher_u32* @@ -5353,14 +5355,14 @@ typedef struct wuffs_deflate__decoder__struct wuffs_deflate__decoder; // 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. +// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. 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); + uint32_t options); size_t sizeof__wuffs_deflate__decoder(); @@ -5541,9 +5543,9 @@ struct wuffs_deflate__decoder__struct { initialize( size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags) { + uint32_t options) { return wuffs_deflate__decoder__initialize( - this, sizeof_star_self, wuffs_version, initialize_flags); + this, sizeof_star_self, wuffs_version, options); } inline wuffs_base__io_transformer* @@ -5608,14 +5610,14 @@ typedef struct wuffs_lzw__decoder__struct wuffs_lzw__decoder; // 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. +// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. 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); + uint32_t options); size_t sizeof__wuffs_lzw__decoder(); @@ -5769,9 +5771,9 @@ struct wuffs_lzw__decoder__struct { initialize( size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags) { + uint32_t options) { return wuffs_lzw__decoder__initialize( - this, sizeof_star_self, wuffs_version, initialize_flags); + this, sizeof_star_self, wuffs_version, options); } inline wuffs_base__io_transformer* @@ -5862,14 +5864,14 @@ typedef struct wuffs_gif__decoder__struct wuffs_gif__decoder; // 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. +// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT wuffs_gif__config_decoder__initialize( wuffs_gif__config_decoder* self, size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags); + uint32_t options); size_t sizeof__wuffs_gif__config_decoder(); @@ -5879,7 +5881,7 @@ wuffs_gif__decoder__initialize( wuffs_gif__decoder* self, size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags); + uint32_t options); size_t sizeof__wuffs_gif__decoder(); @@ -6213,9 +6215,9 @@ struct wuffs_gif__config_decoder__struct { initialize( size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags) { + uint32_t options) { return wuffs_gif__config_decoder__initialize( - this, sizeof_star_self, wuffs_version, initialize_flags); + this, sizeof_star_self, wuffs_version, options); } inline wuffs_base__image_decoder* @@ -6476,9 +6478,9 @@ struct wuffs_gif__decoder__struct { initialize( size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags) { + uint32_t options) { return wuffs_gif__decoder__initialize( - this, sizeof_star_self, wuffs_version, initialize_flags); + this, sizeof_star_self, wuffs_version, options); } inline wuffs_base__image_decoder* @@ -6598,14 +6600,14 @@ typedef struct wuffs_gzip__decoder__struct wuffs_gzip__decoder; // 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. +// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. 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); + uint32_t options); size_t sizeof__wuffs_gzip__decoder(); @@ -6749,9 +6751,9 @@ struct wuffs_gzip__decoder__struct { initialize( size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags) { + uint32_t options) { return wuffs_gzip__decoder__initialize( - this, sizeof_star_self, wuffs_version, initialize_flags); + this, sizeof_star_self, wuffs_version, options); } inline wuffs_base__io_transformer* @@ -6863,14 +6865,14 @@ typedef struct wuffs_json__decoder__struct wuffs_json__decoder; // 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. +// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT wuffs_json__decoder__initialize( wuffs_json__decoder* self, size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags); + uint32_t options); size_t sizeof__wuffs_json__decoder(); @@ -7016,9 +7018,9 @@ struct wuffs_json__decoder__struct { initialize( size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags) { + uint32_t options) { return wuffs_json__decoder__initialize( - this, sizeof_star_self, wuffs_version, initialize_flags); + this, sizeof_star_self, wuffs_version, options); } inline wuffs_base__token_decoder* @@ -7077,14 +7079,14 @@ typedef struct wuffs_wbmp__decoder__struct wuffs_wbmp__decoder; // 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. +// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT wuffs_wbmp__decoder__initialize( wuffs_wbmp__decoder* self, size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags); + uint32_t options); size_t sizeof__wuffs_wbmp__decoder(); @@ -7283,9 +7285,9 @@ struct wuffs_wbmp__decoder__struct { initialize( size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags) { + uint32_t options) { return wuffs_wbmp__decoder__initialize( - this, sizeof_star_self, wuffs_version, initialize_flags); + this, sizeof_star_self, wuffs_version, options); } inline wuffs_base__image_decoder* @@ -7407,14 +7409,14 @@ typedef struct wuffs_zlib__decoder__struct wuffs_zlib__decoder; // 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. +// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. 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); + uint32_t options); size_t sizeof__wuffs_zlib__decoder(); @@ -7571,9 +7573,9 @@ struct wuffs_zlib__decoder__struct { initialize( size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags) { + uint32_t options) { return wuffs_zlib__decoder__initialize( - this, sizeof_star_self, wuffs_version, initialize_flags); + this, sizeof_star_self, wuffs_version, options); } inline wuffs_base__io_transformer* @@ -12237,7 +12239,7 @@ wuffs_adler32__hasher__initialize( wuffs_adler32__hasher* self, size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags){ + uint32_t options){ if (!self) { return wuffs_base__make_status(wuffs_base__error__bad_receiver); } @@ -12249,7 +12251,7 @@ wuffs_adler32__hasher__initialize( return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version); } - if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { + if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { // The whole point of this if-check is to detect an uninitialized *self. // We disable the warning on GCC. Clang-5.0 does not have this warning. #if !defined(__clang__) && defined(__GNUC__) @@ -12263,9 +12265,9 @@ wuffs_adler32__hasher__initialize( #pragma GCC diagnostic pop #endif } else { - if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { + if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { memset(self, 0, sizeof(*self)); - initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED; + options |= WUFFS_INITIALIZE__ALREADY_ZEROED; } else { memset(&(self->private_impl), 0, sizeof(self->private_impl)); } @@ -12458,7 +12460,7 @@ wuffs_bmp__decoder__initialize( wuffs_bmp__decoder* self, size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags){ + uint32_t options){ if (!self) { return wuffs_base__make_status(wuffs_base__error__bad_receiver); } @@ -12470,7 +12472,7 @@ wuffs_bmp__decoder__initialize( return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version); } - if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { + if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { // The whole point of this if-check is to detect an uninitialized *self. // We disable the warning on GCC. Clang-5.0 does not have this warning. #if !defined(__clang__) && defined(__GNUC__) @@ -12484,9 +12486,9 @@ wuffs_bmp__decoder__initialize( #pragma GCC diagnostic pop #endif } else { - if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { + if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { memset(self, 0, sizeof(*self)); - initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED; + options |= WUFFS_INITIALIZE__ALREADY_ZEROED; } else { memset(&(self->private_impl), 0, sizeof(self->private_impl)); } @@ -14256,7 +14258,7 @@ wuffs_crc32__ieee_hasher__initialize( wuffs_crc32__ieee_hasher* self, size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags){ + uint32_t options){ if (!self) { return wuffs_base__make_status(wuffs_base__error__bad_receiver); } @@ -14268,7 +14270,7 @@ wuffs_crc32__ieee_hasher__initialize( return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version); } - if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { + if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { // The whole point of this if-check is to detect an uninitialized *self. // We disable the warning on GCC. Clang-5.0 does not have this warning. #if !defined(__clang__) && defined(__GNUC__) @@ -14282,9 +14284,9 @@ wuffs_crc32__ieee_hasher__initialize( #pragma GCC diagnostic pop #endif } else { - if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { + if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { memset(self, 0, sizeof(*self)); - initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED; + options |= WUFFS_INITIALIZE__ALREADY_ZEROED; } else { memset(&(self->private_impl), 0, sizeof(self->private_impl)); } @@ -14587,7 +14589,7 @@ wuffs_deflate__decoder__initialize( wuffs_deflate__decoder* self, size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags){ + uint32_t options){ if (!self) { return wuffs_base__make_status(wuffs_base__error__bad_receiver); } @@ -14599,7 +14601,7 @@ wuffs_deflate__decoder__initialize( return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version); } - if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { + if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { // The whole point of this if-check is to detect an uninitialized *self. // We disable the warning on GCC. Clang-5.0 does not have this warning. #if !defined(__clang__) && defined(__GNUC__) @@ -14613,9 +14615,9 @@ wuffs_deflate__decoder__initialize( #pragma GCC diagnostic pop #endif } else { - if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { + if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { memset(self, 0, sizeof(*self)); - initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED; + options |= WUFFS_INITIALIZE__ALREADY_ZEROED; } else { memset(&(self->private_impl), 0, sizeof(self->private_impl)); } @@ -16305,7 +16307,7 @@ wuffs_lzw__decoder__initialize( wuffs_lzw__decoder* self, size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags){ + uint32_t options){ if (!self) { return wuffs_base__make_status(wuffs_base__error__bad_receiver); } @@ -16317,7 +16319,7 @@ wuffs_lzw__decoder__initialize( return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version); } - if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { + if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { // The whole point of this if-check is to detect an uninitialized *self. // We disable the warning on GCC. Clang-5.0 does not have this warning. #if !defined(__clang__) && defined(__GNUC__) @@ -16331,9 +16333,9 @@ wuffs_lzw__decoder__initialize( #pragma GCC diagnostic pop #endif } else { - if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { + if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { memset(self, 0, sizeof(*self)); - initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED; + options |= WUFFS_INITIALIZE__ALREADY_ZEROED; } else { memset(&(self->private_impl), 0, sizeof(self->private_impl)); } @@ -17043,7 +17045,7 @@ wuffs_gif__config_decoder__initialize( wuffs_gif__config_decoder* self, size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags){ + uint32_t options){ if (!self) { return wuffs_base__make_status(wuffs_base__error__bad_receiver); } @@ -17055,7 +17057,7 @@ wuffs_gif__config_decoder__initialize( return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version); } - if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { + if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { // The whole point of this if-check is to detect an uninitialized *self. // We disable the warning on GCC. Clang-5.0 does not have this warning. #if !defined(__clang__) && defined(__GNUC__) @@ -17069,9 +17071,9 @@ wuffs_gif__config_decoder__initialize( #pragma GCC diagnostic pop #endif } else { - if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { + if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { memset(self, 0, sizeof(*self)); - initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED; + options |= WUFFS_INITIALIZE__ALREADY_ZEROED; } else { memset(&(self->private_impl), 0, sizeof(self->private_impl)); } @@ -17110,7 +17112,7 @@ wuffs_gif__decoder__initialize( wuffs_gif__decoder* self, size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags){ + uint32_t options){ if (!self) { return wuffs_base__make_status(wuffs_base__error__bad_receiver); } @@ -17122,7 +17124,7 @@ wuffs_gif__decoder__initialize( return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version); } - if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { + if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { // The whole point of this if-check is to detect an uninitialized *self. // We disable the warning on GCC. Clang-5.0 does not have this warning. #if !defined(__clang__) && defined(__GNUC__) @@ -17136,9 +17138,9 @@ wuffs_gif__decoder__initialize( #pragma GCC diagnostic pop #endif } else { - if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { + if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { memset(self, 0, sizeof(*self)); - initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED; + options |= WUFFS_INITIALIZE__ALREADY_ZEROED; } else { memset(&(self->private_impl), 0, sizeof(self->private_impl)); } @@ -17146,7 +17148,7 @@ wuffs_gif__decoder__initialize( { wuffs_base__status z = wuffs_lzw__decoder__initialize( - &self->private_data.f_lzw, sizeof(self->private_data.f_lzw), WUFFS_VERSION, initialize_flags); + &self->private_data.f_lzw, sizeof(self->private_data.f_lzw), WUFFS_VERSION, options); if (z.repr) { return z; } @@ -21303,7 +21305,7 @@ wuffs_gzip__decoder__initialize( wuffs_gzip__decoder* self, size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags){ + uint32_t options){ if (!self) { return wuffs_base__make_status(wuffs_base__error__bad_receiver); } @@ -21315,7 +21317,7 @@ wuffs_gzip__decoder__initialize( return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version); } - if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { + if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { // The whole point of this if-check is to detect an uninitialized *self. // We disable the warning on GCC. Clang-5.0 does not have this warning. #if !defined(__clang__) && defined(__GNUC__) @@ -21329,9 +21331,9 @@ wuffs_gzip__decoder__initialize( #pragma GCC diagnostic pop #endif } else { - if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { + if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { memset(self, 0, sizeof(*self)); - initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED; + options |= WUFFS_INITIALIZE__ALREADY_ZEROED; } else { memset(&(self->private_impl), 0, sizeof(self->private_impl)); } @@ -21339,14 +21341,14 @@ wuffs_gzip__decoder__initialize( { wuffs_base__status z = wuffs_crc32__ieee_hasher__initialize( - &self->private_data.f_checksum, sizeof(self->private_data.f_checksum), WUFFS_VERSION, initialize_flags); + &self->private_data.f_checksum, sizeof(self->private_data.f_checksum), WUFFS_VERSION, options); if (z.repr) { return z; } } { wuffs_base__status z = wuffs_deflate__decoder__initialize( - &self->private_data.f_flate, sizeof(self->private_data.f_flate), WUFFS_VERSION, initialize_flags); + &self->private_data.f_flate, sizeof(self->private_data.f_flate), WUFFS_VERSION, options); if (z.repr) { return z; } @@ -22079,7 +22081,7 @@ wuffs_json__decoder__initialize( wuffs_json__decoder* self, size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags){ + uint32_t options){ if (!self) { return wuffs_base__make_status(wuffs_base__error__bad_receiver); } @@ -22091,7 +22093,7 @@ wuffs_json__decoder__initialize( return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version); } - if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { + if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { // The whole point of this if-check is to detect an uninitialized *self. // We disable the warning on GCC. Clang-5.0 does not have this warning. #if !defined(__clang__) && defined(__GNUC__) @@ -22105,9 +22107,9 @@ wuffs_json__decoder__initialize( #pragma GCC diagnostic pop #endif } else { - if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { + if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { memset(self, 0, sizeof(*self)); - initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED; + options |= WUFFS_INITIALIZE__ALREADY_ZEROED; } else { memset(&(self->private_impl), 0, sizeof(self->private_impl)); } @@ -24025,7 +24027,7 @@ wuffs_wbmp__decoder__initialize( wuffs_wbmp__decoder* self, size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags){ + uint32_t options){ if (!self) { return wuffs_base__make_status(wuffs_base__error__bad_receiver); } @@ -24037,7 +24039,7 @@ wuffs_wbmp__decoder__initialize( return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version); } - if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { + if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { // The whole point of this if-check is to detect an uninitialized *self. // We disable the warning on GCC. Clang-5.0 does not have this warning. #if !defined(__clang__) && defined(__GNUC__) @@ -24051,9 +24053,9 @@ wuffs_wbmp__decoder__initialize( #pragma GCC diagnostic pop #endif } else { - if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { + if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { memset(self, 0, sizeof(*self)); - initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED; + options |= WUFFS_INITIALIZE__ALREADY_ZEROED; } else { memset(&(self->private_impl), 0, sizeof(self->private_impl)); } @@ -24799,7 +24801,7 @@ wuffs_zlib__decoder__initialize( wuffs_zlib__decoder* self, size_t sizeof_star_self, uint64_t wuffs_version, - uint32_t initialize_flags){ + uint32_t options){ if (!self) { return wuffs_base__make_status(wuffs_base__error__bad_receiver); } @@ -24811,7 +24813,7 @@ wuffs_zlib__decoder__initialize( return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version); } - if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { + if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { // The whole point of this if-check is to detect an uninitialized *self. // We disable the warning on GCC. Clang-5.0 does not have this warning. #if !defined(__clang__) && defined(__GNUC__) @@ -24825,9 +24827,9 @@ wuffs_zlib__decoder__initialize( #pragma GCC diagnostic pop #endif } else { - if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { + if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { memset(self, 0, sizeof(*self)); - initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED; + options |= WUFFS_INITIALIZE__ALREADY_ZEROED; } else { memset(&(self->private_impl), 0, sizeof(self->private_impl)); } @@ -24835,21 +24837,21 @@ wuffs_zlib__decoder__initialize( { wuffs_base__status z = wuffs_adler32__hasher__initialize( - &self->private_data.f_checksum, sizeof(self->private_data.f_checksum), WUFFS_VERSION, initialize_flags); + &self->private_data.f_checksum, sizeof(self->private_data.f_checksum), WUFFS_VERSION, options); if (z.repr) { return z; } } { wuffs_base__status z = wuffs_adler32__hasher__initialize( - &self->private_data.f_dict_id_hasher, sizeof(self->private_data.f_dict_id_hasher), WUFFS_VERSION, initialize_flags); + &self->private_data.f_dict_id_hasher, sizeof(self->private_data.f_dict_id_hasher), WUFFS_VERSION, options); if (z.repr) { return z; } } { wuffs_base__status z = wuffs_deflate__decoder__initialize( - &self->private_data.f_flate, sizeof(self->private_data.f_flate), WUFFS_VERSION, initialize_flags); + &self->private_data.f_flate, sizeof(self->private_data.f_flate), WUFFS_VERSION, options); if (z.repr) { return z; }