wuffs gen -version=0.3.0-alpha.5
diff --git a/release/c/wuffs-v0.3.c b/release/c/wuffs-v0.3.c
index d2be780..a5a893f 100644
--- a/release/c/wuffs-v0.3.c
+++ b/release/c/wuffs-v0.3.c
@@ -65,15 +65,15 @@
// each major.minor branch, the commit count should increase monotonically.
//
// WUFFS_VERSION was overridden by "wuffs gen -version" based on revision
-// d377dcaea826f12b47492cced1b75450a440f6c1 committed on 2020-06-17.
+// c94ccef400cd94a23bef9e2a3d824358147ea121 committed on 2020-07-01.
#define WUFFS_VERSION 0x000030000
#define WUFFS_VERSION_MAJOR 0
#define WUFFS_VERSION_MINOR 3
#define WUFFS_VERSION_PATCH 0
-#define WUFFS_VERSION_PRE_RELEASE_LABEL "alpha.4"
-#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 2514
-#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20200617
-#define WUFFS_VERSION_STRING "0.3.0-alpha.4+2514.20200617"
+#define WUFFS_VERSION_PRE_RELEASE_LABEL "alpha.5"
+#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 2523
+#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20200701
+#define WUFFS_VERSION_STRING "0.3.0-alpha.5+2523.20200701"
// Define WUFFS_CONFIG__STATIC_FUNCTIONS to make all of Wuffs' functions have
// static storage. The motivation is discussed in the "ALLOW STATIC
@@ -111,7 +111,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)
@@ -193,36 +195,36 @@
} wuffs_base__status;
-extern const char* wuffs_base__note__i_o_redirect;
-extern const char* wuffs_base__note__end_of_data;
-extern const char* wuffs_base__note__metadata_reported;
-extern const char* wuffs_base__suspension__even_more_information;
-extern const char* wuffs_base__suspension__mispositioned_read;
-extern const char* wuffs_base__suspension__mispositioned_write;
-extern const char* wuffs_base__suspension__short_read;
-extern const char* wuffs_base__suspension__short_write;
-extern const char* wuffs_base__error__bad_i_o_position;
-extern const char* wuffs_base__error__bad_argument_length_too_short;
-extern const char* wuffs_base__error__bad_argument;
-extern const char* wuffs_base__error__bad_call_sequence;
-extern const char* wuffs_base__error__bad_receiver;
-extern const char* wuffs_base__error__bad_restart;
-extern const char* wuffs_base__error__bad_sizeof_receiver;
-extern const char* wuffs_base__error__bad_vtable;
-extern const char* wuffs_base__error__bad_workbuf_length;
-extern const char* wuffs_base__error__bad_wuffs_version;
-extern const char* wuffs_base__error__cannot_return_a_suspension;
-extern const char* wuffs_base__error__disabled_by_previous_error;
-extern const char* wuffs_base__error__initialize_falsely_claimed_already_zeroed;
-extern const char* wuffs_base__error__initialize_not_called;
-extern const char* wuffs_base__error__interleaved_coroutine_calls;
-extern const char* wuffs_base__error__no_more_information;
-extern const char* wuffs_base__error__not_enough_data;
-extern const char* wuffs_base__error__out_of_bounds;
-extern const char* wuffs_base__error__unsupported_method;
-extern const char* wuffs_base__error__unsupported_option;
-extern const char* wuffs_base__error__unsupported_pixel_swizzler_option;
-extern const char* wuffs_base__error__too_much_data;
+extern const char wuffs_base__note__i_o_redirect[];
+extern const char wuffs_base__note__end_of_data[];
+extern const char wuffs_base__note__metadata_reported[];
+extern const char wuffs_base__suspension__even_more_information[];
+extern const char wuffs_base__suspension__mispositioned_read[];
+extern const char wuffs_base__suspension__mispositioned_write[];
+extern const char wuffs_base__suspension__short_read[];
+extern const char wuffs_base__suspension__short_write[];
+extern const char wuffs_base__error__bad_i_o_position[];
+extern const char wuffs_base__error__bad_argument_length_too_short[];
+extern const char wuffs_base__error__bad_argument[];
+extern const char wuffs_base__error__bad_call_sequence[];
+extern const char wuffs_base__error__bad_receiver[];
+extern const char wuffs_base__error__bad_restart[];
+extern const char wuffs_base__error__bad_sizeof_receiver[];
+extern const char wuffs_base__error__bad_vtable[];
+extern const char wuffs_base__error__bad_workbuf_length[];
+extern const char wuffs_base__error__bad_wuffs_version[];
+extern const char wuffs_base__error__cannot_return_a_suspension[];
+extern const char wuffs_base__error__disabled_by_previous_error[];
+extern const char wuffs_base__error__initialize_falsely_claimed_already_zeroed[];
+extern const char wuffs_base__error__initialize_not_called[];
+extern const char wuffs_base__error__interleaved_coroutine_calls[];
+extern const char wuffs_base__error__no_more_information[];
+extern const char wuffs_base__error__not_enough_data[];
+extern const char wuffs_base__error__out_of_bounds[];
+extern const char wuffs_base__error__unsupported_method[];
+extern const char wuffs_base__error__unsupported_option[];
+extern const char wuffs_base__error__unsupported_pixel_swizzler_option[];
+extern const char wuffs_base__error__too_much_data[];
static inline wuffs_base__status //
wuffs_base__make_status(const char* repr) {
@@ -353,6 +355,46 @@
// inline attribute to guide optimizations such as inlining, to avoid the
// -Wunused-function warning, and we like to compile with -Wall -Werror.
+static inline int8_t //
+wuffs_base__i8__min(int8_t x, int8_t y) {
+ return x < y ? x : y;
+}
+
+static inline int8_t //
+wuffs_base__i8__max(int8_t x, int8_t y) {
+ return x > y ? x : y;
+}
+
+static inline int16_t //
+wuffs_base__i16__min(int16_t x, int16_t y) {
+ return x < y ? x : y;
+}
+
+static inline int16_t //
+wuffs_base__i16__max(int16_t x, int16_t y) {
+ return x > y ? x : y;
+}
+
+static inline int32_t //
+wuffs_base__i32__min(int32_t x, int32_t y) {
+ return x < y ? x : y;
+}
+
+static inline int32_t //
+wuffs_base__i32__max(int32_t x, int32_t y) {
+ return x > y ? x : y;
+}
+
+static inline int64_t //
+wuffs_base__i64__min(int64_t x, int64_t y) {
+ return x < y ? x : y;
+}
+
+static inline int64_t //
+wuffs_base__i64__max(int64_t x, int64_t y) {
+ return x > y ? x : y;
+}
+
static inline uint8_t //
wuffs_base__u8__min(uint8_t x, uint8_t y) {
return x < y ? x : y;
@@ -3865,43 +3907,49 @@
// ---------------- String Conversions
-// wuffs_base__parse_number_i64 parses the ASCII integer in s. For example, if
-// s contains the bytes "-123" then it will return the int64_t -123.
-//
-// It returns an error if s does not contain an integer or if the integer
-// within would overflow an int64_t.
-//
-// It is similar to wuffs_base__parse_number_u64 but it returns a signed
-// integer, not an unsigned integer. It also allows a leading '+' or '-'.
-WUFFS_BASE__MAYBE_STATIC wuffs_base__result_i64 //
-wuffs_base__parse_number_i64(wuffs_base__slice_u8 s);
+// Options (bitwise or'ed together) for wuffs_base__render_number_xxx
+// functions. The XXX options apply to both integer and floating point. The FXX
+// options apply only to floating point.
-// wuffs_base__parse_number_u64 parses the ASCII integer in s. For example, if
-// s contains the bytes "123" then it will return the uint64_t 123.
+#define WUFFS_BASE__RENDER_NUMBER_XXX__DEFAULT_OPTIONS ((uint32_t)0x00000000)
+
+// WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT means to render to the right side
+// (higher indexes) of the destination slice, leaving any untouched bytes on
+// the left side (lower indexes). The default is vice versa: rendering on the
+// left with slack on the right.
+#define WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT ((uint32_t)0x00000001)
+
+// WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN means to render the leading
+// "+" for non-negative numbers: "+0" and "+12.3" instead of "0" and "12.3".
+#define WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN ((uint32_t)0x00000002)
+
+// WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA means to render
+// one-and-a-half as "1,5" instead of "1.5".
+#define WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA \
+ ((uint32_t)0x00000100)
+
+// WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ETC means whether to never
+// (EXPONENT_ABSENT, equivalent to printf's "%f") or to always
+// (EXPONENT_PRESENT, equivalent to printf's "%e") render a floating point
+// number as "1.23e+05" instead of "123000".
//
-// It returns an error if s does not contain an integer or if the integer
-// within would overflow a uint64_t.
+// Having both bits set is the same has having neither bit set, where the
+// notation used depends on whether the exponent is sufficiently large: "0.5"
+// is preferred over "5e-01" but "5e-09" is preferred over "0.000000005".
+#define WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT ((uint32_t)0x00000200)
+#define WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT ((uint32_t)0x00000400)
+
+// WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION means to render the
+// smallest number of digits so that parsing the resultant string will recover
+// the same double-precision floating point number.
//
-// It is similar to the C standard library's strtoull function, but:
-// - Errors are returned in-band (in a result type), not out-of-band (errno).
-// - It takes a slice (a pointer and length), not a NUL-terminated C string.
-// - It does not take an optional endptr argument. It does not allow a partial
-// parse: it returns an error unless all of s is consumed.
-// - It does not allow whitespace, leading or otherwise.
-// - It does not allow a leading '+' or '-'.
-// - It does not allow unnecessary leading zeroes ("0" is valid and its sole
-// zero is necessary). All of "00", "0644" and "007" are invalid.
-// - It does not take a base argument (e.g. base 10 vs base 16). Instead, it
-// always accepts both decimal (e.g "1234", "0d5678") and hexadecimal (e.g.
-// "0x9aBC"). The caller is responsible for prior filtering of e.g. hex
-// numbers if they are unwanted. For example, Wuffs' JSON decoder will only
-// produce a wuffs_base__token for decimal numbers, not hexadecimal.
-// - It is not affected by i18n / l10n settings such as environment variables.
-// - It does allow arbitrary underscores, except inside the optional 2-byte
-// opening "0d" or "0X" that denotes base-10 or base-16. For example,
-// "__0D_1_002" would successfully parse as "one thousand and two".
-WUFFS_BASE__MAYBE_STATIC wuffs_base__result_u64 //
-wuffs_base__parse_number_u64(wuffs_base__slice_u8 s);
+// For example, double-precision cannot distinguish between 0.3 and
+// 0.299999999999999988897769753748434595763683319091796875, so when this bit
+// is set, rendering the latter will produce "0.3" but rendering
+// 0.3000000000000000444089209850062616169452667236328125 will produce
+// "0.30000000000000004".
+#define WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION \
+ ((uint32_t)0x00000800)
// ---------------- IEEE 754 Floating Point
@@ -3944,6 +3992,8 @@
WUFFS_BASE__MAYBE_STATIC wuffs_base__result_f64 //
wuffs_base__parse_number_f64(wuffs_base__slice_u8 s);
+// --------
+
// wuffs_base__ieee_754_bit_representation__etc converts between a double
// precision numerical value and its IEEE 754 64-bit representation (1 sign
// bit, 11 exponent bits, 52 explicit significand bits).
@@ -3973,6 +4023,105 @@
return f;
}
+// ---------------- Integer
+
+// wuffs_base__parse_number_i64 parses the ASCII integer in s. For example, if
+// s contains the bytes "-123" then it will return the int64_t -123.
+//
+// It returns an error if s does not contain an integer or if the integer
+// within would overflow an int64_t.
+//
+// It is similar to wuffs_base__parse_number_u64 but it returns a signed
+// integer, not an unsigned integer. It also allows a leading '+' or '-'.
+WUFFS_BASE__MAYBE_STATIC wuffs_base__result_i64 //
+wuffs_base__parse_number_i64(wuffs_base__slice_u8 s);
+
+// wuffs_base__parse_number_u64 parses the ASCII integer in s. For example, if
+// s contains the bytes "123" then it will return the uint64_t 123.
+//
+// It returns an error if s does not contain an integer or if the integer
+// within would overflow a uint64_t.
+//
+// It is similar to the C standard library's strtoull function, but:
+// - Errors are returned in-band (in a result type), not out-of-band (errno).
+// - It takes a slice (a pointer and length), not a NUL-terminated C string.
+// - It does not take an optional endptr argument. It does not allow a partial
+// parse: it returns an error unless all of s is consumed.
+// - It does not allow whitespace, leading or otherwise.
+// - It does not allow a leading '+' or '-'.
+// - It does not allow unnecessary leading zeroes ("0" is valid and its sole
+// zero is necessary). All of "00", "0644" and "007" are invalid.
+// - It does not take a base argument (e.g. base 10 vs base 16). Instead, it
+// always accepts both decimal (e.g "1234", "0d5678") and hexadecimal (e.g.
+// "0x9aBC"). The caller is responsible for prior filtering of e.g. hex
+// numbers if they are unwanted. For example, Wuffs' JSON decoder will only
+// produce a wuffs_base__token for decimal numbers, not hexadecimal.
+// - It is not affected by i18n / l10n settings such as environment variables.
+// - It does allow arbitrary underscores, except inside the optional 2-byte
+// opening "0d" or "0X" that denotes base-10 or base-16. For example,
+// "__0D_1_002" would successfully parse as "one thousand and two".
+WUFFS_BASE__MAYBE_STATIC wuffs_base__result_u64 //
+wuffs_base__parse_number_u64(wuffs_base__slice_u8 s);
+
+// --------
+
+#define WUFFS_BASE__I64__BYTE_LENGTH__MAX_INCL 20
+#define WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL 21
+
+// wuffs_base__render_number_f64 writes the decimal encoding of x to dst and
+// returns the number of bytes written. If dst is shorter than the entire
+// encoding, it returns 0 (and no bytes are written).
+//
+// For those familiar with C's printf or Go's fmt.Printf functions:
+// - "%e" means the WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT option.
+// - "%f" means the WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT option.
+// - "%g" means neither or both bits are set.
+//
+// The precision argument controls the number of digits rendered, excluding the
+// exponent (the "e+05" in "1.23e+05"):
+// - for "%e" and "%f" it is the number of digits after the decimal separator,
+// - for "%g" it is the number of significant digits (and trailing zeroes are
+// removed).
+//
+// A precision of 6 gives similar output to printf's defaults.
+//
+// A precision greater than 4095 is equivalent to 4095.
+//
+// The precision argument is ignored when the
+// WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION option is set. This is
+// similar to Go's strconv.FormatFloat with a negative (i.e. non-sensical)
+// precision, but there is no corresponding feature in C's printf.
+//
+// Extreme values of x will be rendered as "NaN", "Inf" (or "+Inf" if the
+// WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN option is set) or "-Inf".
+WUFFS_BASE__MAYBE_STATIC size_t //
+wuffs_base__render_number_f64(wuffs_base__slice_u8 dst,
+ double x,
+ uint32_t precision,
+ uint32_t options);
+
+// wuffs_base__render_number_i64 writes the decimal encoding of x to dst and
+// returns the number of bytes written. If dst is shorter than the entire
+// encoding, it returns 0 (and no bytes are written).
+//
+// dst will never be too short if its length is at least 20, also known as
+// WUFFS_BASE__I64__BYTE_LENGTH__MAX_INCL.
+WUFFS_BASE__MAYBE_STATIC size_t //
+wuffs_base__render_number_i64(wuffs_base__slice_u8 dst,
+ int64_t x,
+ uint32_t options);
+
+// wuffs_base__render_number_u64 writes the decimal encoding of x to dst and
+// returns the number of bytes written. If dst is shorter than the entire
+// encoding, it returns 0 (and no bytes are written).
+//
+// dst will never be too short if its length is at least 21, also known as
+// WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL.
+WUFFS_BASE__MAYBE_STATIC size_t //
+wuffs_base__render_number_u64(wuffs_base__slice_u8 dst,
+ uint64_t x,
+ uint32_t options);
+
// ---------------- Hexadecimal
// wuffs_base__hexadecimal__decode2 converts "6A6b" to "jk", where e.g. 'j' is
@@ -4141,7 +4290,7 @@
// --------
-extern const char* wuffs_base__hasher_u32__vtable_name;
+extern const char wuffs_base__hasher_u32__vtable_name[];
typedef struct {
wuffs_base__empty_struct (*set_quirk_enabled)(
@@ -4202,7 +4351,7 @@
// --------
-extern const char* wuffs_base__image_decoder__vtable_name;
+extern const char wuffs_base__image_decoder__vtable_name[];
typedef struct {
wuffs_base__status (*decode_frame)(
@@ -4423,7 +4572,7 @@
// --------
-extern const char* wuffs_base__io_transformer__vtable_name;
+extern const char wuffs_base__io_transformer__vtable_name[];
typedef struct {
wuffs_base__empty_struct (*set_quirk_enabled)(
@@ -4501,7 +4650,7 @@
// --------
-extern const char* wuffs_base__token_decoder__vtable_name;
+extern const char wuffs_base__token_decoder__vtable_name[];
typedef struct {
wuffs_base__status (*decode_tokens)(
@@ -4601,14 +4750,14 @@
// 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();
@@ -4727,9 +4876,9 @@
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*
@@ -4765,8 +4914,8 @@
// ---------------- Status Codes
-extern const char* wuffs_bmp__error__bad_header;
-extern const char* wuffs_bmp__error__unsupported_bmp_file;
+extern const char wuffs_bmp__error__bad_header[];
+extern const char wuffs_bmp__error__unsupported_bmp_file[];
// ---------------- Public Consts
@@ -4782,14 +4931,14 @@
// 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();
@@ -5002,9 +5151,9 @@
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*
@@ -5117,14 +5266,14 @@
// 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();
@@ -5242,9 +5391,9 @@
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*
@@ -5280,19 +5429,19 @@
// ---------------- Status Codes
-extern const char* wuffs_deflate__error__bad_huffman_code_over_subscribed;
-extern const char* wuffs_deflate__error__bad_huffman_code_under_subscribed;
-extern const char* wuffs_deflate__error__bad_huffman_code_length_count;
-extern const char* wuffs_deflate__error__bad_huffman_code_length_repetition;
-extern const char* wuffs_deflate__error__bad_huffman_code;
-extern const char* wuffs_deflate__error__bad_huffman_minimum_code_length;
-extern const char* wuffs_deflate__error__bad_block;
-extern const char* wuffs_deflate__error__bad_distance;
-extern const char* wuffs_deflate__error__bad_distance_code_count;
-extern const char* wuffs_deflate__error__bad_literal_length_code_count;
-extern const char* wuffs_deflate__error__inconsistent_stored_block_length;
-extern const char* wuffs_deflate__error__missing_end_of_block_code;
-extern const char* wuffs_deflate__error__no_huffman_codes;
+extern const char wuffs_deflate__error__bad_huffman_code_over_subscribed[];
+extern const char wuffs_deflate__error__bad_huffman_code_under_subscribed[];
+extern const char wuffs_deflate__error__bad_huffman_code_length_count[];
+extern const char wuffs_deflate__error__bad_huffman_code_length_repetition[];
+extern const char wuffs_deflate__error__bad_huffman_code[];
+extern const char wuffs_deflate__error__bad_huffman_minimum_code_length[];
+extern const char wuffs_deflate__error__bad_block[];
+extern const char wuffs_deflate__error__bad_distance[];
+extern const char wuffs_deflate__error__bad_distance_code_count[];
+extern const char wuffs_deflate__error__bad_literal_length_code_count[];
+extern const char wuffs_deflate__error__inconsistent_stored_block_length[];
+extern const char wuffs_deflate__error__missing_end_of_block_code[];
+extern const char wuffs_deflate__error__no_huffman_codes[];
// ---------------- Public Consts
@@ -5308,14 +5457,14 @@
// 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();
@@ -5496,9 +5645,9 @@
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*
@@ -5547,7 +5696,7 @@
// ---------------- Status Codes
-extern const char* wuffs_lzw__error__bad_code;
+extern const char wuffs_lzw__error__bad_code[];
// ---------------- Public Consts
@@ -5563,14 +5712,14 @@
// 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();
@@ -5724,9 +5873,9 @@
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*
@@ -5780,12 +5929,12 @@
// ---------------- Status Codes
-extern const char* wuffs_gif__error__bad_extension_label;
-extern const char* wuffs_gif__error__bad_frame_size;
-extern const char* wuffs_gif__error__bad_graphic_control;
-extern const char* wuffs_gif__error__bad_header;
-extern const char* wuffs_gif__error__bad_literal_width;
-extern const char* wuffs_gif__error__bad_palette;
+extern const char wuffs_gif__error__bad_extension_label[];
+extern const char wuffs_gif__error__bad_frame_size[];
+extern const char wuffs_gif__error__bad_graphic_control[];
+extern const char wuffs_gif__error__bad_header[];
+extern const char wuffs_gif__error__bad_literal_width[];
+extern const char wuffs_gif__error__bad_palette[];
// ---------------- Public Consts
@@ -5817,14 +5966,14 @@
// 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();
@@ -5834,7 +5983,7 @@
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();
@@ -6168,9 +6317,9 @@
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*
@@ -6431,9 +6580,9 @@
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*
@@ -6534,10 +6683,10 @@
// ---------------- Status Codes
-extern const char* wuffs_gzip__error__bad_checksum;
-extern const char* wuffs_gzip__error__bad_compression_method;
-extern const char* wuffs_gzip__error__bad_encoding_flags;
-extern const char* wuffs_gzip__error__bad_header;
+extern const char wuffs_gzip__error__bad_checksum[];
+extern const char wuffs_gzip__error__bad_compression_method[];
+extern const char wuffs_gzip__error__bad_encoding_flags[];
+extern const char wuffs_gzip__error__bad_header[];
// ---------------- Public Consts
@@ -6553,14 +6702,14 @@
// 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();
@@ -6704,9 +6853,9 @@
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*
@@ -6755,12 +6904,12 @@
// ---------------- Status Codes
-extern const char* wuffs_json__error__bad_c0_control_code;
-extern const char* wuffs_json__error__bad_utf_8;
-extern const char* wuffs_json__error__bad_backslash_escape;
-extern const char* wuffs_json__error__bad_input;
-extern const char* wuffs_json__error__unsupported_number_length;
-extern const char* wuffs_json__error__unsupported_recursion_depth;
+extern const char wuffs_json__error__bad_c0_control_code[];
+extern const char wuffs_json__error__bad_utf_8[];
+extern const char wuffs_json__error__bad_backslash_escape[];
+extern const char wuffs_json__error__bad_input[];
+extern const char wuffs_json__error__unsupported_number_length[];
+extern const char wuffs_json__error__unsupported_recursion_depth[];
// ---------------- Public Consts
@@ -6818,14 +6967,14 @@
// 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();
@@ -6971,9 +7120,9 @@
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*
@@ -7016,7 +7165,7 @@
// ---------------- Status Codes
-extern const char* wuffs_wbmp__error__bad_header;
+extern const char wuffs_wbmp__error__bad_header[];
// ---------------- Public Consts
@@ -7032,14 +7181,14 @@
// 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();
@@ -7238,9 +7387,9 @@
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*
@@ -7341,12 +7490,12 @@
// ---------------- Status Codes
-extern const char* wuffs_zlib__note__dictionary_required;
-extern const char* wuffs_zlib__error__bad_checksum;
-extern const char* wuffs_zlib__error__bad_compression_method;
-extern const char* wuffs_zlib__error__bad_compression_window_size;
-extern const char* wuffs_zlib__error__bad_parity_check;
-extern const char* wuffs_zlib__error__incorrect_dictionary;
+extern const char wuffs_zlib__note__dictionary_required[];
+extern const char wuffs_zlib__error__bad_checksum[];
+extern const char wuffs_zlib__error__bad_compression_method[];
+extern const char wuffs_zlib__error__bad_compression_window_size[];
+extern const char wuffs_zlib__error__bad_parity_check[];
+extern const char wuffs_zlib__error__incorrect_dictionary[];
// ---------------- Public Consts
@@ -7362,14 +7511,14 @@
// 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();
@@ -7526,9 +7675,9 @@
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*
@@ -8154,548 +8303,41 @@
0x08, 0x0A, 0x0C, 0x10, 0x18, 0x20, 0x30, 0x40,
};
-const char* wuffs_base__note__i_o_redirect = "@base: I/O redirect";
-const char* wuffs_base__note__end_of_data = "@base: end of data";
-const char* wuffs_base__note__metadata_reported = "@base: metadata reported";
-const char* wuffs_base__suspension__even_more_information = "$base: even more information";
-const char* wuffs_base__suspension__mispositioned_read = "$base: mispositioned read";
-const char* wuffs_base__suspension__mispositioned_write = "$base: mispositioned write";
-const char* wuffs_base__suspension__short_read = "$base: short read";
-const char* wuffs_base__suspension__short_write = "$base: short write";
-const char* wuffs_base__error__bad_i_o_position = "#base: bad I/O position";
-const char* wuffs_base__error__bad_argument_length_too_short = "#base: bad argument (length too short)";
-const char* wuffs_base__error__bad_argument = "#base: bad argument";
-const char* wuffs_base__error__bad_call_sequence = "#base: bad call sequence";
-const char* wuffs_base__error__bad_receiver = "#base: bad receiver";
-const char* wuffs_base__error__bad_restart = "#base: bad restart";
-const char* wuffs_base__error__bad_sizeof_receiver = "#base: bad sizeof receiver";
-const char* wuffs_base__error__bad_vtable = "#base: bad vtable";
-const char* wuffs_base__error__bad_workbuf_length = "#base: bad workbuf length";
-const char* wuffs_base__error__bad_wuffs_version = "#base: bad wuffs version";
-const char* wuffs_base__error__cannot_return_a_suspension = "#base: cannot return a suspension";
-const char* wuffs_base__error__disabled_by_previous_error = "#base: disabled by previous error";
-const char* wuffs_base__error__initialize_falsely_claimed_already_zeroed = "#base: initialize falsely claimed already zeroed";
-const char* wuffs_base__error__initialize_not_called = "#base: initialize not called";
-const char* wuffs_base__error__interleaved_coroutine_calls = "#base: interleaved coroutine calls";
-const char* wuffs_base__error__no_more_information = "#base: no more information";
-const char* wuffs_base__error__not_enough_data = "#base: not enough data";
-const char* wuffs_base__error__out_of_bounds = "#base: out of bounds";
-const char* wuffs_base__error__unsupported_method = "#base: unsupported method";
-const char* wuffs_base__error__unsupported_option = "#base: unsupported option";
-const char* wuffs_base__error__unsupported_pixel_swizzler_option = "#base: unsupported pixel swizzler option";
-const char* wuffs_base__error__too_much_data = "#base: too much data";
+const char wuffs_base__note__i_o_redirect[] = "@base: I/O redirect";
+const char wuffs_base__note__end_of_data[] = "@base: end of data";
+const char wuffs_base__note__metadata_reported[] = "@base: metadata reported";
+const char wuffs_base__suspension__even_more_information[] = "$base: even more information";
+const char wuffs_base__suspension__mispositioned_read[] = "$base: mispositioned read";
+const char wuffs_base__suspension__mispositioned_write[] = "$base: mispositioned write";
+const char wuffs_base__suspension__short_read[] = "$base: short read";
+const char wuffs_base__suspension__short_write[] = "$base: short write";
+const char wuffs_base__error__bad_i_o_position[] = "#base: bad I/O position";
+const char wuffs_base__error__bad_argument_length_too_short[] = "#base: bad argument (length too short)";
+const char wuffs_base__error__bad_argument[] = "#base: bad argument";
+const char wuffs_base__error__bad_call_sequence[] = "#base: bad call sequence";
+const char wuffs_base__error__bad_receiver[] = "#base: bad receiver";
+const char wuffs_base__error__bad_restart[] = "#base: bad restart";
+const char wuffs_base__error__bad_sizeof_receiver[] = "#base: bad sizeof receiver";
+const char wuffs_base__error__bad_vtable[] = "#base: bad vtable";
+const char wuffs_base__error__bad_workbuf_length[] = "#base: bad workbuf length";
+const char wuffs_base__error__bad_wuffs_version[] = "#base: bad wuffs version";
+const char wuffs_base__error__cannot_return_a_suspension[] = "#base: cannot return a suspension";
+const char wuffs_base__error__disabled_by_previous_error[] = "#base: disabled by previous error";
+const char wuffs_base__error__initialize_falsely_claimed_already_zeroed[] = "#base: initialize falsely claimed already zeroed";
+const char wuffs_base__error__initialize_not_called[] = "#base: initialize not called";
+const char wuffs_base__error__interleaved_coroutine_calls[] = "#base: interleaved coroutine calls";
+const char wuffs_base__error__no_more_information[] = "#base: no more information";
+const char wuffs_base__error__not_enough_data[] = "#base: not enough data";
+const char wuffs_base__error__out_of_bounds[] = "#base: out of bounds";
+const char wuffs_base__error__unsupported_method[] = "#base: unsupported method";
+const char wuffs_base__error__unsupported_option[] = "#base: unsupported option";
+const char wuffs_base__error__unsupported_pixel_swizzler_option[] = "#base: unsupported pixel swizzler option";
+const char wuffs_base__error__too_much_data[] = "#base: too much data";
-const char* wuffs_base__hasher_u32__vtable_name = "{vtable}wuffs_base__hasher_u32";
-const char* wuffs_base__image_decoder__vtable_name = "{vtable}wuffs_base__image_decoder";
-const char* wuffs_base__io_transformer__vtable_name = "{vtable}wuffs_base__io_transformer";
-const char* wuffs_base__token_decoder__vtable_name = "{vtable}wuffs_base__token_decoder";
-
-// ---------------- String Conversions
-
-// wuffs_base__parse_number__foo_digits entries are 0x00 for invalid digits,
-// and (0x80 | v) for valid digits, where v is the 4 bit value.
-
-static const uint8_t wuffs_base__parse_number__decimal_digits[256] = {
- // 0 1 2 3 4 5 6 7
- // 8 9 A B C D E F
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x00 ..= 0x07.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x08 ..= 0x0F.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x10 ..= 0x17.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x18 ..= 0x1F.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 ..= 0x27.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x28 ..= 0x2F.
- 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, // 0x30 ..= 0x37. '0'-'7'.
- 0x88, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x38 ..= 0x3F. '8'-'9'.
-
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x40 ..= 0x47.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x48 ..= 0x4F.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x50 ..= 0x57.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x58 ..= 0x5F.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x60 ..= 0x67.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x68 ..= 0x6F.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x70 ..= 0x77.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x78 ..= 0x7F.
-
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x80 ..= 0x87.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x88 ..= 0x8F.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x90 ..= 0x97.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x98 ..= 0x9F.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xA0 ..= 0xA7.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xA8 ..= 0xAF.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xB0 ..= 0xB7.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xB8 ..= 0xBF.
-
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xC0 ..= 0xC7.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xC8 ..= 0xCF.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xD0 ..= 0xD7.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xD8 ..= 0xDF.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xE0 ..= 0xE7.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xE8 ..= 0xEF.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xF0 ..= 0xF7.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xF8 ..= 0xFF.
- // 0 1 2 3 4 5 6 7
- // 8 9 A B C D E F
-};
-
-static const uint8_t wuffs_base__parse_number__hexadecimal_digits[256] = {
- // 0 1 2 3 4 5 6 7
- // 8 9 A B C D E F
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x00 ..= 0x07.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x08 ..= 0x0F.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x10 ..= 0x17.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x18 ..= 0x1F.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 ..= 0x27.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x28 ..= 0x2F.
- 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, // 0x30 ..= 0x37. '0'-'7'.
- 0x88, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x38 ..= 0x3F. '8'-'9'.
-
- 0x00, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x00, // 0x40 ..= 0x47. 'A'-'F'.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x48 ..= 0x4F.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x50 ..= 0x57.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x58 ..= 0x5F.
- 0x00, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x00, // 0x60 ..= 0x67. 'a'-'f'.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x68 ..= 0x6F.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x70 ..= 0x77.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x78 ..= 0x7F.
-
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x80 ..= 0x87.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x88 ..= 0x8F.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x90 ..= 0x97.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x98 ..= 0x9F.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xA0 ..= 0xA7.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xA8 ..= 0xAF.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xB0 ..= 0xB7.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xB8 ..= 0xBF.
-
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xC0 ..= 0xC7.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xC8 ..= 0xCF.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xD0 ..= 0xD7.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xD8 ..= 0xDF.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xE0 ..= 0xE7.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xE8 ..= 0xEF.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xF0 ..= 0xF7.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xF8 ..= 0xFF.
- // 0 1 2 3 4 5 6 7
- // 8 9 A B C D E F
-};
-
-// --------
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__result_i64 //
-wuffs_base__parse_number_i64(wuffs_base__slice_u8 s) {
- uint8_t* p = s.ptr;
- uint8_t* q = s.ptr + s.len;
-
- for (; (p < q) && (*p == '_'); p++) {
- }
-
- bool negative = false;
- if (p >= q) {
- goto fail_bad_argument;
- } else if (*p == '-') {
- p++;
- negative = true;
- } else if (*p == '+') {
- p++;
- }
-
- do {
- wuffs_base__result_u64 r = wuffs_base__parse_number_u64(
- wuffs_base__make_slice_u8(p, (size_t)(q - p)));
- if (r.status.repr != NULL) {
- wuffs_base__result_i64 ret;
- ret.status.repr = r.status.repr;
- ret.value = 0;
- return ret;
- } else if (negative) {
- if (r.value > 0x8000000000000000) {
- goto fail_out_of_bounds;
- }
- wuffs_base__result_i64 ret;
- ret.status.repr = NULL;
- ret.value = -(int64_t)(r.value);
- return ret;
- } else if (r.value > 0x7FFFFFFFFFFFFFFF) {
- goto fail_out_of_bounds;
- } else {
- wuffs_base__result_i64 ret;
- ret.status.repr = NULL;
- ret.value = +(int64_t)(r.value);
- return ret;
- }
- } while (0);
-
-fail_bad_argument:
- do {
- wuffs_base__result_i64 ret;
- ret.status.repr = wuffs_base__error__bad_argument;
- ret.value = 0;
- return ret;
- } while (0);
-
-fail_out_of_bounds:
- do {
- wuffs_base__result_i64 ret;
- ret.status.repr = wuffs_base__error__out_of_bounds;
- ret.value = 0;
- return ret;
- } while (0);
-}
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__result_u64 //
-wuffs_base__parse_number_u64(wuffs_base__slice_u8 s) {
- uint8_t* p = s.ptr;
- uint8_t* q = s.ptr + s.len;
-
- for (; (p < q) && (*p == '_'); p++) {
- }
-
- if (p >= q) {
- goto fail_bad_argument;
-
- } else if (*p == '0') {
- p++;
- if (p >= q) {
- goto ok_zero;
- }
- if (*p == '_') {
- p++;
- for (; p < q; p++) {
- if (*p != '_') {
- goto fail_bad_argument;
- }
- }
- goto ok_zero;
- }
-
- if ((*p == 'x') || (*p == 'X')) {
- p++;
- for (; (p < q) && (*p == '_'); p++) {
- }
- if (p < q) {
- goto hexadecimal;
- }
-
- } else if ((*p == 'd') || (*p == 'D')) {
- p++;
- for (; (p < q) && (*p == '_'); p++) {
- }
- if (p < q) {
- goto decimal;
- }
- }
-
- goto fail_bad_argument;
- }
-
-decimal:
- do {
- uint64_t v = wuffs_base__parse_number__decimal_digits[*p++];
- if (v == 0) {
- goto fail_bad_argument;
- }
- v &= 0x0F;
-
- // UINT64_MAX is 18446744073709551615, which is ((10 * max10) + max1).
- const uint64_t max10 = 1844674407370955161u;
- const uint8_t max1 = 5;
-
- for (; p < q; p++) {
- if (*p == '_') {
- continue;
- }
- uint8_t digit = wuffs_base__parse_number__decimal_digits[*p];
- if (digit == 0) {
- goto fail_bad_argument;
- }
- digit &= 0x0F;
- if ((v > max10) || ((v == max10) && (digit > max1))) {
- goto fail_out_of_bounds;
- }
- v = (10 * v) + ((uint64_t)(digit));
- }
-
- wuffs_base__result_u64 ret;
- ret.status.repr = NULL;
- ret.value = v;
- return ret;
- } while (0);
-
-hexadecimal:
- do {
- uint64_t v = wuffs_base__parse_number__hexadecimal_digits[*p++];
- if (v == 0) {
- goto fail_bad_argument;
- }
- v &= 0x0F;
-
- for (; p < q; p++) {
- if (*p == '_') {
- continue;
- }
- uint8_t digit = wuffs_base__parse_number__hexadecimal_digits[*p];
- if (digit == 0) {
- goto fail_bad_argument;
- }
- digit &= 0x0F;
- if ((v >> 60) != 0) {
- goto fail_out_of_bounds;
- }
- v = (v << 4) | ((uint64_t)(digit));
- }
-
- wuffs_base__result_u64 ret;
- ret.status.repr = NULL;
- ret.value = v;
- return ret;
- } while (0);
-
-ok_zero:
- do {
- wuffs_base__result_u64 ret;
- ret.status.repr = NULL;
- ret.value = 0;
- return ret;
- } while (0);
-
-fail_bad_argument:
- do {
- wuffs_base__result_u64 ret;
- ret.status.repr = wuffs_base__error__bad_argument;
- ret.value = 0;
- return ret;
- } while (0);
-
-fail_out_of_bounds:
- do {
- wuffs_base__result_u64 ret;
- ret.status.repr = wuffs_base__error__out_of_bounds;
- ret.value = 0;
- return ret;
- } while (0);
-}
-
-// ---------------- Hexadecimal
-
-WUFFS_BASE__MAYBE_STATIC size_t //
-wuffs_base__hexadecimal__decode2(wuffs_base__slice_u8 dst,
- wuffs_base__slice_u8 src) {
- size_t src_len2 = src.len / 2;
- size_t len = dst.len < src_len2 ? dst.len : src_len2;
- uint8_t* d = dst.ptr;
- uint8_t* s = src.ptr;
- size_t n = len;
-
- while (n--) {
- *d = (uint8_t)((wuffs_base__parse_number__hexadecimal_digits[s[0]] << 4) |
- (wuffs_base__parse_number__hexadecimal_digits[s[1]] & 0x0F));
- d += 1;
- s += 2;
- }
-
- return len;
-}
-
-WUFFS_BASE__MAYBE_STATIC size_t //
-wuffs_base__hexadecimal__decode4(wuffs_base__slice_u8 dst,
- wuffs_base__slice_u8 src) {
- size_t src_len4 = src.len / 4;
- size_t len = dst.len < src_len4 ? dst.len : src_len4;
- uint8_t* d = dst.ptr;
- uint8_t* s = src.ptr;
- size_t n = len;
-
- while (n--) {
- *d = (uint8_t)((wuffs_base__parse_number__hexadecimal_digits[s[2]] << 4) |
- (wuffs_base__parse_number__hexadecimal_digits[s[3]] & 0x0F));
- d += 1;
- s += 4;
- }
-
- return len;
-}
-
-// ---------------- Unicode and UTF-8
-
-WUFFS_BASE__MAYBE_STATIC size_t //
-wuffs_base__utf_8__encode(wuffs_base__slice_u8 dst, uint32_t code_point) {
- if (code_point <= 0x7F) {
- if (dst.len >= 1) {
- dst.ptr[0] = (uint8_t)(code_point);
- return 1;
- }
-
- } else if (code_point <= 0x07FF) {
- if (dst.len >= 2) {
- dst.ptr[0] = (uint8_t)(0xC0 | ((code_point >> 6)));
- dst.ptr[1] = (uint8_t)(0x80 | ((code_point >> 0) & 0x3F));
- return 2;
- }
-
- } else if (code_point <= 0xFFFF) {
- if ((dst.len >= 3) && ((code_point < 0xD800) || (0xDFFF < code_point))) {
- dst.ptr[0] = (uint8_t)(0xE0 | ((code_point >> 12)));
- dst.ptr[1] = (uint8_t)(0x80 | ((code_point >> 6) & 0x3F));
- dst.ptr[2] = (uint8_t)(0x80 | ((code_point >> 0) & 0x3F));
- return 3;
- }
-
- } else if (code_point <= 0x10FFFF) {
- if (dst.len >= 4) {
- dst.ptr[0] = (uint8_t)(0xF0 | ((code_point >> 18)));
- dst.ptr[1] = (uint8_t)(0x80 | ((code_point >> 12) & 0x3F));
- dst.ptr[2] = (uint8_t)(0x80 | ((code_point >> 6) & 0x3F));
- dst.ptr[3] = (uint8_t)(0x80 | ((code_point >> 0) & 0x3F));
- return 4;
- }
- }
-
- return 0;
-}
-
-// wuffs_base__utf_8__byte_length_minus_1 is the byte length (minus 1) of a
-// UTF-8 encoded code point, based on the encoding's initial byte.
-// - 0x00 is 1-byte UTF-8 (ASCII).
-// - 0x01 is the start of 2-byte UTF-8.
-// - 0x02 is the start of 3-byte UTF-8.
-// - 0x03 is the start of 4-byte UTF-8.
-// - 0x40 is a UTF-8 tail byte.
-// - 0x80 is invalid UTF-8.
-//
-// RFC 3629 (UTF-8) gives this grammar for valid UTF-8:
-// UTF8-1 = %x00-7F
-// UTF8-2 = %xC2-DF UTF8-tail
-// UTF8-3 = %xE0 %xA0-BF UTF8-tail / %xE1-EC 2( UTF8-tail ) /
-// %xED %x80-9F UTF8-tail / %xEE-EF 2( UTF8-tail )
-// UTF8-4 = %xF0 %x90-BF 2( UTF8-tail ) / %xF1-F3 3( UTF8-tail ) /
-// %xF4 %x80-8F 2( UTF8-tail )
-// UTF8-tail = %x80-BF
-static const uint8_t wuffs_base__utf_8__byte_length_minus_1[256] = {
- // 0 1 2 3 4 5 6 7
- // 8 9 A B C D E F
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x00 ..= 0x07.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x08 ..= 0x0F.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x10 ..= 0x17.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x18 ..= 0x1F.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 ..= 0x27.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x28 ..= 0x2F.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x30 ..= 0x37.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x38 ..= 0x3F.
-
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x40 ..= 0x47.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x48 ..= 0x4F.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x50 ..= 0x57.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x58 ..= 0x5F.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x60 ..= 0x67.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x68 ..= 0x6F.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x70 ..= 0x77.
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x78 ..= 0x7F.
-
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0x80 ..= 0x87.
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0x88 ..= 0x8F.
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0x90 ..= 0x97.
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0x98 ..= 0x9F.
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0xA0 ..= 0xA7.
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0xA8 ..= 0xAF.
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0xB0 ..= 0xB7.
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0xB8 ..= 0xBF.
-
- 0x80, 0x80, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, // 0xC0 ..= 0xC7.
- 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, // 0xC8 ..= 0xCF.
- 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, // 0xD0 ..= 0xD7.
- 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, // 0xD8 ..= 0xDF.
- 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xE0 ..= 0xE7.
- 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xE8 ..= 0xEF.
- 0x03, 0x03, 0x03, 0x03, 0x03, 0x80, 0x80, 0x80, // 0xF0 ..= 0xF7.
- 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xF8 ..= 0xFF.
- // 0 1 2 3 4 5 6 7
- // 8 9 A B C D E F
-};
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__utf_8__next__output //
-wuffs_base__utf_8__next(wuffs_base__slice_u8 s) {
- if (s.len == 0) {
- return wuffs_base__make_utf_8__next__output(0, 0);
- }
- uint32_t c = s.ptr[0];
- switch (wuffs_base__utf_8__byte_length_minus_1[c & 0xFF]) {
- case 0:
- return wuffs_base__make_utf_8__next__output(c, 1);
-
- case 1:
- if (s.len < 2) {
- break;
- }
- c = wuffs_base__load_u16le__no_bounds_check(s.ptr);
- if ((c & 0xC000) != 0x8000) {
- break;
- }
- c = (0x0007C0 & (c << 6)) | (0x00003F & (c >> 8));
- return wuffs_base__make_utf_8__next__output(c, 2);
-
- case 2:
- if (s.len < 3) {
- break;
- }
- c = wuffs_base__load_u24le__no_bounds_check(s.ptr);
- if ((c & 0xC0C000) != 0x808000) {
- break;
- }
- c = (0x00F000 & (c << 12)) | (0x000FC0 & (c >> 2)) |
- (0x00003F & (c >> 16));
- if ((c <= 0x07FF) || ((0xD800 <= c) && (c <= 0xDFFF))) {
- break;
- }
- return wuffs_base__make_utf_8__next__output(c, 3);
-
- case 3:
- if (s.len < 4) {
- break;
- }
- c = wuffs_base__load_u32le__no_bounds_check(s.ptr);
- if ((c & 0xC0C0C000) != 0x80808000) {
- break;
- }
- c = (0x1C0000 & (c << 18)) | (0x03F000 & (c << 4)) |
- (0x000FC0 & (c >> 10)) | (0x00003F & (c >> 24));
- if ((c <= 0xFFFF) || (0x110000 <= c)) {
- break;
- }
- return wuffs_base__make_utf_8__next__output(c, 4);
- }
-
- return wuffs_base__make_utf_8__next__output(
- WUFFS_BASE__UNICODE_REPLACEMENT_CHARACTER, 1);
-}
-
-WUFFS_BASE__MAYBE_STATIC size_t //
-wuffs_base__utf_8__longest_valid_prefix(wuffs_base__slice_u8 s) {
- // TODO: possibly optimize the all-ASCII case (4 or 8 bytes at a time).
- //
- // TODO: possibly optimize this by manually inlining the
- // wuffs_base__utf_8__next calls.
- size_t original_len = s.len;
- while (s.len > 0) {
- wuffs_base__utf_8__next__output o = wuffs_base__utf_8__next(s);
- if ((o.code_point > 0x7F) && (o.byte_length == 1)) {
- break;
- }
- s.ptr += o.byte_length;
- s.len -= o.byte_length;
- }
- return original_len - s.len;
-}
-
-WUFFS_BASE__MAYBE_STATIC size_t //
-wuffs_base__ascii__longest_valid_prefix(wuffs_base__slice_u8 s) {
- // TODO: possibly optimize this by checking 4 or 8 bytes at a time.
- uint8_t* original_ptr = s.ptr;
- uint8_t* p = s.ptr;
- uint8_t* q = s.ptr + s.len;
- for (; (p != q) && ((*p & 0x80) == 0); p++) {
- }
- return (size_t)(p - original_ptr);
-}
+const char wuffs_base__hasher_u32__vtable_name[] = "{vtable}wuffs_base__hasher_u32";
+const char wuffs_base__image_decoder__vtable_name[] = "{vtable}wuffs_base__image_decoder";
+const char wuffs_base__io_transformer__vtable_name[] = "{vtable}wuffs_base__io_transformer";
+const char wuffs_base__token_decoder__vtable_name[] = "{vtable}wuffs_base__token_decoder";
#endif // !defined(WUFFS_CONFIG__MODULES) ||
// defined(WUFFS_CONFIG__MODULE__BASE) ||
@@ -9300,8 +8942,8 @@
// ---------------- IEEE 754 Floating Point
-#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE 1023
-#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION 500
+#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE 2047
+#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION 800
// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL is the largest N
// such that ((10 << N) < (1 << 64)).
@@ -9311,14 +8953,14 @@
// fixed precision floating point decimal number, augmented with ±infinity
// values, but it cannot represent NaN (Not a Number).
//
-// "High precision" means that the mantissa holds 500 decimal digits. 500 is
+// "High precision" means that the mantissa holds 800 decimal digits. 800 is
// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION.
//
// An HPD isn't for general purpose arithmetic, only for conversions to and
// from IEEE 754 double-precision floating point, where the largest and
// smallest positive, finite values are approximately 1.8e+308 and 4.9e-324.
-// HPD exponents above +1023 mean infinity, below -1023 mean zero. The ±1023
-// bounds are further away from zero than ±(324 + 500), where 500 and 1023 is
+// HPD exponents above +2047 mean infinity, below -2047 mean zero. The ±2047
+// bounds are further away from zero than ±(324 + 800), where 800 and 2047 is
// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION and
// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE.
//
@@ -9340,8 +8982,8 @@
// - A decimal_point of +4 means "7890."
// - A decimal_point of +5 means "78900."
//
-// As above, a decimal_point higher than +1023 means that the overall value is
-// infinity, lower than -1023 means zero.
+// As above, a decimal_point higher than +2047 means that the overall value is
+// infinity, lower than -2047 means zero.
//
// negative is a sign bit. An HPD can distinguish positive and negative zero.
//
@@ -9373,6 +9015,48 @@
}
}
+// wuffs_base__private_implementation__high_prec_dec__assign sets h to
+// represent the number x.
+//
+// Preconditions:
+// - h is non-NULL.
+static void //
+wuffs_base__private_implementation__high_prec_dec__assign(
+ wuffs_base__private_implementation__high_prec_dec* h,
+ uint64_t x,
+ bool negative) {
+ uint32_t n = 0;
+
+ // Set h->digits.
+ if (x > 0) {
+ // Calculate the digits, working right-to-left. After we determine n (how
+ // many digits there are), copy from buf to h->digits.
+ //
+ // UINT64_MAX, 18446744073709551615, is 20 digits long. It can be faster to
+ // copy a constant number of bytes than a variable number (20 instead of
+ // n). Make buf large enough (and start writing to it from the middle) so
+ // that can we always copy 20 bytes: the slice buf[(20-n) .. (40-n)].
+ uint8_t buf[40] = {0};
+ uint8_t* ptr = &buf[20];
+ do {
+ uint64_t remaining = x / 10;
+ x -= remaining * 10;
+ ptr--;
+ *ptr = (uint8_t)x;
+ n++;
+ x = remaining;
+ } while (x > 0);
+ memcpy(h->digits, ptr, 20);
+ }
+
+ // Set h's other fields.
+ h->num_digits = n;
+ h->decimal_point = (int32_t)n;
+ h->negative = negative;
+ h->truncated = false;
+ wuffs_base__private_implementation__high_prec_dec__trim(h);
+}
+
static wuffs_base__status //
wuffs_base__private_implementation__high_prec_dec__parse(
wuffs_base__private_implementation__high_prec_dec* h,
@@ -9748,6 +9432,11 @@
// wuffs_base__private_implementation__high_prec_dec__rounded_integer and
// wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits
// have the same preconditions.
+//
+// wuffs_base__private_implementation__high_prec_dec__lshift keeps the first
+// two preconditions but not the last two. Its shift argument is signed and
+// does not need to be "small": zero is a no-op, positive means left shift and
+// negative means right shift.
static void //
wuffs_base__private_implementation__high_prec_dec__small_lshift(
@@ -9861,6 +9550,254 @@
wuffs_base__private_implementation__high_prec_dec__trim(h);
}
+static void //
+wuffs_base__private_implementation__high_prec_dec__lshift(
+ wuffs_base__private_implementation__high_prec_dec* h,
+ int32_t shift) {
+ if (shift > 0) {
+ while (shift > +WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL) {
+ wuffs_base__private_implementation__high_prec_dec__small_lshift(
+ h, WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL);
+ shift -= WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;
+ }
+ wuffs_base__private_implementation__high_prec_dec__small_lshift(
+ h, ((uint32_t)(+shift)));
+ } else if (shift < 0) {
+ while (shift < -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL) {
+ wuffs_base__private_implementation__high_prec_dec__small_rshift(
+ h, WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL);
+ shift += WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;
+ }
+ wuffs_base__private_implementation__high_prec_dec__small_rshift(
+ h, ((uint32_t)(-shift)));
+ }
+}
+
+// --------
+
+// wuffs_base__private_implementation__high_prec_dec__round_etc rounds h's
+// number. For those functions that take an n argument, rounding produces at
+// most n digits (which is not necessarily at most n decimal places). Negative
+// n values are ignored, as well as any n greater than or equal to h's number
+// of digits. The etc__round_just_enough function implicitly chooses an n to
+// implement WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION.
+//
+// Preconditions:
+// - h is non-NULL.
+// - h->decimal_point is "not extreme".
+//
+// "Not extreme" means within
+// ±WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE.
+
+static void //
+wuffs_base__private_implementation__high_prec_dec__round_down(
+ wuffs_base__private_implementation__high_prec_dec* h,
+ int32_t n) {
+ if ((n < 0) || (h->num_digits <= (uint32_t)n)) {
+ return;
+ }
+ h->num_digits = (uint32_t)(n);
+ wuffs_base__private_implementation__high_prec_dec__trim(h);
+}
+
+static void //
+wuffs_base__private_implementation__high_prec_dec__round_up(
+ wuffs_base__private_implementation__high_prec_dec* h,
+ int32_t n) {
+ if ((n < 0) || (h->num_digits <= (uint32_t)n)) {
+ return;
+ }
+
+ for (n--; n >= 0; n--) {
+ if (h->digits[n] < 9) {
+ h->digits[n]++;
+ h->num_digits = (uint32_t)(n + 1);
+ return;
+ }
+ }
+
+ // The number is all 9s. Change to a single 1 and adjust the decimal point.
+ h->digits[0] = 1;
+ h->num_digits = 1;
+ h->decimal_point++;
+}
+
+static void //
+wuffs_base__private_implementation__high_prec_dec__round_nearest(
+ wuffs_base__private_implementation__high_prec_dec* h,
+ int32_t n) {
+ if ((n < 0) || (h->num_digits <= (uint32_t)n)) {
+ return;
+ }
+ bool up = h->digits[n] >= 5;
+ if ((h->digits[n] == 5) && ((n + 1) == ((int32_t)(h->num_digits)))) {
+ up = h->truncated || //
+ ((n > 0) && ((h->digits[n - 1] & 1) != 0));
+ }
+
+ if (up) {
+ wuffs_base__private_implementation__high_prec_dec__round_up(h, n);
+ } else {
+ wuffs_base__private_implementation__high_prec_dec__round_down(h, n);
+ }
+}
+
+static void //
+wuffs_base__private_implementation__high_prec_dec__round_just_enough(
+ wuffs_base__private_implementation__high_prec_dec* h,
+ int32_t exp2,
+ uint64_t mantissa) {
+ // The magic numbers 52 and 53 in this function are because IEEE 754 double
+ // precision has 52 mantissa bits.
+ //
+ // Let f be the floating point number represented by exp2 and mantissa (and
+ // also the number in h): the number (mantissa * (2 ** (exp2 - 52))).
+ //
+ // If f is zero, we can return early.
+ if (mantissa == 0) {
+ return;
+ }
+
+ // The smallest normal f has an exp2 of -1022 and a mantissa of (1 << 52).
+ // Subnormal numbers have the same exp2 but a smaller mantissa.
+ static const int32_t min_incl_normal_exp2 = -1022;
+ static const uint64_t min_incl_normal_mantissa = 0x0010000000000000ul;
+
+ // Compute lower and upper bounds such that any number between them (possibly
+ // inclusive) will round to f. First, the lower bound. Our number f is:
+ // ((mantissa + 0) * (2 ** ( exp2 - 52)))
+ //
+ // The next lowest floating point number is:
+ // ((mantissa - 1) * (2 ** ( exp2 - 52)))
+ // unless (mantissa - 1) drops the (1 << 52) bit and exp2 is not the
+ // min_incl_normal_exp2. Either way, call it:
+ // ((l_mantissa) * (2 ** (l_exp2 - 52)))
+ //
+ // The lower bound is halfway between them (noting that 52 became 53):
+ // (((2 * l_mantissa) + 1) * (2 ** (l_exp2 - 53)))
+ int32_t l_exp2 = exp2;
+ uint64_t l_mantissa = mantissa - 1;
+ if ((exp2 > min_incl_normal_exp2) && (mantissa <= min_incl_normal_mantissa)) {
+ l_exp2 = exp2 - 1;
+ l_mantissa = (2 * mantissa) - 1;
+ }
+ wuffs_base__private_implementation__high_prec_dec lower;
+ wuffs_base__private_implementation__high_prec_dec__assign(
+ &lower, (2 * l_mantissa) + 1, false);
+ wuffs_base__private_implementation__high_prec_dec__lshift(&lower,
+ l_exp2 - 53);
+
+ // Next, the upper bound. Our number f is:
+ // ((mantissa + 0) * (2 ** (exp2 - 52)))
+ //
+ // The next highest floating point number is:
+ // ((mantissa + 1) * (2 ** (exp2 - 52)))
+ //
+ // The upper bound is halfway between them (noting that 52 became 53):
+ // (((2 * mantissa) + 1) * (2 ** (exp2 - 53)))
+ wuffs_base__private_implementation__high_prec_dec upper;
+ wuffs_base__private_implementation__high_prec_dec__assign(
+ &upper, (2 * mantissa) + 1, false);
+ wuffs_base__private_implementation__high_prec_dec__lshift(&upper, exp2 - 53);
+
+ // The lower and upper bounds are possible outputs only if the original
+ // mantissa is even, so that IEEE round-to-even would round to the original
+ // mantissa and not its neighbors.
+ bool inclusive = (mantissa & 1) == 0;
+
+ // As we walk the digits, we want to know whether rounding up would fall
+ // within the upper bound. This is tracked by upper_delta:
+ // - When -1, the digits of h and upper are the same so far.
+ // - When +0, we saw a difference of 1 between h and upper on a previous
+ // digit and subsequently only 9s for h and 0s for upper. Thus, rounding
+ // up may fall outside of the bound if !inclusive.
+ // - When +1, the difference is greater than 1 and we know that rounding up
+ // falls within the bound.
+ //
+ // This is a state machine with three states. The numerical value for each
+ // state (-1, +0 or +1) isn't important, other than their order.
+ int upper_delta = -1;
+
+ // We can now figure out the shortest number of digits required. Walk the
+ // digits until h has distinguished itself from lower or upper.
+ //
+ // The zi and zd variables are indexes and digits, for z in l (lower), h (the
+ // number) and u (upper).
+ //
+ // The lower, h and upper numbers may have their decimal points at different
+ // places. In this case, upper is the longest, so we iterate ui starting from
+ // 0 and iterate li and hi starting from either 0 or -1.
+ int32_t ui = 0;
+ for (;; ui++) {
+ // Calculate hd, the middle number's digit.
+ int32_t hi = ui - upper.decimal_point + h->decimal_point;
+ if (hi >= ((int32_t)(h->num_digits))) {
+ break;
+ }
+ uint8_t hd = (((uint32_t)hi) < h->num_digits) ? h->digits[hi] : 0;
+
+ // Calculate ld, the lower bound's digit.
+ int32_t li = ui - upper.decimal_point + lower.decimal_point;
+ uint8_t ld = (((uint32_t)li) < lower.num_digits) ? lower.digits[li] : 0;
+
+ // We can round down (truncate) if lower has a different digit than h or if
+ // lower is inclusive and is exactly the result of rounding down (i.e. we
+ // have reached the final digit of lower).
+ bool can_round_down =
+ (ld != hd) || //
+ (inclusive && ((li + 1) == ((int32_t)(lower.num_digits))));
+
+ // Calculate ud, the upper bound's digit, and update upper_delta.
+ uint8_t ud = (((uint32_t)ui) < upper.num_digits) ? upper.digits[ui] : 0;
+ if (upper_delta < 0) {
+ if ((hd + 1) < ud) {
+ // For example:
+ // h = 12345???
+ // upper = 12347???
+ upper_delta = +1;
+ } else if (hd != ud) {
+ // For example:
+ // h = 12345???
+ // upper = 12346???
+ upper_delta = +0;
+ }
+ } else if (upper_delta == 0) {
+ if ((hd != 9) || (ud != 0)) {
+ // For example:
+ // h = 1234598?
+ // upper = 1234600?
+ upper_delta = +1;
+ }
+ }
+
+ // We can round up if upper has a different digit than h and either upper
+ // is inclusive or upper is bigger than the result of rounding up.
+ bool can_round_up =
+ (upper_delta > 0) || //
+ ((upper_delta == 0) && //
+ (inclusive || ((ui + 1) < ((int32_t)(upper.num_digits)))));
+
+ // If we can round either way, round to nearest. If we can round only one
+ // way, do it. If we can't round, continue the loop.
+ if (can_round_down) {
+ if (can_round_up) {
+ wuffs_base__private_implementation__high_prec_dec__round_nearest(
+ h, hi + 1);
+ return;
+ } else {
+ wuffs_base__private_implementation__high_prec_dec__round_down(h,
+ hi + 1);
+ return;
+ }
+ } else {
+ if (can_round_up) {
+ wuffs_base__private_implementation__high_prec_dec__round_up(h, hi + 1);
+ return;
+ }
+ }
+ }
+}
+
// --------
// The wuffs_base__private_implementation__etc_powers_of_10 tables were printed
@@ -10547,11 +10484,737 @@
} while (0);
}
+// --------
+
+static inline size_t //
+wuffs_base__private_implementation__render_inf(wuffs_base__slice_u8 dst,
+ bool neg,
+ uint32_t options) {
+ if (neg) {
+ if (dst.len < 4) {
+ return 0;
+ }
+ wuffs_base__store_u32le__no_bounds_check(dst.ptr, 0x666E492D); // '-Inf'le.
+ return 4;
+ }
+
+ if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {
+ if (dst.len < 4) {
+ return 0;
+ }
+ wuffs_base__store_u32le__no_bounds_check(dst.ptr, 0x666E492B); // '+Inf'le.
+ return 4;
+ }
+
+ if (dst.len < 3) {
+ return 0;
+ }
+ wuffs_base__store_u24le__no_bounds_check(dst.ptr, 0x666E49); // 'Inf'le.
+ return 3;
+}
+
+static inline size_t //
+wuffs_base__private_implementation__render_nan(wuffs_base__slice_u8 dst) {
+ if (dst.len < 3) {
+ return 0;
+ }
+ wuffs_base__store_u24le__no_bounds_check(dst.ptr, 0x4E614E); // 'NaN'le.
+ return 3;
+}
+
+static size_t //
+wuffs_base__private_implementation__high_prec_dec__render_exponent_absent(
+ wuffs_base__slice_u8 dst,
+ wuffs_base__private_implementation__high_prec_dec* h,
+ uint32_t precision,
+ uint32_t options) {
+ size_t n = (h->negative ||
+ (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN))
+ ? 1
+ : 0;
+ if (h->decimal_point <= 0) {
+ n += 1;
+ } else {
+ n += (size_t)(h->decimal_point);
+ }
+ if (precision > 0) {
+ n += precision + 1; // +1 for the '.'.
+ }
+
+ // Don't modify dst if the formatted number won't fit.
+ if (n > dst.len) {
+ return 0;
+ }
+
+ // Align-left or align-right.
+ uint8_t* ptr = (options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)
+ ? &dst.ptr[dst.len - n]
+ : &dst.ptr[0];
+
+ // Leading "±".
+ if (h->negative) {
+ *ptr++ = '-';
+ } else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {
+ *ptr++ = '+';
+ }
+
+ // Integral digits.
+ if (h->decimal_point <= 0) {
+ *ptr++ = '0';
+ } else {
+ uint32_t m =
+ wuffs_base__u32__min(h->num_digits, (uint32_t)(h->decimal_point));
+ uint32_t i = 0;
+ for (; i < m; i++) {
+ *ptr++ = (uint8_t)('0' | h->digits[i]);
+ }
+ for (; i < (uint32_t)(h->decimal_point); i++) {
+ *ptr++ = '0';
+ }
+ }
+
+ // Separator and then fractional digits.
+ if (precision > 0) {
+ *ptr++ =
+ (options & WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)
+ ? ','
+ : '.';
+ uint32_t i = 0;
+ for (; i < precision; i++) {
+ uint32_t j = ((uint32_t)(h->decimal_point)) + i;
+ *ptr++ = (uint8_t)('0' | ((j < h->num_digits) ? h->digits[j] : 0));
+ }
+ }
+
+ return n;
+}
+
+static size_t //
+wuffs_base__private_implementation__high_prec_dec__render_exponent_present(
+ wuffs_base__slice_u8 dst,
+ wuffs_base__private_implementation__high_prec_dec* h,
+ uint32_t precision,
+ uint32_t options) {
+ int32_t exp = 0;
+ if (h->num_digits > 0) {
+ exp = h->decimal_point - 1;
+ }
+ bool negative_exp = exp < 0;
+ if (negative_exp) {
+ exp = -exp;
+ }
+
+ size_t n = (h->negative ||
+ (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN))
+ ? 4
+ : 3; // Mininum 3 bytes: first digit and then "e±".
+ if (precision > 0) {
+ n += precision + 1; // +1 for the '.'.
+ }
+ n += (exp < 100) ? 2 : 3;
+
+ // Don't modify dst if the formatted number won't fit.
+ if (n > dst.len) {
+ return 0;
+ }
+
+ // Align-left or align-right.
+ uint8_t* ptr = (options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)
+ ? &dst.ptr[dst.len - n]
+ : &dst.ptr[0];
+
+ // Leading "±".
+ if (h->negative) {
+ *ptr++ = '-';
+ } else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {
+ *ptr++ = '+';
+ }
+
+ // Integral digit.
+ if (h->num_digits > 0) {
+ *ptr++ = (uint8_t)('0' | h->digits[0]);
+ } else {
+ *ptr++ = '0';
+ }
+
+ // Separator and then fractional digits.
+ if (precision > 0) {
+ *ptr++ =
+ (options & WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)
+ ? ','
+ : '.';
+ uint32_t i = 1;
+ uint32_t j = wuffs_base__u32__min(h->num_digits, precision + 1);
+ for (; i < j; i++) {
+ *ptr++ = (uint8_t)('0' | h->digits[i]);
+ }
+ for (; i <= precision; i++) {
+ *ptr++ = '0';
+ }
+ }
+
+ // Exponent: "e±" and then 2 or 3 digits.
+ *ptr++ = 'e';
+ *ptr++ = negative_exp ? '-' : '+';
+ if (exp < 10) {
+ *ptr++ = '0';
+ *ptr++ = (uint8_t)('0' | exp);
+ } else if (exp < 100) {
+ *ptr++ = (uint8_t)('0' | (exp / 10));
+ *ptr++ = (uint8_t)('0' | (exp % 10));
+ } else {
+ int32_t e = exp / 100;
+ exp -= e * 100;
+ *ptr++ = (uint8_t)('0' | e);
+ *ptr++ = (uint8_t)('0' | (exp / 10));
+ *ptr++ = (uint8_t)('0' | (exp % 10));
+ }
+
+ return n;
+}
+
+WUFFS_BASE__MAYBE_STATIC size_t //
+wuffs_base__render_number_f64(wuffs_base__slice_u8 dst,
+ double x,
+ uint32_t precision,
+ uint32_t options) {
+ // Decompose x (64 bits) into negativity (1 bit), base-2 exponent (11 bits
+ // with a -1023 bias) and mantissa (52 bits).
+ uint64_t bits = wuffs_base__ieee_754_bit_representation__from_f64(x);
+ bool neg = (bits >> 63) != 0;
+ int32_t exp2 = ((int32_t)(bits >> 52)) & 0x7FF;
+ uint64_t man = bits & 0x000FFFFFFFFFFFFFul;
+
+ // Apply the exponent bias and set the implicit top bit of the mantissa,
+ // unless x is subnormal. Also take care of Inf and NaN.
+ if (exp2 == 0x7FF) {
+ if (man != 0) {
+ return wuffs_base__private_implementation__render_nan(dst);
+ }
+ return wuffs_base__private_implementation__render_inf(dst, neg, options);
+ } else if (exp2 == 0) {
+ exp2 = -1022;
+ } else {
+ exp2 -= 1023;
+ man |= 0x0010000000000000ul;
+ }
+
+ // Ensure that precision isn't too large.
+ if (precision > 4095) {
+ precision = 4095;
+ }
+
+ // Convert from the (neg, exp2, man) tuple to an HPD.
+ wuffs_base__private_implementation__high_prec_dec h;
+ wuffs_base__private_implementation__high_prec_dec__assign(&h, man, neg);
+ if (h.num_digits > 0) {
+ wuffs_base__private_implementation__high_prec_dec__lshift(
+ &h, exp2 - 52); // 52 mantissa bits.
+ }
+
+ // Handle the "%e" and "%f" formats.
+ switch (options & (WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT |
+ WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT)) {
+ case WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT: // The "%"f" format.
+ if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {
+ wuffs_base__private_implementation__high_prec_dec__round_just_enough(
+ &h, exp2, man);
+ int32_t p = ((int32_t)(h.num_digits)) - h.decimal_point;
+ precision = ((uint32_t)(wuffs_base__i32__max(0, p)));
+ } else {
+ wuffs_base__private_implementation__high_prec_dec__round_nearest(
+ &h, ((int32_t)precision) + h.decimal_point);
+ }
+ return wuffs_base__private_implementation__high_prec_dec__render_exponent_absent(
+ dst, &h, precision, options);
+
+ case WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT: // The "%e" format.
+ if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {
+ wuffs_base__private_implementation__high_prec_dec__round_just_enough(
+ &h, exp2, man);
+ precision = (h.num_digits > 0) ? (h.num_digits - 1) : 0;
+ } else {
+ wuffs_base__private_implementation__high_prec_dec__round_nearest(
+ &h, ((int32_t)precision) + 1);
+ }
+ return wuffs_base__private_implementation__high_prec_dec__render_exponent_present(
+ dst, &h, precision, options);
+ }
+
+ // We have the "%g" format and so precision means the number of significant
+ // digits, not the number of digits after the decimal separator. Perform
+ // rounding and determine whether to use "%e" or "%f".
+ int32_t e_threshold = 0;
+ if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {
+ wuffs_base__private_implementation__high_prec_dec__round_just_enough(
+ &h, exp2, man);
+ precision = h.num_digits;
+ e_threshold = 6;
+ } else {
+ if (precision == 0) {
+ precision = 1;
+ }
+ wuffs_base__private_implementation__high_prec_dec__round_nearest(
+ &h, ((int32_t)precision));
+ e_threshold = ((int32_t)precision);
+ int32_t nd = ((int32_t)(h.num_digits));
+ if ((e_threshold > nd) && (nd >= h.decimal_point)) {
+ e_threshold = nd;
+ }
+ }
+
+ // Use the "%e" format if the exponent is large.
+ int32_t e = h.decimal_point - 1;
+ if ((e < -4) || (e_threshold <= e)) {
+ uint32_t p = wuffs_base__u32__min(precision, h.num_digits);
+ return wuffs_base__private_implementation__high_prec_dec__render_exponent_present(
+ dst, &h, (p > 0) ? (p - 1) : 0, options);
+ }
+
+ // Use the "%f" format otherwise.
+ int32_t p = ((int32_t)precision);
+ if (p > h.decimal_point) {
+ p = ((int32_t)(h.num_digits));
+ }
+ precision = ((uint32_t)(wuffs_base__i32__max(0, p - h.decimal_point)));
+ return wuffs_base__private_implementation__high_prec_dec__render_exponent_absent(
+ dst, &h, precision, options);
+}
+
#endif // !defined(WUFFS_CONFIG__MODULES) ||
// defined(WUFFS_CONFIG__MODULE__BASE) ||
// defined(WUFFS_CONFIG__MODULE__BASE__F64CONV)
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \
+ defined(WUFFS_CONFIG__MODULE__BASE__I64CONV)
+
+// ---------------- Integer
+
+// wuffs_base__parse_number__foo_digits entries are 0x00 for invalid digits,
+// and (0x80 | v) for valid digits, where v is the 4 bit value.
+
+static const uint8_t wuffs_base__parse_number__decimal_digits[256] = {
+ // 0 1 2 3 4 5 6 7
+ // 8 9 A B C D E F
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x00 ..= 0x07.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x08 ..= 0x0F.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x10 ..= 0x17.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x18 ..= 0x1F.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 ..= 0x27.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x28 ..= 0x2F.
+ 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, // 0x30 ..= 0x37. '0'-'7'.
+ 0x88, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x38 ..= 0x3F. '8'-'9'.
+
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x40 ..= 0x47.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x48 ..= 0x4F.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x50 ..= 0x57.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x58 ..= 0x5F.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x60 ..= 0x67.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x68 ..= 0x6F.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x70 ..= 0x77.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x78 ..= 0x7F.
+
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x80 ..= 0x87.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x88 ..= 0x8F.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x90 ..= 0x97.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x98 ..= 0x9F.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xA0 ..= 0xA7.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xA8 ..= 0xAF.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xB0 ..= 0xB7.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xB8 ..= 0xBF.
+
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xC0 ..= 0xC7.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xC8 ..= 0xCF.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xD0 ..= 0xD7.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xD8 ..= 0xDF.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xE0 ..= 0xE7.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xE8 ..= 0xEF.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xF0 ..= 0xF7.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xF8 ..= 0xFF.
+ // 0 1 2 3 4 5 6 7
+ // 8 9 A B C D E F
+};
+
+static const uint8_t wuffs_base__parse_number__hexadecimal_digits[256] = {
+ // 0 1 2 3 4 5 6 7
+ // 8 9 A B C D E F
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x00 ..= 0x07.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x08 ..= 0x0F.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x10 ..= 0x17.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x18 ..= 0x1F.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 ..= 0x27.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x28 ..= 0x2F.
+ 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, // 0x30 ..= 0x37. '0'-'7'.
+ 0x88, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x38 ..= 0x3F. '8'-'9'.
+
+ 0x00, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x00, // 0x40 ..= 0x47. 'A'-'F'.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x48 ..= 0x4F.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x50 ..= 0x57.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x58 ..= 0x5F.
+ 0x00, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x00, // 0x60 ..= 0x67. 'a'-'f'.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x68 ..= 0x6F.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x70 ..= 0x77.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x78 ..= 0x7F.
+
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x80 ..= 0x87.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x88 ..= 0x8F.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x90 ..= 0x97.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x98 ..= 0x9F.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xA0 ..= 0xA7.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xA8 ..= 0xAF.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xB0 ..= 0xB7.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xB8 ..= 0xBF.
+
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xC0 ..= 0xC7.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xC8 ..= 0xCF.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xD0 ..= 0xD7.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xD8 ..= 0xDF.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xE0 ..= 0xE7.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xE8 ..= 0xEF.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xF0 ..= 0xF7.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xF8 ..= 0xFF.
+ // 0 1 2 3 4 5 6 7
+ // 8 9 A B C D E F
+};
+
+// --------
+
+WUFFS_BASE__MAYBE_STATIC wuffs_base__result_i64 //
+wuffs_base__parse_number_i64(wuffs_base__slice_u8 s) {
+ uint8_t* p = s.ptr;
+ uint8_t* q = s.ptr + s.len;
+
+ for (; (p < q) && (*p == '_'); p++) {
+ }
+
+ bool negative = false;
+ if (p >= q) {
+ goto fail_bad_argument;
+ } else if (*p == '-') {
+ p++;
+ negative = true;
+ } else if (*p == '+') {
+ p++;
+ }
+
+ do {
+ wuffs_base__result_u64 r = wuffs_base__parse_number_u64(
+ wuffs_base__make_slice_u8(p, (size_t)(q - p)));
+ if (r.status.repr != NULL) {
+ wuffs_base__result_i64 ret;
+ ret.status.repr = r.status.repr;
+ ret.value = 0;
+ return ret;
+ } else if (negative) {
+ if (r.value > 0x8000000000000000) {
+ goto fail_out_of_bounds;
+ }
+ wuffs_base__result_i64 ret;
+ ret.status.repr = NULL;
+ ret.value = -(int64_t)(r.value);
+ return ret;
+ } else if (r.value > 0x7FFFFFFFFFFFFFFF) {
+ goto fail_out_of_bounds;
+ } else {
+ wuffs_base__result_i64 ret;
+ ret.status.repr = NULL;
+ ret.value = +(int64_t)(r.value);
+ return ret;
+ }
+ } while (0);
+
+fail_bad_argument:
+ do {
+ wuffs_base__result_i64 ret;
+ ret.status.repr = wuffs_base__error__bad_argument;
+ ret.value = 0;
+ return ret;
+ } while (0);
+
+fail_out_of_bounds:
+ do {
+ wuffs_base__result_i64 ret;
+ ret.status.repr = wuffs_base__error__out_of_bounds;
+ ret.value = 0;
+ return ret;
+ } while (0);
+}
+
+WUFFS_BASE__MAYBE_STATIC wuffs_base__result_u64 //
+wuffs_base__parse_number_u64(wuffs_base__slice_u8 s) {
+ uint8_t* p = s.ptr;
+ uint8_t* q = s.ptr + s.len;
+
+ for (; (p < q) && (*p == '_'); p++) {
+ }
+
+ if (p >= q) {
+ goto fail_bad_argument;
+
+ } else if (*p == '0') {
+ p++;
+ if (p >= q) {
+ goto ok_zero;
+ }
+ if (*p == '_') {
+ p++;
+ for (; p < q; p++) {
+ if (*p != '_') {
+ goto fail_bad_argument;
+ }
+ }
+ goto ok_zero;
+ }
+
+ if ((*p == 'x') || (*p == 'X')) {
+ p++;
+ for (; (p < q) && (*p == '_'); p++) {
+ }
+ if (p < q) {
+ goto hexadecimal;
+ }
+
+ } else if ((*p == 'd') || (*p == 'D')) {
+ p++;
+ for (; (p < q) && (*p == '_'); p++) {
+ }
+ if (p < q) {
+ goto decimal;
+ }
+ }
+
+ goto fail_bad_argument;
+ }
+
+decimal:
+ do {
+ uint64_t v = wuffs_base__parse_number__decimal_digits[*p++];
+ if (v == 0) {
+ goto fail_bad_argument;
+ }
+ v &= 0x0F;
+
+ // UINT64_MAX is 18446744073709551615, which is ((10 * max10) + max1).
+ const uint64_t max10 = 1844674407370955161u;
+ const uint8_t max1 = 5;
+
+ for (; p < q; p++) {
+ if (*p == '_') {
+ continue;
+ }
+ uint8_t digit = wuffs_base__parse_number__decimal_digits[*p];
+ if (digit == 0) {
+ goto fail_bad_argument;
+ }
+ digit &= 0x0F;
+ if ((v > max10) || ((v == max10) && (digit > max1))) {
+ goto fail_out_of_bounds;
+ }
+ v = (10 * v) + ((uint64_t)(digit));
+ }
+
+ wuffs_base__result_u64 ret;
+ ret.status.repr = NULL;
+ ret.value = v;
+ return ret;
+ } while (0);
+
+hexadecimal:
+ do {
+ uint64_t v = wuffs_base__parse_number__hexadecimal_digits[*p++];
+ if (v == 0) {
+ goto fail_bad_argument;
+ }
+ v &= 0x0F;
+
+ for (; p < q; p++) {
+ if (*p == '_') {
+ continue;
+ }
+ uint8_t digit = wuffs_base__parse_number__hexadecimal_digits[*p];
+ if (digit == 0) {
+ goto fail_bad_argument;
+ }
+ digit &= 0x0F;
+ if ((v >> 60) != 0) {
+ goto fail_out_of_bounds;
+ }
+ v = (v << 4) | ((uint64_t)(digit));
+ }
+
+ wuffs_base__result_u64 ret;
+ ret.status.repr = NULL;
+ ret.value = v;
+ return ret;
+ } while (0);
+
+ok_zero:
+ do {
+ wuffs_base__result_u64 ret;
+ ret.status.repr = NULL;
+ ret.value = 0;
+ return ret;
+ } while (0);
+
+fail_bad_argument:
+ do {
+ wuffs_base__result_u64 ret;
+ ret.status.repr = wuffs_base__error__bad_argument;
+ ret.value = 0;
+ return ret;
+ } while (0);
+
+fail_out_of_bounds:
+ do {
+ wuffs_base__result_u64 ret;
+ ret.status.repr = wuffs_base__error__out_of_bounds;
+ ret.value = 0;
+ return ret;
+ } while (0);
+}
+
+// --------
+
+// wuffs_base__render_number__first_hundred contains the decimal encodings of
+// the first one hundred numbers [0 ..= 99].
+static const uint8_t wuffs_base__render_number__first_hundred[200] = {
+ '0', '0', '0', '1', '0', '2', '0', '3', '0', '4', //
+ '0', '5', '0', '6', '0', '7', '0', '8', '0', '9', //
+ '1', '0', '1', '1', '1', '2', '1', '3', '1', '4', //
+ '1', '5', '1', '6', '1', '7', '1', '8', '1', '9', //
+ '2', '0', '2', '1', '2', '2', '2', '3', '2', '4', //
+ '2', '5', '2', '6', '2', '7', '2', '8', '2', '9', //
+ '3', '0', '3', '1', '3', '2', '3', '3', '3', '4', //
+ '3', '5', '3', '6', '3', '7', '3', '8', '3', '9', //
+ '4', '0', '4', '1', '4', '2', '4', '3', '4', '4', //
+ '4', '5', '4', '6', '4', '7', '4', '8', '4', '9', //
+ '5', '0', '5', '1', '5', '2', '5', '3', '5', '4', //
+ '5', '5', '5', '6', '5', '7', '5', '8', '5', '9', //
+ '6', '0', '6', '1', '6', '2', '6', '3', '6', '4', //
+ '6', '5', '6', '6', '6', '7', '6', '8', '6', '9', //
+ '7', '0', '7', '1', '7', '2', '7', '3', '7', '4', //
+ '7', '5', '7', '6', '7', '7', '7', '8', '7', '9', //
+ '8', '0', '8', '1', '8', '2', '8', '3', '8', '4', //
+ '8', '5', '8', '6', '8', '7', '8', '8', '8', '9', //
+ '9', '0', '9', '1', '9', '2', '9', '3', '9', '4', //
+ '9', '5', '9', '6', '9', '7', '9', '8', '9', '9', //
+};
+
+static size_t //
+wuffs_base__private_implementation__render_number_u64(wuffs_base__slice_u8 dst,
+ uint64_t x,
+ uint32_t options,
+ bool neg) {
+ uint8_t buf[WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL];
+ uint8_t* ptr = &buf[0] + sizeof(buf);
+
+ while (x >= 100) {
+ size_t index = (x % 100) * 2;
+ x /= 100;
+ uint8_t s0 = wuffs_base__render_number__first_hundred[index + 0];
+ uint8_t s1 = wuffs_base__render_number__first_hundred[index + 1];
+ ptr -= 2;
+ ptr[0] = s0;
+ ptr[1] = s1;
+ }
+
+ if (x < 10) {
+ ptr -= 1;
+ ptr[0] = (uint8_t)('0' + x);
+ } else {
+ size_t index = x * 2;
+ uint8_t s0 = wuffs_base__render_number__first_hundred[index + 0];
+ uint8_t s1 = wuffs_base__render_number__first_hundred[index + 1];
+ ptr -= 2;
+ ptr[0] = s0;
+ ptr[1] = s1;
+ }
+
+ if (neg) {
+ ptr -= 1;
+ ptr[0] = '-';
+ } else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {
+ ptr -= 1;
+ ptr[0] = '+';
+ }
+
+ size_t n = sizeof(buf) - ((size_t)(ptr - &buf[0]));
+ if (n > dst.len) {
+ return 0;
+ }
+ memcpy(dst.ptr + ((options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)
+ ? (dst.len - n)
+ : 0),
+ ptr, n);
+ return n;
+}
+
+WUFFS_BASE__MAYBE_STATIC size_t //
+wuffs_base__render_number_i64(wuffs_base__slice_u8 dst,
+ int64_t x,
+ uint32_t options) {
+ uint64_t u = (uint64_t)x;
+ bool neg = x < 0;
+ if (neg) {
+ u = 1 + ~u;
+ }
+ return wuffs_base__private_implementation__render_number_u64(dst, u, options,
+ neg);
+}
+
+WUFFS_BASE__MAYBE_STATIC size_t //
+wuffs_base__render_number_u64(wuffs_base__slice_u8 dst,
+ uint64_t x,
+ uint32_t options) {
+ return wuffs_base__private_implementation__render_number_u64(dst, x, options,
+ false);
+}
+
+// ---------------- Hexadecimal
+
+WUFFS_BASE__MAYBE_STATIC size_t //
+wuffs_base__hexadecimal__decode2(wuffs_base__slice_u8 dst,
+ wuffs_base__slice_u8 src) {
+ size_t src_len2 = src.len / 2;
+ size_t len = dst.len < src_len2 ? dst.len : src_len2;
+ uint8_t* d = dst.ptr;
+ uint8_t* s = src.ptr;
+ size_t n = len;
+
+ while (n--) {
+ *d = (uint8_t)((wuffs_base__parse_number__hexadecimal_digits[s[0]] << 4) |
+ (wuffs_base__parse_number__hexadecimal_digits[s[1]] & 0x0F));
+ d += 1;
+ s += 2;
+ }
+
+ return len;
+}
+
+WUFFS_BASE__MAYBE_STATIC size_t //
+wuffs_base__hexadecimal__decode4(wuffs_base__slice_u8 dst,
+ wuffs_base__slice_u8 src) {
+ size_t src_len4 = src.len / 4;
+ size_t len = dst.len < src_len4 ? dst.len : src_len4;
+ uint8_t* d = dst.ptr;
+ uint8_t* s = src.ptr;
+ size_t n = len;
+
+ while (n--) {
+ *d = (uint8_t)((wuffs_base__parse_number__hexadecimal_digits[s[2]] << 4) |
+ (wuffs_base__parse_number__hexadecimal_digits[s[3]] & 0x0F));
+ d += 1;
+ s += 4;
+ }
+
+ return len;
+}
+
+#endif // !defined(WUFFS_CONFIG__MODULES) ||
+ // defined(WUFFS_CONFIG__MODULE__BASE) ||
+ // defined(WUFFS_CONFIG__MODULE__BASE__I64CONV)
+
+#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \
defined(WUFFS_CONFIG__MODULE__BASE__PIXCONV)
// ---------------- Pixel Swizzler
@@ -12063,6 +12726,195 @@
// defined(WUFFS_CONFIG__MODULE__BASE) ||
// defined(WUFFS_CONFIG__MODULE__BASE__PIXCONV)
+#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \
+ defined(WUFFS_CONFIG__MODULE__BASE__UTF8)
+
+// ---------------- Unicode and UTF-8
+
+WUFFS_BASE__MAYBE_STATIC size_t //
+wuffs_base__utf_8__encode(wuffs_base__slice_u8 dst, uint32_t code_point) {
+ if (code_point <= 0x7F) {
+ if (dst.len >= 1) {
+ dst.ptr[0] = (uint8_t)(code_point);
+ return 1;
+ }
+
+ } else if (code_point <= 0x07FF) {
+ if (dst.len >= 2) {
+ dst.ptr[0] = (uint8_t)(0xC0 | ((code_point >> 6)));
+ dst.ptr[1] = (uint8_t)(0x80 | ((code_point >> 0) & 0x3F));
+ return 2;
+ }
+
+ } else if (code_point <= 0xFFFF) {
+ if ((dst.len >= 3) && ((code_point < 0xD800) || (0xDFFF < code_point))) {
+ dst.ptr[0] = (uint8_t)(0xE0 | ((code_point >> 12)));
+ dst.ptr[1] = (uint8_t)(0x80 | ((code_point >> 6) & 0x3F));
+ dst.ptr[2] = (uint8_t)(0x80 | ((code_point >> 0) & 0x3F));
+ return 3;
+ }
+
+ } else if (code_point <= 0x10FFFF) {
+ if (dst.len >= 4) {
+ dst.ptr[0] = (uint8_t)(0xF0 | ((code_point >> 18)));
+ dst.ptr[1] = (uint8_t)(0x80 | ((code_point >> 12) & 0x3F));
+ dst.ptr[2] = (uint8_t)(0x80 | ((code_point >> 6) & 0x3F));
+ dst.ptr[3] = (uint8_t)(0x80 | ((code_point >> 0) & 0x3F));
+ return 4;
+ }
+ }
+
+ return 0;
+}
+
+// wuffs_base__utf_8__byte_length_minus_1 is the byte length (minus 1) of a
+// UTF-8 encoded code point, based on the encoding's initial byte.
+// - 0x00 is 1-byte UTF-8 (ASCII).
+// - 0x01 is the start of 2-byte UTF-8.
+// - 0x02 is the start of 3-byte UTF-8.
+// - 0x03 is the start of 4-byte UTF-8.
+// - 0x40 is a UTF-8 tail byte.
+// - 0x80 is invalid UTF-8.
+//
+// RFC 3629 (UTF-8) gives this grammar for valid UTF-8:
+// UTF8-1 = %x00-7F
+// UTF8-2 = %xC2-DF UTF8-tail
+// UTF8-3 = %xE0 %xA0-BF UTF8-tail / %xE1-EC 2( UTF8-tail ) /
+// %xED %x80-9F UTF8-tail / %xEE-EF 2( UTF8-tail )
+// UTF8-4 = %xF0 %x90-BF 2( UTF8-tail ) / %xF1-F3 3( UTF8-tail ) /
+// %xF4 %x80-8F 2( UTF8-tail )
+// UTF8-tail = %x80-BF
+static const uint8_t wuffs_base__utf_8__byte_length_minus_1[256] = {
+ // 0 1 2 3 4 5 6 7
+ // 8 9 A B C D E F
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x00 ..= 0x07.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x08 ..= 0x0F.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x10 ..= 0x17.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x18 ..= 0x1F.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 ..= 0x27.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x28 ..= 0x2F.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x30 ..= 0x37.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x38 ..= 0x3F.
+
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x40 ..= 0x47.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x48 ..= 0x4F.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x50 ..= 0x57.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x58 ..= 0x5F.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x60 ..= 0x67.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x68 ..= 0x6F.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x70 ..= 0x77.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x78 ..= 0x7F.
+
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0x80 ..= 0x87.
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0x88 ..= 0x8F.
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0x90 ..= 0x97.
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0x98 ..= 0x9F.
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0xA0 ..= 0xA7.
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0xA8 ..= 0xAF.
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0xB0 ..= 0xB7.
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0xB8 ..= 0xBF.
+
+ 0x80, 0x80, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, // 0xC0 ..= 0xC7.
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, // 0xC8 ..= 0xCF.
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, // 0xD0 ..= 0xD7.
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, // 0xD8 ..= 0xDF.
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xE0 ..= 0xE7.
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xE8 ..= 0xEF.
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x80, 0x80, 0x80, // 0xF0 ..= 0xF7.
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xF8 ..= 0xFF.
+ // 0 1 2 3 4 5 6 7
+ // 8 9 A B C D E F
+};
+
+WUFFS_BASE__MAYBE_STATIC wuffs_base__utf_8__next__output //
+wuffs_base__utf_8__next(wuffs_base__slice_u8 s) {
+ if (s.len == 0) {
+ return wuffs_base__make_utf_8__next__output(0, 0);
+ }
+ uint32_t c = s.ptr[0];
+ switch (wuffs_base__utf_8__byte_length_minus_1[c & 0xFF]) {
+ case 0:
+ return wuffs_base__make_utf_8__next__output(c, 1);
+
+ case 1:
+ if (s.len < 2) {
+ break;
+ }
+ c = wuffs_base__load_u16le__no_bounds_check(s.ptr);
+ if ((c & 0xC000) != 0x8000) {
+ break;
+ }
+ c = (0x0007C0 & (c << 6)) | (0x00003F & (c >> 8));
+ return wuffs_base__make_utf_8__next__output(c, 2);
+
+ case 2:
+ if (s.len < 3) {
+ break;
+ }
+ c = wuffs_base__load_u24le__no_bounds_check(s.ptr);
+ if ((c & 0xC0C000) != 0x808000) {
+ break;
+ }
+ c = (0x00F000 & (c << 12)) | (0x000FC0 & (c >> 2)) |
+ (0x00003F & (c >> 16));
+ if ((c <= 0x07FF) || ((0xD800 <= c) && (c <= 0xDFFF))) {
+ break;
+ }
+ return wuffs_base__make_utf_8__next__output(c, 3);
+
+ case 3:
+ if (s.len < 4) {
+ break;
+ }
+ c = wuffs_base__load_u32le__no_bounds_check(s.ptr);
+ if ((c & 0xC0C0C000) != 0x80808000) {
+ break;
+ }
+ c = (0x1C0000 & (c << 18)) | (0x03F000 & (c << 4)) |
+ (0x000FC0 & (c >> 10)) | (0x00003F & (c >> 24));
+ if ((c <= 0xFFFF) || (0x110000 <= c)) {
+ break;
+ }
+ return wuffs_base__make_utf_8__next__output(c, 4);
+ }
+
+ return wuffs_base__make_utf_8__next__output(
+ WUFFS_BASE__UNICODE_REPLACEMENT_CHARACTER, 1);
+}
+
+WUFFS_BASE__MAYBE_STATIC size_t //
+wuffs_base__utf_8__longest_valid_prefix(wuffs_base__slice_u8 s) {
+ // TODO: possibly optimize the all-ASCII case (4 or 8 bytes at a time).
+ //
+ // TODO: possibly optimize this by manually inlining the
+ // wuffs_base__utf_8__next calls.
+ size_t original_len = s.len;
+ while (s.len > 0) {
+ wuffs_base__utf_8__next__output o = wuffs_base__utf_8__next(s);
+ if ((o.code_point > 0x7F) && (o.byte_length == 1)) {
+ break;
+ }
+ s.ptr += o.byte_length;
+ s.len -= o.byte_length;
+ }
+ return original_len - s.len;
+}
+
+WUFFS_BASE__MAYBE_STATIC size_t //
+wuffs_base__ascii__longest_valid_prefix(wuffs_base__slice_u8 s) {
+ // TODO: possibly optimize this by checking 4 or 8 bytes at a time.
+ uint8_t* original_ptr = s.ptr;
+ uint8_t* p = s.ptr;
+ uint8_t* q = s.ptr + s.len;
+ for (; (p != q) && ((*p & 0x80) == 0); p++) {
+ }
+ return (size_t)(p - original_ptr);
+}
+
+#endif // !defined(WUFFS_CONFIG__MODULES) ||
+ // defined(WUFFS_CONFIG__MODULE__BASE) ||
+ // defined(WUFFS_CONFIG__MODULE__BASE__UTF8)
+
#ifdef __cplusplus
} // extern "C"
#endif
@@ -12095,7 +12947,7 @@
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);
}
@@ -12107,7 +12959,7 @@
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__)
@@ -12121,9 +12973,9 @@
#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));
}
@@ -12252,9 +13104,9 @@
// ---------------- Status Codes Implementations
-const char* wuffs_bmp__error__bad_header = "#bmp: bad header";
-const char* wuffs_bmp__error__unsupported_bmp_file = "#bmp: unsupported BMP file";
-const char* wuffs_bmp__note__internal_note_short_read = "@bmp: internal note: short read";
+const char wuffs_bmp__error__bad_header[] = "#bmp: bad header";
+const char wuffs_bmp__error__unsupported_bmp_file[] = "#bmp: unsupported BMP file";
+const char wuffs_bmp__note__internal_note_short_read[] = "@bmp: internal note: short read";
// ---------------- Private Consts
@@ -12316,7 +13168,7 @@
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);
}
@@ -12328,7 +13180,7 @@
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__)
@@ -12342,9 +13194,9 @@
#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));
}
@@ -14114,7 +14966,7 @@
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);
}
@@ -14126,7 +14978,7 @@
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__)
@@ -14140,9 +14992,9 @@
#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));
}
@@ -14296,23 +15148,23 @@
// ---------------- Status Codes Implementations
-const char* wuffs_deflate__error__bad_huffman_code_over_subscribed = "#deflate: bad Huffman code (over-subscribed)";
-const char* wuffs_deflate__error__bad_huffman_code_under_subscribed = "#deflate: bad Huffman code (under-subscribed)";
-const char* wuffs_deflate__error__bad_huffman_code_length_count = "#deflate: bad Huffman code length count";
-const char* wuffs_deflate__error__bad_huffman_code_length_repetition = "#deflate: bad Huffman code length repetition";
-const char* wuffs_deflate__error__bad_huffman_code = "#deflate: bad Huffman code";
-const char* wuffs_deflate__error__bad_huffman_minimum_code_length = "#deflate: bad Huffman minimum code length";
-const char* wuffs_deflate__error__bad_block = "#deflate: bad block";
-const char* wuffs_deflate__error__bad_distance = "#deflate: bad distance";
-const char* wuffs_deflate__error__bad_distance_code_count = "#deflate: bad distance code count";
-const char* wuffs_deflate__error__bad_literal_length_code_count = "#deflate: bad literal/length code count";
-const char* wuffs_deflate__error__inconsistent_stored_block_length = "#deflate: inconsistent stored block length";
-const char* wuffs_deflate__error__missing_end_of_block_code = "#deflate: missing end-of-block code";
-const char* wuffs_deflate__error__no_huffman_codes = "#deflate: no Huffman codes";
-const char* wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state = "#deflate: internal error: inconsistent Huffman decoder state";
-const char* wuffs_deflate__error__internal_error_inconsistent_i_o = "#deflate: internal error: inconsistent I/O";
-const char* wuffs_deflate__error__internal_error_inconsistent_distance = "#deflate: internal error: inconsistent distance";
-const char* wuffs_deflate__error__internal_error_inconsistent_n_bits = "#deflate: internal error: inconsistent n_bits";
+const char wuffs_deflate__error__bad_huffman_code_over_subscribed[] = "#deflate: bad Huffman code (over-subscribed)";
+const char wuffs_deflate__error__bad_huffman_code_under_subscribed[] = "#deflate: bad Huffman code (under-subscribed)";
+const char wuffs_deflate__error__bad_huffman_code_length_count[] = "#deflate: bad Huffman code length count";
+const char wuffs_deflate__error__bad_huffman_code_length_repetition[] = "#deflate: bad Huffman code length repetition";
+const char wuffs_deflate__error__bad_huffman_code[] = "#deflate: bad Huffman code";
+const char wuffs_deflate__error__bad_huffman_minimum_code_length[] = "#deflate: bad Huffman minimum code length";
+const char wuffs_deflate__error__bad_block[] = "#deflate: bad block";
+const char wuffs_deflate__error__bad_distance[] = "#deflate: bad distance";
+const char wuffs_deflate__error__bad_distance_code_count[] = "#deflate: bad distance code count";
+const char wuffs_deflate__error__bad_literal_length_code_count[] = "#deflate: bad literal/length code count";
+const char wuffs_deflate__error__inconsistent_stored_block_length[] = "#deflate: inconsistent stored block length";
+const char wuffs_deflate__error__missing_end_of_block_code[] = "#deflate: missing end-of-block code";
+const char wuffs_deflate__error__no_huffman_codes[] = "#deflate: no Huffman codes";
+const char wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state[] = "#deflate: internal error: inconsistent Huffman decoder state";
+const char wuffs_deflate__error__internal_error_inconsistent_i_o[] = "#deflate: internal error: inconsistent I/O";
+const char wuffs_deflate__error__internal_error_inconsistent_distance[] = "#deflate: internal error: inconsistent distance";
+const char wuffs_deflate__error__internal_error_inconsistent_n_bits[] = "#deflate: internal error: inconsistent n_bits";
// ---------------- Private Consts
@@ -14445,7 +15297,7 @@
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);
}
@@ -14457,7 +15309,7 @@
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__)
@@ -14471,9 +15323,9 @@
#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));
}
@@ -16123,8 +16975,8 @@
// ---------------- Status Codes Implementations
-const char* wuffs_lzw__error__bad_code = "#lzw: bad code";
-const char* wuffs_lzw__error__internal_error_inconsistent_i_o = "#lzw: internal error: inconsistent I/O";
+const char wuffs_lzw__error__bad_code[] = "#lzw: bad code";
+const char wuffs_lzw__error__internal_error_inconsistent_i_o[] = "#lzw: internal error: inconsistent I/O";
// ---------------- Private Consts
@@ -16163,7 +17015,7 @@
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);
}
@@ -16175,7 +17027,7 @@
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__)
@@ -16189,9 +17041,9 @@
#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));
}
@@ -16649,13 +17501,13 @@
// ---------------- Status Codes Implementations
-const char* wuffs_gif__error__bad_extension_label = "#gif: bad extension label";
-const char* wuffs_gif__error__bad_frame_size = "#gif: bad frame size";
-const char* wuffs_gif__error__bad_graphic_control = "#gif: bad graphic control";
-const char* wuffs_gif__error__bad_header = "#gif: bad header";
-const char* wuffs_gif__error__bad_literal_width = "#gif: bad literal width";
-const char* wuffs_gif__error__bad_palette = "#gif: bad palette";
-const char* wuffs_gif__error__internal_error_inconsistent_ri_wi = "#gif: internal error: inconsistent ri/wi";
+const char wuffs_gif__error__bad_extension_label[] = "#gif: bad extension label";
+const char wuffs_gif__error__bad_frame_size[] = "#gif: bad frame size";
+const char wuffs_gif__error__bad_graphic_control[] = "#gif: bad graphic control";
+const char wuffs_gif__error__bad_header[] = "#gif: bad header";
+const char wuffs_gif__error__bad_literal_width[] = "#gif: bad literal width";
+const char wuffs_gif__error__bad_palette[] = "#gif: bad palette";
+const char wuffs_gif__error__internal_error_inconsistent_ri_wi[] = "#gif: internal error: inconsistent ri/wi";
// ---------------- Private Consts
@@ -16901,7 +17753,7 @@
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);
}
@@ -16913,7 +17765,7 @@
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__)
@@ -16927,9 +17779,9 @@
#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));
}
@@ -16968,7 +17820,7 @@
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);
}
@@ -16980,7 +17832,7 @@
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__)
@@ -16994,9 +17846,9 @@
#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));
}
@@ -17004,7 +17856,7 @@
{
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;
}
@@ -21129,10 +21981,10 @@
// ---------------- Status Codes Implementations
-const char* wuffs_gzip__error__bad_checksum = "#gzip: bad checksum";
-const char* wuffs_gzip__error__bad_compression_method = "#gzip: bad compression method";
-const char* wuffs_gzip__error__bad_encoding_flags = "#gzip: bad encoding flags";
-const char* wuffs_gzip__error__bad_header = "#gzip: bad header";
+const char wuffs_gzip__error__bad_checksum[] = "#gzip: bad checksum";
+const char wuffs_gzip__error__bad_compression_method[] = "#gzip: bad compression method";
+const char wuffs_gzip__error__bad_encoding_flags[] = "#gzip: bad encoding flags";
+const char wuffs_gzip__error__bad_header[] = "#gzip: bad header";
// ---------------- Private Consts
@@ -21161,7 +22013,7 @@
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);
}
@@ -21173,7 +22025,7 @@
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__)
@@ -21187,9 +22039,9 @@
#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));
}
@@ -21197,14 +22049,14 @@
{
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;
}
@@ -21629,13 +22481,13 @@
// ---------------- Status Codes Implementations
-const char* wuffs_json__error__bad_c0_control_code = "#json: bad C0 control code";
-const char* wuffs_json__error__bad_utf_8 = "#json: bad UTF-8";
-const char* wuffs_json__error__bad_backslash_escape = "#json: bad backslash-escape";
-const char* wuffs_json__error__bad_input = "#json: bad input";
-const char* wuffs_json__error__unsupported_number_length = "#json: unsupported number length";
-const char* wuffs_json__error__unsupported_recursion_depth = "#json: unsupported recursion depth";
-const char* wuffs_json__error__internal_error_inconsistent_i_o = "#json: internal error: inconsistent I/O";
+const char wuffs_json__error__bad_c0_control_code[] = "#json: bad C0 control code";
+const char wuffs_json__error__bad_utf_8[] = "#json: bad UTF-8";
+const char wuffs_json__error__bad_backslash_escape[] = "#json: bad backslash-escape";
+const char wuffs_json__error__bad_input[] = "#json: bad input";
+const char wuffs_json__error__unsupported_number_length[] = "#json: unsupported number length";
+const char wuffs_json__error__unsupported_recursion_depth[] = "#json: unsupported recursion depth";
+const char wuffs_json__error__internal_error_inconsistent_i_o[] = "#json: internal error: inconsistent I/O";
// ---------------- Private Consts
@@ -21937,7 +22789,7 @@
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);
}
@@ -21949,7 +22801,7 @@
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__)
@@ -21963,9 +22815,9 @@
#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));
}
@@ -23827,7 +24679,7 @@
// ---------------- Status Codes Implementations
-const char* wuffs_wbmp__error__bad_header = "#wbmp: bad header";
+const char wuffs_wbmp__error__bad_header[] = "#wbmp: bad header";
// ---------------- Private Consts
@@ -23883,7 +24735,7 @@
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);
}
@@ -23895,7 +24747,7 @@
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__)
@@ -23909,9 +24761,9 @@
#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));
}
@@ -24623,12 +25475,12 @@
// ---------------- Status Codes Implementations
-const char* wuffs_zlib__note__dictionary_required = "@zlib: dictionary required";
-const char* wuffs_zlib__error__bad_checksum = "#zlib: bad checksum";
-const char* wuffs_zlib__error__bad_compression_method = "#zlib: bad compression method";
-const char* wuffs_zlib__error__bad_compression_window_size = "#zlib: bad compression window size";
-const char* wuffs_zlib__error__bad_parity_check = "#zlib: bad parity check";
-const char* wuffs_zlib__error__incorrect_dictionary = "#zlib: incorrect dictionary";
+const char wuffs_zlib__note__dictionary_required[] = "@zlib: dictionary required";
+const char wuffs_zlib__error__bad_checksum[] = "#zlib: bad checksum";
+const char wuffs_zlib__error__bad_compression_method[] = "#zlib: bad compression method";
+const char wuffs_zlib__error__bad_compression_window_size[] = "#zlib: bad compression window size";
+const char wuffs_zlib__error__bad_parity_check[] = "#zlib: bad parity check";
+const char wuffs_zlib__error__incorrect_dictionary[] = "#zlib: incorrect dictionary";
// ---------------- Private Consts
@@ -24657,7 +25509,7 @@
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);
}
@@ -24669,7 +25521,7 @@
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__)
@@ -24683,9 +25535,9 @@
#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));
}
@@ -24693,21 +25545,21 @@
{
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;
}
