wuffs gen -version=0.2.0-alpha.33
diff --git a/release/c/wuffs-v0.2.c b/release/c/wuffs-v0.2.c
index dd7ba15..a7b10b3 100644
--- a/release/c/wuffs-v0.2.c
+++ b/release/c/wuffs-v0.2.c
@@ -54,15 +54,15 @@
// each major.minor branch, the commit count should increase monotonically.
//
// WUFFS_VERSION was overridden by "wuffs gen -version" based on revision
-// c5538078e4aa401af580bd3e5caf6072c56a779c committed on 2019-02-16.
+// d78101625ec2c4acba5458d370739e780a1170dd committed on 2019-02-24.
#define WUFFS_VERSION ((uint64_t)0x0000000000020000)
#define WUFFS_VERSION_MAJOR ((uint64_t)0x00000000)
#define WUFFS_VERSION_MINOR ((uint64_t)0x0002)
#define WUFFS_VERSION_PATCH ((uint64_t)0x0000)
-#define WUFFS_VERSION_PRE_RELEASE_LABEL "alpha.32"
-#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 1625
-#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20190216
-#define WUFFS_VERSION_STRING "0.2.0-alpha.32+1625.20190216"
+#define WUFFS_VERSION_PRE_RELEASE_LABEL "alpha.33"
+#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 1640
+#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20190224
+#define WUFFS_VERSION_STRING "0.2.0-alpha.33+1640.20190224"
// Define WUFFS_CONFIG__STATIC_FUNCTIONS to make all of Wuffs' functions have
// static storage. The motivation is discussed in the "ALLOW STATIC
@@ -186,15 +186,17 @@
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__not_enough_data;
+extern const char* wuffs_base__error__too_much_data;
static inline bool //
wuffs_base__status__is_complete(wuffs_base__status z) {
- return (z == NULL) || ((*z != '$') && (*z != '?'));
+ return (z == NULL) || ((*z != '$') && (*z != '#'));
}
static inline bool //
wuffs_base__status__is_error(wuffs_base__status z) {
- return z && (*z == '?');
+ return z && (*z == '#');
}
static inline bool //
@@ -209,7 +211,7 @@
static inline bool //
wuffs_base__status__is_warning(wuffs_base__status z) {
- return z && (*z != '$') && (*z != '?');
+ return z && (*z != '$') && (*z != '#');
}
// --------
@@ -2877,6 +2879,7 @@
uint32_t f_bits;
uint32_t f_n_bits;
uint32_t f_history_index;
+ uint32_t f_n_huffs_bits[2];
bool f_end_of_block;
uint32_t p_decode_io_writer[1];
@@ -2888,7 +2891,6 @@
struct {
uint32_t f_huffs[2][1024];
- uint32_t f_n_huffs_bits[2];
uint8_t f_history[32768];
uint8_t f_code_lengths[320];
@@ -3094,6 +3096,7 @@
uint32_t f_output_ri;
uint32_t f_output_wi;
uint32_t f_read_from_return_value;
+ uint16_t f_prefixes[4096];
uint32_t p_decode_io_writer[1];
uint32_t p_write_to[1];
@@ -3101,7 +3104,6 @@
struct {
uint8_t f_suffixes[4096][8];
- uint16_t f_prefixes[4096];
uint16_t f_lm1s[4096];
uint8_t f_output[8199];
@@ -3195,8 +3197,6 @@
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__not_enough_pixel_data;
-extern const char* wuffs_gif__error__too_much_pixel_data;
// ---------------- Public Consts
@@ -4788,25 +4788,27 @@
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_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";
+ "#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_workbuf_length = "?base: bad workbuf length";
-const char* wuffs_base__error__bad_wuffs_version = "?base: bad wuffs version";
+ "#base: bad sizeof receiver";
+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";
+ "#base: cannot return a suspension";
const char* wuffs_base__error__disabled_by_previous_error =
- "?base: 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";
+ "#base: initialize falsely claimed already zeroed";
const char* wuffs_base__error__initialize_not_called =
- "?base: initialize not called";
+ "#base: initialize not called";
const char* wuffs_base__error__interleaved_coroutine_calls =
- "?base: interleaved coroutine calls";
+ "#base: interleaved coroutine calls";
+const char* wuffs_base__error__not_enough_data = "#base: not enough data";
+const char* wuffs_base__error__too_much_data = "#base: too much data";
// ---------------- Images
@@ -4999,12 +5001,16 @@
if (self->private_impl.magic != 0) {
return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
}
- } else if ((initialize_flags &
- WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) != 0) {
- memset(&(self->private_impl), 0, sizeof(self->private_impl));
} else {
- memset(self, 0, sizeof(*self));
- initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+ void* p = &(self->private_impl);
+ size_t n = sizeof(self->private_impl);
+ if ((initialize_flags &
+ WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
+ p = self;
+ n = sizeof(*self);
+ initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+ }
+ memset(p, 0, n);
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
@@ -6006,12 +6012,16 @@
if (self->private_impl.magic != 0) {
return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
}
- } else if ((initialize_flags &
- WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) != 0) {
- memset(&(self->private_impl), 0, sizeof(self->private_impl));
} else {
- memset(self, 0, sizeof(*self));
- initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+ void* p = &(self->private_impl);
+ size_t n = sizeof(self->private_impl);
+ if ((initialize_flags &
+ WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
+ p = self;
+ n = sizeof(*self);
+ initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+ }
+ memset(p, 0, n);
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
@@ -6141,38 +6151,38 @@
// ---------------- Status Codes Implementations
const char* wuffs_deflate__error__bad_huffman_code_over_subscribed =
- "?deflate: 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)";
+ "#deflate: bad Huffman code (under-subscribed)";
const char* wuffs_deflate__error__bad_huffman_code_length_count =
- "?deflate: 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";
+ "#deflate: bad Huffman code length repetition";
const char* wuffs_deflate__error__bad_huffman_code =
- "?deflate: 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";
+ "#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";
+ "#deflate: bad distance code count";
const char* wuffs_deflate__error__bad_literal_length_code_count =
- "?deflate: 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";
+ "#deflate: inconsistent stored block length";
const char* wuffs_deflate__error__missing_end_of_block_code =
- "?deflate: missing end-of-block code";
+ "#deflate: missing end-of-block code";
const char* wuffs_deflate__error__no_huffman_codes =
- "?deflate: 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";
+ "#deflate: internal error: inconsistent Huffman decoder state";
const char* wuffs_deflate__error__internal_error_inconsistent_i_o =
- "?deflate: 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";
+ "#deflate: internal error: inconsistent distance";
const char* wuffs_deflate__error__internal_error_inconsistent_n_bits =
- "?deflate: internal error: inconsistent n_bits";
+ "#deflate: internal error: inconsistent n_bits";
// ---------------- Private Consts
@@ -6292,12 +6302,16 @@
if (self->private_impl.magic != 0) {
return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
}
- } else if ((initialize_flags &
- WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) != 0) {
- memset(&(self->private_impl), 0, sizeof(self->private_impl));
} else {
- memset(self, 0, sizeof(*self));
- initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+ void* p = &(self->private_impl);
+ size_t n = sizeof(self->private_impl);
+ if ((initialize_flags &
+ WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
+ p = self;
+ n = sizeof(*self);
+ initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+ }
+ memset(p, 0, n);
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
@@ -6326,7 +6340,8 @@
if (!self) {
return ((wuffs_base__range_ii_u64){0});
}
- if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
+ if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
+ (self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return ((wuffs_base__range_ii_u64){0});
}
@@ -6931,7 +6946,7 @@
status = v_status;
goto exit;
}
- v_mask = ((((uint32_t)(1)) << self->private_data.f_n_huffs_bits[0]) - 1);
+ v_mask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
v_i = 0;
label_0_continue:;
while (v_i < (v_n_lit + v_n_dist)) {
@@ -6976,7 +6991,7 @@
status = wuffs_deflate__error__bad_huffman_code_length_repetition;
goto exit;
}
- v_rep_symbol = self->private_data.f_code_lengths[(v_i - 1)];
+ v_rep_symbol = (self->private_data.f_code_lengths[(v_i - 1)] & 15);
v_rep_count = 3;
} else if (v_table_entry == 17) {
v_n_extra_bits = 3;
@@ -7105,10 +7120,10 @@
v_i = a_n_codes0;
while (v_i < a_n_codes1) {
- if (v_counts[self->private_data.f_code_lengths[v_i]] >= 320) {
+ if (v_counts[(self->private_data.f_code_lengths[v_i] & 15)] >= 320) {
return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
}
- v_counts[self->private_data.f_code_lengths[v_i]] += 1;
+ v_counts[(self->private_data.f_code_lengths[v_i] & 15)] += 1;
v_i += 1;
}
if ((((uint32_t)(v_counts[0])) + a_n_codes0) == a_n_codes1) {
@@ -7149,12 +7164,12 @@
return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
}
if (self->private_data.f_code_lengths[v_i] != 0) {
- if (v_offsets[self->private_data.f_code_lengths[v_i]] >= 320) {
+ if (v_offsets[(self->private_data.f_code_lengths[v_i] & 15)] >= 320) {
return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
}
- v_symbols[v_offsets[self->private_data.f_code_lengths[v_i]]] =
+ v_symbols[v_offsets[(self->private_data.f_code_lengths[v_i] & 15)]] =
((uint16_t)((v_i - a_n_codes0)));
- v_offsets[self->private_data.f_code_lengths[v_i]] += 1;
+ v_offsets[(self->private_data.f_code_lengths[v_i] & 15)] += 1;
}
v_i += 1;
}
@@ -7181,9 +7196,9 @@
}
label_1_break:;
if (v_max_cl <= 9) {
- self->private_data.f_n_huffs_bits[a_which] = v_max_cl;
+ self->private_impl.f_n_huffs_bits[a_which] = v_max_cl;
} else {
- self->private_data.f_n_huffs_bits[a_which] = 9;
+ self->private_impl.f_n_huffs_bits[a_which] = 9;
}
v_i = 0;
if ((v_n_symbols != ((uint32_t)(v_offsets[v_max_cl]))) ||
@@ -7197,8 +7212,9 @@
if (v_max_cl < 9) {
v_initial_high_bits = (((uint32_t)(1)) << v_max_cl);
}
- v_prev_cl = ((uint32_t)(self->private_data.f_code_lengths[(
- a_n_codes0 + ((uint32_t)(v_symbols[0])))]));
+ v_prev_cl = ((uint32_t)((self->private_data.f_code_lengths[(
+ a_n_codes0 + ((uint32_t)(v_symbols[0])))] &
+ 15)));
v_prev_redirect_key = 4294967295;
v_top = 0;
v_next_top = 512;
@@ -7209,8 +7225,9 @@
if ((a_n_codes0 + ((uint32_t)(v_symbols[v_i]))) >= 320) {
return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
}
- v_cl = ((uint32_t)(self->private_data.f_code_lengths[(
- a_n_codes0 + ((uint32_t)(v_symbols[v_i])))]));
+ v_cl = ((uint32_t)((self->private_data.f_code_lengths[(
+ a_n_codes0 + ((uint32_t)(v_symbols[v_i])))] &
+ 15)));
if (v_cl > v_prev_cl) {
v_code <<= (v_cl - v_prev_cl);
if (v_code >= 32768) {
@@ -7363,8 +7380,8 @@
}
v_bits = self->private_impl.f_bits;
v_n_bits = self->private_impl.f_n_bits;
- v_lmask = ((((uint32_t)(1)) << self->private_data.f_n_huffs_bits[0]) - 1);
- v_dmask = ((((uint32_t)(1)) << self->private_data.f_n_huffs_bits[1]) - 1);
+ v_lmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
+ v_dmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[1]) - 1);
label_0_continue:;
while ((((uint64_t)(io1_a_dst - iop_a_dst)) >= 258) &&
(((uint64_t)(io1_a_src - iop_a_src)) >= 12)) {
@@ -7700,8 +7717,8 @@
}
v_bits = self->private_impl.f_bits;
v_n_bits = self->private_impl.f_n_bits;
- v_lmask = ((((uint32_t)(1)) << self->private_data.f_n_huffs_bits[0]) - 1);
- v_dmask = ((((uint32_t)(1)) << self->private_data.f_n_huffs_bits[1]) - 1);
+ v_lmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
+ v_dmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[1]) - 1);
label_0_continue:;
while (!(self->private_impl.p_decode_huffman_slow[0] != 0)) {
while (true) {
@@ -8043,9 +8060,9 @@
// ---------------- Status Codes Implementations
-const char* wuffs_lzw__error__bad_code = "?lzw: bad code";
+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";
+ "#lzw: internal error: inconsistent I/O";
// ---------------- Private Consts
@@ -8083,12 +8100,16 @@
if (self->private_impl.magic != 0) {
return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
}
- } else if ((initialize_flags &
- WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) != 0) {
- memset(&(self->private_impl), 0, sizeof(self->private_impl));
} else {
- memset(self, 0, sizeof(*self));
- initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+ void* p = &(self->private_impl);
+ size_t n = sizeof(self->private_impl);
+ if ((initialize_flags &
+ WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
+ p = self;
+ n = sizeof(*self);
+ initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+ }
+ memset(p, 0, n);
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
@@ -8136,7 +8157,8 @@
if (!self) {
return ((wuffs_base__range_ii_u64){0});
}
- if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
+ if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
+ (self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return ((wuffs_base__range_ii_u64){0});
}
@@ -8325,15 +8347,15 @@
v_lm1_a = ((self->private_data.f_lm1s[v_prev_code] + 1) & 4095);
self->private_data.f_lm1s[v_save_code] = v_lm1_a;
if ((v_lm1_a % 8) != 0) {
- self->private_data.f_prefixes[v_save_code] =
- self->private_data.f_prefixes[v_prev_code];
+ self->private_impl.f_prefixes[v_save_code] =
+ self->private_impl.f_prefixes[v_prev_code];
memcpy(self->private_data.f_suffixes[v_save_code],
self->private_data.f_suffixes[v_prev_code],
sizeof(self->private_data.f_suffixes[v_save_code]));
self->private_data.f_suffixes[v_save_code][(v_lm1_a % 8)] =
((uint8_t)(v_code));
} else {
- self->private_data.f_prefixes[v_save_code] =
+ self->private_impl.f_prefixes[v_save_code] =
((uint16_t)(v_prev_code));
self->private_data.f_suffixes[v_save_code][0] = ((uint8_t)(v_code));
}
@@ -8371,7 +8393,7 @@
}
v_steps -= 1;
v_o = ((v_o - 8) & 8191);
- v_c = ((uint32_t)(self->private_data.f_prefixes[v_c]));
+ v_c = ((uint32_t)(self->private_impl.f_prefixes[v_c]));
}
label_1_break:;
v_first_byte = self->private_data.f_suffixes[v_c][0];
@@ -8383,15 +8405,15 @@
v_lm1_b = ((self->private_data.f_lm1s[v_prev_code] + 1) & 4095);
self->private_data.f_lm1s[v_save_code] = v_lm1_b;
if ((v_lm1_b % 8) != 0) {
- self->private_data.f_prefixes[v_save_code] =
- self->private_data.f_prefixes[v_prev_code];
+ self->private_impl.f_prefixes[v_save_code] =
+ self->private_impl.f_prefixes[v_prev_code];
memcpy(self->private_data.f_suffixes[v_save_code],
self->private_data.f_suffixes[v_prev_code],
sizeof(self->private_data.f_suffixes[v_save_code]));
self->private_data.f_suffixes[v_save_code][(v_lm1_b % 8)] =
v_first_byte;
} else {
- self->private_data.f_prefixes[v_save_code] =
+ self->private_impl.f_prefixes[v_save_code] =
((uint16_t)(v_prev_code));
self->private_data.f_suffixes[v_save_code][0] =
((uint8_t)(v_first_byte));
@@ -8549,16 +8571,13 @@
// ---------------- Status Codes Implementations
-const char* wuffs_gif__error__bad_block = "?gif: bad block";
-const char* wuffs_gif__error__bad_extension_label = "?gif: bad extension label";
-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__not_enough_pixel_data =
- "?gif: not enough pixel data";
-const char* wuffs_gif__error__too_much_pixel_data = "?gif: too much pixel data";
+const char* wuffs_gif__error__bad_block = "#gif: bad block";
+const char* wuffs_gif__error__bad_extension_label = "#gif: bad extension label";
+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__internal_error_inconsistent_ri_wi =
- "?gif: internal error: inconsistent ri/wi";
+ "#gif: internal error: inconsistent ri/wi";
// ---------------- Private Consts
@@ -8667,12 +8686,16 @@
if (self->private_impl.magic != 0) {
return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
}
- } else if ((initialize_flags &
- WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) != 0) {
- memset(&(self->private_impl), 0, sizeof(self->private_impl));
} else {
- memset(self, 0, sizeof(*self));
- initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+ void* p = &(self->private_impl);
+ size_t n = sizeof(self->private_impl);
+ if ((initialize_flags &
+ WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
+ p = self;
+ n = sizeof(*self);
+ initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+ }
+ memset(p, 0, n);
}
{
@@ -8791,7 +8814,8 @@
if (!self) {
return 0;
}
- if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
+ if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
+ (self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return 0;
}
@@ -8808,7 +8832,8 @@
if (!self) {
return 0;
}
- if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
+ if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
+ (self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return 0;
}
@@ -8822,7 +8847,8 @@
if (!self) {
return 0;
}
- if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
+ if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
+ (self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return 0;
}
@@ -8836,7 +8862,8 @@
if (!self) {
return ((wuffs_base__rect_ie_u32){0});
}
- if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
+ if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
+ (self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return ((wuffs_base__rect_ie_u32){0});
}
@@ -8856,7 +8883,8 @@
if (!self) {
return ((wuffs_base__range_ii_u64){0});
}
- if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
+ if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
+ (self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return ((wuffs_base__range_ii_u64){0});
}
@@ -10655,6 +10683,14 @@
label_0_break:;
self->private_impl.f_compressed_ri = 0;
self->private_impl.f_compressed_wi = 0;
+ if ((self->private_impl.f_dst_y < self->private_impl.f_frame_rect_y1) &&
+ (self->private_impl.f_frame_rect_x0 !=
+ self->private_impl.f_frame_rect_x1) &&
+ (self->private_impl.f_frame_rect_y0 !=
+ self->private_impl.f_frame_rect_y1)) {
+ status = wuffs_base__error__not_enough_data;
+ goto exit;
+ }
goto ok;
ok:
@@ -10707,7 +10743,7 @@
while (v_src_ri < ((uint64_t)(a_src.len))) {
v_src = wuffs_base__slice_u8__subslice_i(a_src, v_src_ri);
if (self->private_impl.f_dst_y >= self->private_impl.f_frame_rect_y1) {
- return wuffs_gif__error__too_much_pixel_data;
+ return wuffs_base__error__too_much_data;
}
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
v_i = (((uint64_t)(self->private_impl.f_dst_x)) *
@@ -10794,11 +10830,11 @@
// ---------------- Status Codes Implementations
-const char* wuffs_gzip__error__bad_checksum = "?gzip: bad checksum";
+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";
+ "#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
@@ -10828,12 +10864,16 @@
if (self->private_impl.magic != 0) {
return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
}
- } else if ((initialize_flags &
- WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) != 0) {
- memset(&(self->private_impl), 0, sizeof(self->private_impl));
} else {
- memset(self, 0, sizeof(*self));
- initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+ void* p = &(self->private_impl);
+ size_t n = sizeof(self->private_impl);
+ if ((initialize_flags &
+ WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
+ p = self;
+ n = sizeof(*self);
+ initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+ }
+ memset(p, 0, n);
}
{
@@ -10893,7 +10933,8 @@
if (!self) {
return ((wuffs_base__range_ii_u64){0});
}
- if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
+ if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
+ (self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return ((wuffs_base__range_ii_u64){0});
}
@@ -11272,14 +11313,14 @@
// ---------------- Status Codes Implementations
-const char* wuffs_zlib__error__bad_checksum = "?zlib: bad checksum";
+const char* wuffs_zlib__error__bad_checksum = "#zlib: bad checksum";
const char* wuffs_zlib__error__bad_compression_method =
- "?zlib: 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";
+ "#zlib: bad compression window size";
+const char* wuffs_zlib__error__bad_parity_check = "#zlib: bad parity check";
const char* wuffs_zlib__error__todo_unsupported_preset_dictionary =
- "?zlib: TODO: unsupported preset dictionary";
+ "#zlib: TODO: unsupported preset dictionary";
// ---------------- Private Consts
@@ -11309,12 +11350,16 @@
if (self->private_impl.magic != 0) {
return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
}
- } else if ((initialize_flags &
- WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) != 0) {
- memset(&(self->private_impl), 0, sizeof(self->private_impl));
} else {
- memset(self, 0, sizeof(*self));
- initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+ void* p = &(self->private_impl);
+ size_t n = sizeof(self->private_impl);
+ if ((initialize_flags &
+ WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
+ p = self;
+ n = sizeof(*self);
+ initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+ }
+ memset(p, 0, n);
}
{
@@ -11374,7 +11419,8 @@
if (!self) {
return ((wuffs_base__range_ii_u64){0});
}
- if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
+ if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
+ (self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return ((wuffs_base__range_ii_u64){0});
}
