From 5fb82e7d0acc68e136b7c5bc8c43522c47b02b3d Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Thu, 5 Oct 2023 11:25:42 +1100 Subject: [PATCH] std: add compact_retaining, history_retain_length --- doc/changelog.md | 1 + example/bzcat/bzcat.c | 3 +- example/convert-to-nia/convert-to-nia.c | 17 +- example/jsonptr/jsonptr.cc | 8 +- example/sdl-imageviewer/sdl-imageviewer.cc | 4 +- example/zcat/zcat.c | 3 +- internal/cgen/auxiliary/base.cc | 12 +- internal/cgen/auxiliary/base.hh | 6 +- internal/cgen/auxiliary/cbor.cc | 4 +- internal/cgen/auxiliary/image.cc | 14 +- internal/cgen/auxiliary/json.cc | 104 +-- internal/cgen/base/io-public.h | 55 +- internal/cgen/base/token-public.h | 56 +- lang/builtin/builtin.go | 5 +- release/c/wuffs-unsupported-snapshot.c | 919 ++++++++++++++++++--- std/bmp/decode_bmp.wuffs | 7 +- std/bzip2/decode_bzip2.wuffs | 7 +- std/cbor/decode_cbor.wuffs | 8 + std/deflate/decode_deflate.wuffs | 6 + std/gif/common_consts.wuffs | 3 +- std/gif/decode_gif.wuffs | 4 + std/gzip/decode_gzip.wuffs | 6 + std/jpeg/decode_jpeg.wuffs | 7 +- std/json/common_consts.wuffs | 4 + std/json/decode_json.wuffs | 4 + std/lzw/decode_lzw.wuffs | 6 + std/netpbm/decode_netpbm.wuffs | 7 +- std/nie/decode_nie.wuffs | 7 +- std/png/common_consts.wuffs | 3 +- std/png/decode_png.wuffs | 4 + std/tga/decode_tga.wuffs | 7 +- std/wbmp/decode_wbmp.wuffs | 7 +- std/zlib/decode_zlib.wuffs | 6 + 33 files changed, 1088 insertions(+), 226 deletions(-) diff --git a/doc/changelog.md b/doc/changelog.md index 89500702..69308bab 100644 --- a/doc/changelog.md +++ b/doc/changelog.md @@ -3,6 +3,7 @@ ## Work In Progress +- Added `compact_retaining` and `history_retain_length`. - Added `example/toy-aux-image`. - Added `get_quirk(key: u32) u64`. - Added `if.likely` and `if.unlikely`. diff --git a/example/bzcat/bzcat.c b/example/bzcat/bzcat.c index 68b5c261..3086a348 100644 --- a/example/bzcat/bzcat.c +++ b/example/bzcat/bzcat.c @@ -212,7 +212,8 @@ main1(int argc, char** argv) { return wuffs_base__status__message(&status); } - wuffs_base__io_buffer__compact(&src); + wuffs_base__io_buffer__compact_retaining( + &src, wuffs_bzip2__decoder__history_retain_length(&dec)); if (src.meta.wi == src.data.len) { return "main: internal error: no I/O progress possible"; } diff --git a/example/convert-to-nia/convert-to-nia.c b/example/convert-to-nia/convert-to-nia.c index f90d4887..d2225a90 100644 --- a/example/convert-to-nia/convert-to-nia.c +++ b/example/convert-to-nia/convert-to-nia.c @@ -255,11 +255,11 @@ static void // ignore_return_value(int ignored) {} const char* // -read_more_src() { +read_more_src(uint64_t history_retain_length) { if (g_src.meta.closed) { return "main: unexpected end of file"; } - wuffs_base__io_buffer__compact(&g_src); + wuffs_base__io_buffer__compact_retaining(&g_src, history_retain_length); ssize_t n = read(STDIN_FD, g_src.data.ptr + g_src.meta.wi, g_src.data.len - g_src.meta.wi); if (n > 0) { @@ -285,7 +285,7 @@ load_image_type() { (wuffs_base__io_buffer__reader_length(&g_src) == g_src.data.len)) { break; } - TRY(read_more_src()); + TRY(read_more_src(0)); } return NULL; } @@ -410,7 +410,7 @@ advance_for_redirect() { break; } g_src.meta.ri = g_src.meta.wi; - TRY(read_more_src()); + TRY(read_more_src(0)); } return NULL; } @@ -437,7 +437,8 @@ redirect: } else if (status.repr != wuffs_base__suspension__short_read) { return wuffs_base__status__message(&status); } - TRY(read_more_src()); + TRY(read_more_src( + wuffs_base__image_decoder__history_retain_length(g_image_decoder))); } // Read the dimensions. @@ -636,7 +637,8 @@ convert_frames() { } else if (dfc_status.repr != wuffs_base__suspension__short_read) { return wuffs_base__status__message(&dfc_status); } - TRY(read_more_src()); + TRY(read_more_src( + wuffs_base__image_decoder__history_retain_length(g_image_decoder))); } wuffs_base__flicks duration = @@ -678,7 +680,8 @@ convert_frames() { if (df_status.repr != wuffs_base__suspension__short_read) { break; } - decode_frame_io_error_message = read_more_src(); + decode_frame_io_error_message = read_more_src( + wuffs_base__image_decoder__history_retain_length(g_image_decoder)); if (decode_frame_io_error_message != NULL) { // Neuter the "short read" df_status so that convert_frames returns the // I/O error message instead. diff --git a/example/jsonptr/jsonptr.cc b/example/jsonptr/jsonptr.cc index 0cebc432..5deb98a2 100644 --- a/example/jsonptr/jsonptr.cc +++ b/example/jsonptr/jsonptr.cc @@ -1001,11 +1001,11 @@ static void // ignore_return_value(int ignored) {} const char* // -read_src() { +read_src(uint64_t history_retain_length) { if (g_src.meta.closed) { return "main: internal error: read requested on a closed source"; } - g_src.compact(); + g_src.compact_retaining(history_retain_length); if (g_src.meta.wi >= g_src.data.len) { return "main: g_src buffer is full"; } @@ -1398,7 +1398,7 @@ main1(int argc, char** argv) { } // Check that we've exhausted the input. if ((g_src.meta.ri == g_src.meta.wi) && !g_src.meta.closed) { - TRY(read_src()); + TRY(read_src(g_dec.history_retain_length())); } if ((g_src.meta.ri < g_src.meta.wi) || !g_src.meta.closed) { return "main: valid JSON followed by further (unexpected) data"; @@ -1409,7 +1409,7 @@ main1(int argc, char** argv) { if (g_cursor_index != g_src.meta.ri) { return "main: internal error: inconsistent g_src indexes"; } - TRY(read_src()); + TRY(read_src(g_dec.history_retain_length())); g_cursor_index = g_src.meta.ri; } else if (status.repr == wuffs_base__suspension__short_write) { g_tok.compact(); diff --git a/example/sdl-imageviewer/sdl-imageviewer.cc b/example/sdl-imageviewer/sdl-imageviewer.cc index be92759b..6b2eb096 100644 --- a/example/sdl-imageviewer/sdl-imageviewer.cc +++ b/example/sdl-imageviewer/sdl-imageviewer.cc @@ -193,7 +193,7 @@ class Wuffs_Load_RW_Input : public wuffs_aux::sync_io::Input { private: std::string // - CopyIn(wuffs_aux::IOBuffer* dst) override { + CopyIn(wuffs_aux::IOBuffer* dst, uint64_t history_retain_length) override { if (!m_rw) { return "Wuffs_Load_RW_Input: NULL SDL_RWops"; } else if (!dst) { @@ -201,7 +201,7 @@ class Wuffs_Load_RW_Input : public wuffs_aux::sync_io::Input { } else if (dst->meta.closed) { return "Wuffs_Load_RW_Input: end of file"; } - dst->compact(); + dst->compact_retaining(history_retain_length); if (dst->writer_length() == 0) { return "Wuffs_Load_RW_Input: full IOBuffer"; } diff --git a/example/zcat/zcat.c b/example/zcat/zcat.c index 85257398..508de731 100644 --- a/example/zcat/zcat.c +++ b/example/zcat/zcat.c @@ -214,7 +214,8 @@ main1(int argc, char** argv) { return wuffs_base__status__message(&status); } - wuffs_base__io_buffer__compact(&src); + wuffs_base__io_buffer__compact_retaining( + &src, wuffs_gzip__decoder__history_retain_length(&dec)); if (src.meta.wi == src.data.len) { return "main: internal error: no I/O progress possible"; } diff --git a/internal/cgen/auxiliary/base.cc b/internal/cgen/auxiliary/base.cc index a43a83e8..0b6cc681 100644 --- a/internal/cgen/auxiliary/base.cc +++ b/internal/cgen/auxiliary/base.cc @@ -102,7 +102,7 @@ Input::BringsItsOwnIOBuffer() { FileInput::FileInput(FILE* f) : m_f(f) {} std::string // -FileInput::CopyIn(IOBuffer* dst) { +FileInput::CopyIn(IOBuffer* dst, uint64_t history_retain_length) { if (!m_f) { return "wuffs_aux::sync_io::FileInput: nullptr file"; } else if (!dst) { @@ -110,7 +110,7 @@ FileInput::CopyIn(IOBuffer* dst) { } else if (dst->meta.closed) { return "wuffs_aux::sync_io::FileInput: end of file"; } else { - dst->compact(); + dst->compact_retaining(history_retain_length); size_t n = fread(dst->writer_pointer(), 1, dst->writer_length(), m_f); dst->meta.wi += n; dst->meta.closed = feof(m_f); @@ -138,7 +138,7 @@ MemoryInput::BringsItsOwnIOBuffer() { } std::string // -MemoryInput::CopyIn(IOBuffer* dst) { +MemoryInput::CopyIn(IOBuffer* dst, uint64_t history_retain_length) { if (!dst) { return "wuffs_aux::sync_io::MemoryInput: nullptr IOBuffer"; } else if (dst->meta.closed) { @@ -148,7 +148,7 @@ MemoryInput::CopyIn(IOBuffer* dst) { // to it. return "wuffs_aux::sync_io::MemoryInput: overlapping buffers"; } else { - dst->compact(); + dst->compact_retaining(history_retain_length); size_t nd = dst->writer_length(); size_t ns = m_io.reader_length(); size_t n = (nd < ns) ? nd : ns; @@ -203,7 +203,7 @@ AdvanceIOBufferTo(const ErrorMessages& error_messages, if (!input.BringsItsOwnIOBuffer()) { io_buf.compact(); } - std::string error_message = input.CopyIn(&io_buf); + std::string error_message = input.CopyIn(&io_buf, 0); if (!error_message.empty()) { return error_message; } @@ -286,7 +286,7 @@ HandleMetadata( } else if (!input.BringsItsOwnIOBuffer()) { io_buf.compact(); } - std::string error_message = input.CopyIn(&io_buf); + std::string error_message = input.CopyIn(&io_buf, 0); if (!error_message.empty()) { return error_message; } diff --git a/internal/cgen/auxiliary/base.hh b/internal/cgen/auxiliary/base.hh index 90fe2e8b..e312eaf5 100644 --- a/internal/cgen/auxiliary/base.hh +++ b/internal/cgen/auxiliary/base.hh @@ -98,7 +98,7 @@ class Input { virtual ~Input(); virtual IOBuffer* BringsItsOwnIOBuffer(); - virtual std::string CopyIn(IOBuffer* dst) = 0; + virtual std::string CopyIn(IOBuffer* dst, uint64_t history_retain_length) = 0; }; // -------- @@ -110,7 +110,7 @@ class FileInput : public Input { public: FileInput(FILE* f); - virtual std::string CopyIn(IOBuffer* dst); + virtual std::string CopyIn(IOBuffer* dst, uint64_t history_retain_length); private: FILE* m_f; @@ -131,7 +131,7 @@ class MemoryInput : public Input { MemoryInput(const uint8_t* ptr, size_t len); virtual IOBuffer* BringsItsOwnIOBuffer(); - virtual std::string CopyIn(IOBuffer* dst); + virtual std::string CopyIn(IOBuffer* dst, uint64_t history_retain_length); private: IOBuffer m_io; diff --git a/internal/cgen/auxiliary/cbor.cc b/internal/cgen/auxiliary/cbor.cc index 9cd9f25a..44e80638 100644 --- a/internal/cgen/auxiliary/cbor.cc +++ b/internal/cgen/auxiliary/cbor.cc @@ -115,14 +115,14 @@ DecodeCbor(DecodeCborCallbacks& callbacks, "wuffs_aux::DecodeCbor: internal error: io_buf is closed"; goto done; } - io_buf->compact(); + io_buf->compact_retaining(dec->history_retain_length()); if (io_buf->meta.wi >= io_buf->data.len) { ret_error_message = "wuffs_aux::DecodeCbor: internal error: io_buf is full"; goto done; } cursor_index = io_buf->meta.ri; - io_error_message = input.CopyIn(io_buf); + io_error_message = input.CopyIn(io_buf, dec->history_retain_length()); } else { ret_error_message = tok_status.message(); goto done; diff --git a/internal/cgen/auxiliary/image.cc b/internal/cgen/auxiliary/image.cc index aa693856..6c810aba 100644 --- a/internal/cgen/auxiliary/image.cc +++ b/internal/cgen/auxiliary/image.cc @@ -344,7 +344,7 @@ redirect: fourcc = 0; break; } - std::string error_message = input.CopyIn(&io_buf); + std::string error_message = input.CopyIn(&io_buf, 0); if (!error_message.empty()) { return DecodeImageResult(std::move(error_message)); } @@ -440,7 +440,8 @@ redirect: } else if (io_buf.meta.closed) { return DecodeImageResult(DecodeImage_UnexpectedEndOfFile); } else { - std::string error_message = input.CopyIn(&io_buf); + std::string error_message = + input.CopyIn(&io_buf, image_decoder->history_retain_length()); if (!error_message.empty()) { return DecodeImageResult(std::move(error_message)); } @@ -522,7 +523,8 @@ redirect: } else if (io_buf.meta.closed) { return DecodeImageResult(DecodeImage_UnexpectedEndOfFile); } else { - std::string error_message = input.CopyIn(&io_buf); + std::string error_message = + input.CopyIn(&io_buf, image_decoder->history_retain_length()); if (!error_message.empty()) { return DecodeImageResult(std::move(error_message)); } @@ -551,7 +553,8 @@ redirect: message = DecodeImage_UnexpectedEndOfFile; break; } else { - std::string error_message = input.CopyIn(&io_buf); + std::string error_message = + input.CopyIn(&io_buf, image_decoder->history_retain_length()); if (!error_message.empty()) { message = std::move(error_message); break; @@ -579,7 +582,8 @@ redirect: } else if (io_buf.meta.closed) { return DecodeImageResult(DecodeImage_UnexpectedEndOfFile); } else { - std::string error_message = input.CopyIn(&io_buf); + std::string error_message = + input.CopyIn(&io_buf, image_decoder->history_retain_length()); if (!error_message.empty()) { return DecodeImageResult(std::move(error_message)); } diff --git a/internal/cgen/auxiliary/json.cc b/internal/cgen/auxiliary/json.cc index 1dd7c9b1..58e79efe 100644 --- a/internal/cgen/auxiliary/json.cc +++ b/internal/cgen/auxiliary/json.cc @@ -58,58 +58,58 @@ DecodeJsonArgJsonPointer::DefaultValue() { // -------- -#define WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN \ - while (tok_buf.meta.ri >= tok_buf.meta.wi) { \ - if (tok_status.repr == nullptr) { \ - goto done; \ - } else if (tok_status.repr == wuffs_base__suspension__short_write) { \ - tok_buf.compact(); \ - } else if (tok_status.repr == wuffs_base__suspension__short_read) { \ - if (!io_error_message.empty()) { \ - ret_error_message = std::move(io_error_message); \ - goto done; \ - } else if (cursor_index != io_buf->meta.ri) { \ - ret_error_message = \ - "wuffs_aux::DecodeJson: internal error: bad cursor_index"; \ - goto done; \ - } else if (io_buf->meta.closed) { \ - ret_error_message = \ - "wuffs_aux::DecodeJson: internal error: io_buf is closed"; \ - goto done; \ - } \ - io_buf->compact(); \ - if (io_buf->meta.wi >= io_buf->data.len) { \ - ret_error_message = \ - "wuffs_aux::DecodeJson: internal error: io_buf is full"; \ - goto done; \ - } \ - cursor_index = io_buf->meta.ri; \ - io_error_message = input.CopyIn(io_buf); \ - } else { \ - ret_error_message = tok_status.message(); \ - goto done; \ - } \ - tok_status = \ - dec->decode_tokens(&tok_buf, io_buf, wuffs_base__empty_slice_u8()); \ - if ((tok_buf.meta.ri > tok_buf.meta.wi) || \ - (tok_buf.meta.wi > tok_buf.data.len) || \ - (io_buf->meta.ri > io_buf->meta.wi) || \ - (io_buf->meta.wi > io_buf->data.len)) { \ - ret_error_message = \ - "wuffs_aux::DecodeJson: internal error: bad buffer indexes"; \ - goto done; \ - } \ - } \ - wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++]; \ - uint64_t token_len = token.length(); \ - if ((io_buf->meta.ri < cursor_index) || \ - ((io_buf->meta.ri - cursor_index) < token_len)) { \ - ret_error_message = \ - "wuffs_aux::DecodeJson: internal error: bad token indexes"; \ - goto done; \ - } \ - uint8_t* token_ptr = io_buf->data.ptr + cursor_index; \ - (void)(token_ptr); \ +#define WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN \ + while (tok_buf.meta.ri >= tok_buf.meta.wi) { \ + if (tok_status.repr == nullptr) { \ + goto done; \ + } else if (tok_status.repr == wuffs_base__suspension__short_write) { \ + tok_buf.compact(); \ + } else if (tok_status.repr == wuffs_base__suspension__short_read) { \ + if (!io_error_message.empty()) { \ + ret_error_message = std::move(io_error_message); \ + goto done; \ + } else if (cursor_index != io_buf->meta.ri) { \ + ret_error_message = \ + "wuffs_aux::DecodeJson: internal error: bad cursor_index"; \ + goto done; \ + } else if (io_buf->meta.closed) { \ + ret_error_message = \ + "wuffs_aux::DecodeJson: internal error: io_buf is closed"; \ + goto done; \ + } \ + io_buf->compact_retaining(dec->history_retain_length()); \ + if (io_buf->meta.wi >= io_buf->data.len) { \ + ret_error_message = \ + "wuffs_aux::DecodeJson: internal error: io_buf is full"; \ + goto done; \ + } \ + cursor_index = io_buf->meta.ri; \ + io_error_message = input.CopyIn(io_buf, dec->history_retain_length()); \ + } else { \ + ret_error_message = tok_status.message(); \ + goto done; \ + } \ + tok_status = \ + dec->decode_tokens(&tok_buf, io_buf, wuffs_base__empty_slice_u8()); \ + if ((tok_buf.meta.ri > tok_buf.meta.wi) || \ + (tok_buf.meta.wi > tok_buf.data.len) || \ + (io_buf->meta.ri > io_buf->meta.wi) || \ + (io_buf->meta.wi > io_buf->data.len)) { \ + ret_error_message = \ + "wuffs_aux::DecodeJson: internal error: bad buffer indexes"; \ + goto done; \ + } \ + } \ + wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++]; \ + uint64_t token_len = token.length(); \ + if ((io_buf->meta.ri < cursor_index) || \ + ((io_buf->meta.ri - cursor_index) < token_len)) { \ + ret_error_message = \ + "wuffs_aux::DecodeJson: internal error: bad token indexes"; \ + goto done; \ + } \ + uint8_t* token_ptr = io_buf->data.ptr + cursor_index; \ + (void)(token_ptr); \ cursor_index += static_cast(token_len) // -------- diff --git a/internal/cgen/base/io-public.h b/internal/cgen/base/io-public.h index 458be692..dd5d454b 100644 --- a/internal/cgen/base/io-public.h +++ b/internal/cgen/base/io-public.h @@ -36,6 +36,7 @@ typedef struct wuffs_base__io_buffer__struct { #ifdef __cplusplus inline bool is_valid() const; inline void compact(); + inline void compact_retaining(uint64_t history_retain_length); inline size_t reader_length() const; inline uint8_t* reader_pointer() const; inline uint64_t reader_position() const; @@ -160,14 +161,55 @@ wuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) { return; } buf->meta.pos = wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri); - size_t n = buf->meta.wi - buf->meta.ri; - if (n != 0) { - memmove(buf->data.ptr, buf->data.ptr + buf->meta.ri, n); + size_t new_wi = buf->meta.wi - buf->meta.ri; + if (new_wi != 0) { + memmove(buf->data.ptr, buf->data.ptr + buf->meta.ri, new_wi); } - buf->meta.wi = n; + buf->meta.wi = new_wi; buf->meta.ri = 0; } +// wuffs_base__io_buffer__compact_retaining moves any written but unread bytes +// closer to the start of the buffer. It retains H bytes of history (the most +// recently read bytes), where H is min(buf->meta.ri, history_retain_length). +// A postcondition is that buf->meta.ri == H. +// +// wuffs_base__io_buffer__compact_retaining(0) is equivalent to +// wuffs_base__io_buffer__compact(). +// +// For example, if buf started like this: +// +// +--- ri = 3 +// v +// abcdefgh?? len = 10, pos = 900 +// ^ +// +--- wi = 8 +// +// Then, depending on history_retain_length, the resultant buf would be: +// +// HRL = 0 defgh????? ri = 0 wi = 5 pos = 903 +// HRL = 1 cdefgh???? ri = 1 wi = 6 pos = 902 +// HRL = 2 bcdefgh??? ri = 2 wi = 7 pos = 901 +// HRL = 3 abcdefgh?? ri = 3 wi = 8 pos = 900 +// HRL = 4+ abcdefgh?? ri = 3 wi = 8 pos = 900 +static inline void // +wuffs_base__io_buffer__compact_retaining(wuffs_base__io_buffer* buf, + uint64_t history_retain_length) { + if (!buf || (buf->meta.ri == 0)) { + return; + } + size_t old_ri = buf->meta.ri; + size_t new_ri = (size_t)(wuffs_base__u64__min(old_ri, history_retain_length)); + size_t memmove_start = old_ri - new_ri; + buf->meta.pos = wuffs_base__u64__sat_add(buf->meta.pos, memmove_start); + size_t new_wi = buf->meta.wi - memmove_start; + if ((new_wi != 0) && (memmove_start != 0)) { + memmove(buf->data.ptr, buf->data.ptr + memmove_start, new_wi); + } + buf->meta.wi = new_wi; + buf->meta.ri = new_ri; +} + static inline size_t // wuffs_base__io_buffer__reader_length(const wuffs_base__io_buffer* buf) { return buf ? buf->meta.wi - buf->meta.ri : 0; @@ -224,6 +266,11 @@ wuffs_base__io_buffer::compact() { wuffs_base__io_buffer__compact(this); } +inline void // +wuffs_base__io_buffer::compact_retaining(uint64_t history_retain_length) { + wuffs_base__io_buffer__compact_retaining(this, history_retain_length); +} + inline size_t // wuffs_base__io_buffer::reader_length() const { return wuffs_base__io_buffer__reader_length(this); diff --git a/internal/cgen/base/token-public.h b/internal/cgen/base/token-public.h index f7df668a..0f865157 100644 --- a/internal/cgen/base/token-public.h +++ b/internal/cgen/base/token-public.h @@ -321,6 +321,7 @@ typedef struct wuffs_base__token_buffer__struct { #ifdef __cplusplus inline bool is_valid() const; inline void compact(); + inline void compact_retaining(uint64_t history_retain_length); inline uint64_t reader_length() const; inline wuffs_base__token* reader_pointer() const; inline wuffs_base__slice_token reader_slice() const; @@ -421,15 +422,57 @@ wuffs_base__token_buffer__compact(wuffs_base__token_buffer* buf) { return; } buf->meta.pos = wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri); - size_t n = buf->meta.wi - buf->meta.ri; - if (n != 0) { + size_t new_wi = buf->meta.wi - buf->meta.ri; + if (new_wi != 0) { memmove(buf->data.ptr, buf->data.ptr + buf->meta.ri, - n * sizeof(wuffs_base__token)); + new_wi * sizeof(wuffs_base__token)); } - buf->meta.wi = n; + buf->meta.wi = new_wi; buf->meta.ri = 0; } +// wuffs_base__token_buffer__compact_retaining moves any written but unread +// tokens closer to the start of the buffer. It retains H tokens of history +// (the most recently read tokens), where H is min(buf->meta.ri, +// history_retain_length). A postcondition is that buf->meta.ri == H. +// +// wuffs_base__token_buffer__compact_retaining(0) is equivalent to +// wuffs_base__token_buffer__compact(). +// +// For example, if buf started like this: +// +// +--- ri = 3 +// v +// abcdefgh?? len = 10, pos = 900 +// ^ +// +--- wi = 8 +// +// Then, depending on history_retain_length, the resultant buf would be: +// +// HRL = 0 defgh????? ri = 0 wi = 5 pos = 903 +// HRL = 1 cdefgh???? ri = 1 wi = 6 pos = 902 +// HRL = 2 bcdefgh??? ri = 2 wi = 7 pos = 901 +// HRL = 3 abcdefgh?? ri = 3 wi = 8 pos = 900 +// HRL = 4+ abcdefgh?? ri = 3 wi = 8 pos = 900 +static inline void // +wuffs_base__token_buffer__compact_retaining(wuffs_base__token_buffer* buf, + uint64_t history_retain_length) { + if (!buf || (buf->meta.ri == 0)) { + return; + } + size_t old_ri = buf->meta.ri; + size_t new_ri = (size_t)(wuffs_base__u64__min(old_ri, history_retain_length)); + size_t memmove_start = old_ri - new_ri; + buf->meta.pos = wuffs_base__u64__sat_add(buf->meta.pos, memmove_start); + size_t new_wi = buf->meta.wi - memmove_start; + if ((new_wi != 0) && (memmove_start != 0)) { + memmove(buf->data.ptr, buf->data.ptr + memmove_start, + new_wi * sizeof(wuffs_base__token)); + } + buf->meta.wi = new_wi; + buf->meta.ri = new_ri; +} + static inline uint64_t // wuffs_base__token_buffer__reader_length(const wuffs_base__token_buffer* buf) { return buf ? buf->meta.wi - buf->meta.ri : 0; @@ -488,6 +531,11 @@ wuffs_base__token_buffer::compact() { wuffs_base__token_buffer__compact(this); } +inline void // +wuffs_base__token_buffer::compact_retaining(uint64_t history_retain_length) { + wuffs_base__token_buffer__compact_retaining(this, history_retain_length); +} + inline uint64_t // wuffs_base__token_buffer::reader_length() const { return wuffs_base__token_buffer__reader_length(this); diff --git a/lang/builtin/builtin.go b/lang/builtin/builtin.go index 5360f115..af6dcfb3 100644 --- a/lang/builtin/builtin.go +++ b/lang/builtin/builtin.go @@ -969,6 +969,7 @@ var InterfaceFuncs = []string{ "image_decoder.decode_image_config?(dst: nptr image_config, src: io_reader)", "image_decoder.frame_dirty_rect() rect_ie_u32", "image_decoder.get_quirk(key: u32) u64", + "image_decoder.history_retain_length() u64", "image_decoder.num_animation_loops() u32", "image_decoder.num_decoded_frame_configs() u64", "image_decoder.num_decoded_frames() u64", @@ -981,14 +982,16 @@ var InterfaceFuncs = []string{ // ---- io_transformer "io_transformer.get_quirk(key: u32) u64", + "io_transformer.history_retain_length() u64", "io_transformer.set_quirk!(key: u32, value: u64) status", "io_transformer.transform_io?(dst: io_writer, src: io_reader, workbuf: slice u8)", "io_transformer.workbuf_len() range_ii_u64", // ---- token_decoder - "token_decoder.get_quirk(key: u32) u64", "token_decoder.decode_tokens?(dst: token_writer, src: io_reader, workbuf: slice u8)", + "token_decoder.get_quirk(key: u32) u64", + "token_decoder.history_retain_length() u64", "token_decoder.set_quirk!(key: u32, value: u64) status", "token_decoder.workbuf_len() range_ii_u64", } diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index cbf3f241..56b94156 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -2878,6 +2878,7 @@ typedef struct wuffs_base__io_buffer__struct { #ifdef __cplusplus inline bool is_valid() const; inline void compact(); + inline void compact_retaining(uint64_t history_retain_length); inline size_t reader_length() const; inline uint8_t* reader_pointer() const; inline uint64_t reader_position() const; @@ -3002,14 +3003,55 @@ wuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) { return; } buf->meta.pos = wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri); - size_t n = buf->meta.wi - buf->meta.ri; - if (n != 0) { - memmove(buf->data.ptr, buf->data.ptr + buf->meta.ri, n); + size_t new_wi = buf->meta.wi - buf->meta.ri; + if (new_wi != 0) { + memmove(buf->data.ptr, buf->data.ptr + buf->meta.ri, new_wi); } - buf->meta.wi = n; + buf->meta.wi = new_wi; buf->meta.ri = 0; } +// wuffs_base__io_buffer__compact_retaining moves any written but unread bytes +// closer to the start of the buffer. It retains H bytes of history (the most +// recently read bytes), where H is min(buf->meta.ri, history_retain_length). +// A postcondition is that buf->meta.ri == H. +// +// wuffs_base__io_buffer__compact_retaining(0) is equivalent to +// wuffs_base__io_buffer__compact(). +// +// For example, if buf started like this: +// +// +--- ri = 3 +// v +// abcdefgh?? len = 10, pos = 900 +// ^ +// +--- wi = 8 +// +// Then, depending on history_retain_length, the resultant buf would be: +// +// HRL = 0 defgh????? ri = 0 wi = 5 pos = 903 +// HRL = 1 cdefgh???? ri = 1 wi = 6 pos = 902 +// HRL = 2 bcdefgh??? ri = 2 wi = 7 pos = 901 +// HRL = 3 abcdefgh?? ri = 3 wi = 8 pos = 900 +// HRL = 4+ abcdefgh?? ri = 3 wi = 8 pos = 900 +static inline void // +wuffs_base__io_buffer__compact_retaining(wuffs_base__io_buffer* buf, + uint64_t history_retain_length) { + if (!buf || (buf->meta.ri == 0)) { + return; + } + size_t old_ri = buf->meta.ri; + size_t new_ri = (size_t)(wuffs_base__u64__min(old_ri, history_retain_length)); + size_t memmove_start = old_ri - new_ri; + buf->meta.pos = wuffs_base__u64__sat_add(buf->meta.pos, memmove_start); + size_t new_wi = buf->meta.wi - memmove_start; + if ((new_wi != 0) && (memmove_start != 0)) { + memmove(buf->data.ptr, buf->data.ptr + memmove_start, new_wi); + } + buf->meta.wi = new_wi; + buf->meta.ri = new_ri; +} + static inline size_t // wuffs_base__io_buffer__reader_length(const wuffs_base__io_buffer* buf) { return buf ? buf->meta.wi - buf->meta.ri : 0; @@ -3066,6 +3108,11 @@ wuffs_base__io_buffer::compact() { wuffs_base__io_buffer__compact(this); } +inline void // +wuffs_base__io_buffer::compact_retaining(uint64_t history_retain_length) { + wuffs_base__io_buffer__compact_retaining(this, history_retain_length); +} + inline size_t // wuffs_base__io_buffer::reader_length() const { return wuffs_base__io_buffer__reader_length(this); @@ -3417,6 +3464,7 @@ typedef struct wuffs_base__token_buffer__struct { #ifdef __cplusplus inline bool is_valid() const; inline void compact(); + inline void compact_retaining(uint64_t history_retain_length); inline uint64_t reader_length() const; inline wuffs_base__token* reader_pointer() const; inline wuffs_base__slice_token reader_slice() const; @@ -3517,15 +3565,57 @@ wuffs_base__token_buffer__compact(wuffs_base__token_buffer* buf) { return; } buf->meta.pos = wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri); - size_t n = buf->meta.wi - buf->meta.ri; - if (n != 0) { + size_t new_wi = buf->meta.wi - buf->meta.ri; + if (new_wi != 0) { memmove(buf->data.ptr, buf->data.ptr + buf->meta.ri, - n * sizeof(wuffs_base__token)); + new_wi * sizeof(wuffs_base__token)); } - buf->meta.wi = n; + buf->meta.wi = new_wi; buf->meta.ri = 0; } +// wuffs_base__token_buffer__compact_retaining moves any written but unread +// tokens closer to the start of the buffer. It retains H tokens of history +// (the most recently read tokens), where H is min(buf->meta.ri, +// history_retain_length). A postcondition is that buf->meta.ri == H. +// +// wuffs_base__token_buffer__compact_retaining(0) is equivalent to +// wuffs_base__token_buffer__compact(). +// +// For example, if buf started like this: +// +// +--- ri = 3 +// v +// abcdefgh?? len = 10, pos = 900 +// ^ +// +--- wi = 8 +// +// Then, depending on history_retain_length, the resultant buf would be: +// +// HRL = 0 defgh????? ri = 0 wi = 5 pos = 903 +// HRL = 1 cdefgh???? ri = 1 wi = 6 pos = 902 +// HRL = 2 bcdefgh??? ri = 2 wi = 7 pos = 901 +// HRL = 3 abcdefgh?? ri = 3 wi = 8 pos = 900 +// HRL = 4+ abcdefgh?? ri = 3 wi = 8 pos = 900 +static inline void // +wuffs_base__token_buffer__compact_retaining(wuffs_base__token_buffer* buf, + uint64_t history_retain_length) { + if (!buf || (buf->meta.ri == 0)) { + return; + } + size_t old_ri = buf->meta.ri; + size_t new_ri = (size_t)(wuffs_base__u64__min(old_ri, history_retain_length)); + size_t memmove_start = old_ri - new_ri; + buf->meta.pos = wuffs_base__u64__sat_add(buf->meta.pos, memmove_start); + size_t new_wi = buf->meta.wi - memmove_start; + if ((new_wi != 0) && (memmove_start != 0)) { + memmove(buf->data.ptr, buf->data.ptr + memmove_start, + new_wi * sizeof(wuffs_base__token)); + } + buf->meta.wi = new_wi; + buf->meta.ri = new_ri; +} + static inline uint64_t // wuffs_base__token_buffer__reader_length(const wuffs_base__token_buffer* buf) { return buf ? buf->meta.wi - buf->meta.ri : 0; @@ -3584,6 +3674,11 @@ wuffs_base__token_buffer::compact() { wuffs_base__token_buffer__compact(this); } +inline void // +wuffs_base__token_buffer::compact_retaining(uint64_t history_retain_length) { + wuffs_base__token_buffer__compact_retaining(this, history_retain_length); +} + inline uint64_t // wuffs_base__token_buffer::reader_length() const { return wuffs_base__token_buffer__reader_length(this); @@ -6004,6 +6099,8 @@ typedef struct wuffs_base__image_decoder__func_ptrs__struct { uint64_t (*get_quirk)( const void* self, uint32_t a_key); + uint64_t (*history_retain_length)( + const void* self); uint32_t (*num_animation_loops)( const void* self); uint64_t (*num_decoded_frame_configs)( @@ -6068,6 +6165,11 @@ wuffs_base__image_decoder__get_quirk( const wuffs_base__image_decoder* self, uint32_t a_key); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_base__image_decoder__history_retain_length( + const wuffs_base__image_decoder* self); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC uint32_t wuffs_base__image_decoder__num_animation_loops( @@ -6170,6 +6272,11 @@ struct wuffs_base__image_decoder__struct { this, a_key); } + inline uint64_t + history_retain_length() const { + return wuffs_base__image_decoder__history_retain_length(this); + } + inline uint32_t num_animation_loops() const { return wuffs_base__image_decoder__num_animation_loops(this); @@ -6236,6 +6343,8 @@ typedef struct wuffs_base__io_transformer__func_ptrs__struct { uint64_t (*get_quirk)( const void* self, uint32_t a_key); + uint64_t (*history_retain_length)( + const void* self); wuffs_base__status (*set_quirk)( void* self, uint32_t a_key, @@ -6257,6 +6366,11 @@ wuffs_base__io_transformer__get_quirk( const wuffs_base__io_transformer* self, uint32_t a_key); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_base__io_transformer__history_retain_length( + const wuffs_base__io_transformer* self); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__status wuffs_base__io_transformer__set_quirk( @@ -6298,6 +6412,11 @@ struct wuffs_base__io_transformer__struct { this, a_key); } + inline uint64_t + history_retain_length() const { + return wuffs_base__io_transformer__history_retain_length(this); + } + inline wuffs_base__status set_quirk( uint32_t a_key, @@ -6330,14 +6449,16 @@ struct wuffs_base__io_transformer__struct { extern const char wuffs_base__token_decoder__vtable_name[]; typedef struct wuffs_base__token_decoder__func_ptrs__struct { - uint64_t (*get_quirk)( - const void* self, - uint32_t a_key); wuffs_base__status (*decode_tokens)( void* self, wuffs_base__token_buffer* a_dst, wuffs_base__io_buffer* a_src, wuffs_base__slice_u8 a_workbuf); + uint64_t (*get_quirk)( + const void* self, + uint32_t a_key); + uint64_t (*history_retain_length)( + const void* self); wuffs_base__status (*set_quirk)( void* self, uint32_t a_key, @@ -6348,12 +6469,6 @@ typedef struct wuffs_base__token_decoder__func_ptrs__struct { typedef struct wuffs_base__token_decoder__struct wuffs_base__token_decoder; -WUFFS_BASE__GENERATED_C_CODE -WUFFS_BASE__MAYBE_STATIC uint64_t -wuffs_base__token_decoder__get_quirk( - const wuffs_base__token_decoder* self, - uint32_t a_key); - WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__status wuffs_base__token_decoder__decode_tokens( @@ -6362,6 +6477,17 @@ wuffs_base__token_decoder__decode_tokens( wuffs_base__io_buffer* a_src, wuffs_base__slice_u8 a_workbuf); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_base__token_decoder__get_quirk( + const wuffs_base__token_decoder* self, + uint32_t a_key); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_base__token_decoder__history_retain_length( + const wuffs_base__token_decoder* self); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__status wuffs_base__token_decoder__set_quirk( @@ -6388,13 +6514,6 @@ struct wuffs_base__token_decoder__struct { using unique_ptr = std::unique_ptr; #endif - inline uint64_t - get_quirk( - uint32_t a_key) const { - return wuffs_base__token_decoder__get_quirk( - this, a_key); - } - inline wuffs_base__status decode_tokens( wuffs_base__token_buffer* a_dst, @@ -6404,6 +6523,18 @@ struct wuffs_base__token_decoder__struct { this, a_dst, a_src, a_workbuf); } + inline uint64_t + get_quirk( + uint32_t a_key) const { + return wuffs_base__token_decoder__get_quirk( + this, a_key); + } + + inline uint64_t + history_retain_length() const { + return wuffs_base__token_decoder__history_retain_length(this); + } + inline wuffs_base__status set_quirk( uint32_t a_key, @@ -6639,6 +6770,8 @@ extern const char wuffs_bmp__error__unsupported_bmp_file[]; // ---------------- Public Consts +#define WUFFS_BMP__DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE 0 + #define WUFFS_BMP__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 // ---------------- Struct Declarations @@ -6772,6 +6905,11 @@ wuffs_bmp__decoder__tell_me_more( wuffs_base__more_information* a_minfo, wuffs_base__io_buffer* a_src); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_bmp__decoder__history_retain_length( + const wuffs_bmp__decoder* self); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 wuffs_bmp__decoder__workbuf_len( @@ -6997,6 +7135,11 @@ struct wuffs_bmp__decoder__struct { return wuffs_bmp__decoder__tell_me_more(this, a_dst, a_minfo, a_src); } + inline uint64_t + history_retain_length() const { + return wuffs_bmp__decoder__history_retain_length(this); + } + inline wuffs_base__range_ii_u64 workbuf_len() const { return wuffs_bmp__decoder__workbuf_len(this); @@ -7025,6 +7168,8 @@ extern const char wuffs_bzip2__error__unsupported_block_randomization[]; // ---------------- Public Consts +#define WUFFS_BZIP2__DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE 0 + #define WUFFS_BZIP2__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 // ---------------- Struct Declarations @@ -7092,6 +7237,11 @@ wuffs_bzip2__decoder__set_quirk( uint32_t a_key, uint64_t a_value); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_bzip2__decoder__history_retain_length( + const wuffs_bzip2__decoder* self); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 wuffs_bzip2__decoder__workbuf_len( @@ -7274,6 +7424,11 @@ struct wuffs_bzip2__decoder__struct { return wuffs_bzip2__decoder__set_quirk(this, a_key, a_value); } + inline uint64_t + history_retain_length() const { + return wuffs_bzip2__decoder__history_retain_length(this); + } + inline wuffs_base__range_ii_u64 workbuf_len() const { return wuffs_bzip2__decoder__workbuf_len(this); @@ -7303,6 +7458,8 @@ extern const char wuffs_cbor__error__unsupported_recursion_depth[]; // ---------------- Public Consts +#define WUFFS_CBOR__DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE 0 + #define WUFFS_CBOR__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 #define WUFFS_CBOR__DECODER_DEPTH_MAX_INCL 1024 @@ -7386,6 +7543,11 @@ wuffs_cbor__decoder__set_quirk( uint32_t a_key, uint64_t a_value); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_cbor__decoder__history_retain_length( + const wuffs_cbor__decoder* self); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 wuffs_cbor__decoder__workbuf_len( @@ -7518,6 +7680,11 @@ struct wuffs_cbor__decoder__struct { return wuffs_cbor__decoder__set_quirk(this, a_key, a_value); } + inline uint64_t + history_retain_length() const { + return wuffs_cbor__decoder__history_retain_length(this); + } + inline wuffs_base__range_ii_u64 workbuf_len() const { return wuffs_cbor__decoder__workbuf_len(this); @@ -7758,6 +7925,8 @@ extern const char wuffs_deflate__error__truncated_input[]; // ---------------- Public Consts +#define WUFFS_DEFLATE__DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE 0 + #define WUFFS_DEFLATE__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 1 // ---------------- Struct Declarations @@ -7831,6 +8000,11 @@ wuffs_deflate__decoder__set_quirk( uint32_t a_key, uint64_t a_value); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_deflate__decoder__history_retain_length( + const wuffs_deflate__decoder* self); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 wuffs_deflate__decoder__workbuf_len( @@ -8009,6 +8183,11 @@ struct wuffs_deflate__decoder__struct { return wuffs_deflate__decoder__set_quirk(this, a_key, a_value); } + inline uint64_t + history_retain_length() const { + return wuffs_deflate__decoder__history_retain_length(this); + } + inline wuffs_base__range_ii_u64 workbuf_len() const { return wuffs_deflate__decoder__workbuf_len(this); @@ -8044,6 +8223,8 @@ extern const char wuffs_gif__error__truncated_input[]; // ---------------- Public Consts +#define WUFFS_GIF__DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE 0 + #define WUFFS_GIF__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 #define WUFFS_GIF__QUIRK_DELAY_NUM_DECODED_FRAMES 1041635328 @@ -8167,6 +8348,11 @@ WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32 wuffs_gif__decoder__frame_dirty_rect( const wuffs_gif__decoder* self); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_gif__decoder__history_retain_length( + const wuffs_gif__decoder* self); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 wuffs_gif__decoder__workbuf_len( @@ -8464,6 +8650,11 @@ struct wuffs_gif__decoder__struct { return wuffs_gif__decoder__frame_dirty_rect(this); } + inline uint64_t + history_retain_length() const { + return wuffs_gif__decoder__history_retain_length(this); + } + inline wuffs_base__range_ii_u64 workbuf_len() const { return wuffs_gif__decoder__workbuf_len(this); @@ -8512,6 +8703,8 @@ extern const char wuffs_gzip__error__truncated_input[]; // ---------------- Public Consts +#define WUFFS_GZIP__DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE 0 + #define WUFFS_GZIP__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 1 // ---------------- Struct Declarations @@ -8579,6 +8772,11 @@ wuffs_gzip__decoder__set_quirk( uint32_t a_key, uint64_t a_value); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_gzip__decoder__history_retain_length( + const wuffs_gzip__decoder* self); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 wuffs_gzip__decoder__workbuf_len( @@ -8713,6 +8911,11 @@ struct wuffs_gzip__decoder__struct { return wuffs_gzip__decoder__set_quirk(this, a_key, a_value); } + inline uint64_t + history_retain_length() const { + return wuffs_gzip__decoder__history_retain_length(this); + } + inline wuffs_base__range_ii_u64 workbuf_len() const { return wuffs_gzip__decoder__workbuf_len(this); @@ -8761,6 +8964,8 @@ extern const char wuffs_jpeg__error__unsupported_scan_count[]; // ---------------- Public Consts +#define WUFFS_JPEG__DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE 0 + #define WUFFS_JPEG__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 51552191232 // ---------------- Struct Declarations @@ -8894,6 +9099,11 @@ wuffs_jpeg__decoder__tell_me_more( wuffs_base__more_information* a_minfo, wuffs_base__io_buffer* a_src); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_jpeg__decoder__history_retain_length( + const wuffs_jpeg__decoder* self); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 wuffs_jpeg__decoder__workbuf_len( @@ -9215,6 +9425,11 @@ struct wuffs_jpeg__decoder__struct { return wuffs_jpeg__decoder__tell_me_more(this, a_dst, a_minfo, a_src); } + inline uint64_t + history_retain_length() const { + return wuffs_jpeg__decoder__history_retain_length(this); + } + inline wuffs_base__range_ii_u64 workbuf_len() const { return wuffs_jpeg__decoder__workbuf_len(this); @@ -9242,6 +9457,8 @@ extern const char wuffs_json__error__unsupported_recursion_depth[]; // ---------------- Public Consts +#define WUFFS_JSON__DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE 0 + #define WUFFS_JSON__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 #define WUFFS_JSON__DECODER_DEPTH_MAX_INCL 1024 @@ -9355,6 +9572,11 @@ wuffs_json__decoder__set_quirk( uint32_t a_key, uint64_t a_value); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_json__decoder__history_retain_length( + const wuffs_json__decoder* self); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 wuffs_json__decoder__workbuf_len( @@ -9494,6 +9716,11 @@ struct wuffs_json__decoder__struct { return wuffs_json__decoder__set_quirk(this, a_key, a_value); } + inline uint64_t + history_retain_length() const { + return wuffs_json__decoder__history_retain_length(this); + } + inline wuffs_base__range_ii_u64 workbuf_len() const { return wuffs_json__decoder__workbuf_len(this); @@ -9523,6 +9750,8 @@ extern const char wuffs_lzw__error__truncated_input[]; // ---------------- Public Consts +#define WUFFS_LZW__DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE 0 + #define WUFFS_LZW__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 #define WUFFS_LZW__QUIRK_LITERAL_WIDTH_PLUS_ONE 1348378624 @@ -9592,6 +9821,11 @@ wuffs_lzw__decoder__set_quirk( uint32_t a_key, uint64_t a_value); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_lzw__decoder__history_retain_length( + const wuffs_lzw__decoder* self); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 wuffs_lzw__decoder__workbuf_len( @@ -9736,6 +9970,11 @@ struct wuffs_lzw__decoder__struct { return wuffs_lzw__decoder__set_quirk(this, a_key, a_value); } + inline uint64_t + history_retain_length() const { + return wuffs_lzw__decoder__history_retain_length(this); + } + inline wuffs_base__range_ii_u64 workbuf_len() const { return wuffs_lzw__decoder__workbuf_len(this); @@ -9771,6 +10010,8 @@ extern const char wuffs_netpbm__error__unsupported_netpbm_file[]; // ---------------- Public Consts +#define WUFFS_NETPBM__DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE 0 + #define WUFFS_NETPBM__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 // ---------------- Struct Declarations @@ -9904,6 +10145,11 @@ wuffs_netpbm__decoder__tell_me_more( wuffs_base__more_information* a_minfo, wuffs_base__io_buffer* a_src); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_netpbm__decoder__history_retain_length( + const wuffs_netpbm__decoder* self); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 wuffs_netpbm__decoder__workbuf_len( @@ -10095,6 +10341,11 @@ struct wuffs_netpbm__decoder__struct { return wuffs_netpbm__decoder__tell_me_more(this, a_dst, a_minfo, a_src); } + inline uint64_t + history_retain_length() const { + return wuffs_netpbm__decoder__history_retain_length(this); + } + inline wuffs_base__range_ii_u64 workbuf_len() const { return wuffs_netpbm__decoder__workbuf_len(this); @@ -10117,6 +10368,8 @@ extern const char wuffs_nie__error__unsupported_nie_file[]; // ---------------- Public Consts +#define WUFFS_NIE__DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE 0 + #define WUFFS_NIE__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 // ---------------- Struct Declarations @@ -10250,6 +10503,11 @@ wuffs_nie__decoder__tell_me_more( wuffs_base__more_information* a_minfo, wuffs_base__io_buffer* a_src); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_nie__decoder__history_retain_length( + const wuffs_nie__decoder* self); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 wuffs_nie__decoder__workbuf_len( @@ -10445,6 +10703,11 @@ struct wuffs_nie__decoder__struct { return wuffs_nie__decoder__tell_me_more(this, a_dst, a_minfo, a_src); } + inline uint64_t + history_retain_length() const { + return wuffs_nie__decoder__history_retain_length(this); + } + inline wuffs_base__range_ii_u64 workbuf_len() const { return wuffs_nie__decoder__workbuf_len(this); @@ -10473,6 +10736,8 @@ extern const char wuffs_zlib__error__truncated_input[]; #define WUFFS_ZLIB__QUIRK_JUST_RAW_DEFLATE 2113790976 +#define WUFFS_ZLIB__DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE 0 + #define WUFFS_ZLIB__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 1 // ---------------- Struct Declarations @@ -10551,6 +10816,11 @@ wuffs_zlib__decoder__set_quirk( uint32_t a_key, uint64_t a_value); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_zlib__decoder__history_retain_length( + const wuffs_zlib__decoder* self); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 wuffs_zlib__decoder__workbuf_len( @@ -10701,6 +10971,11 @@ struct wuffs_zlib__decoder__struct { return wuffs_zlib__decoder__set_quirk(this, a_key, a_value); } + inline uint64_t + history_retain_length() const { + return wuffs_zlib__decoder__history_retain_length(this); + } + inline wuffs_base__range_ii_u64 workbuf_len() const { return wuffs_zlib__decoder__workbuf_len(this); @@ -10739,6 +11014,8 @@ extern const char wuffs_png__error__unsupported_png_file[]; // ---------------- Public Consts +#define WUFFS_PNG__DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE 0 + #define WUFFS_PNG__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 2251799562027015 #define WUFFS_PNG__DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL 8 @@ -10874,6 +11151,11 @@ wuffs_png__decoder__tell_me_more( wuffs_base__more_information* a_minfo, wuffs_base__io_buffer* a_src); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_png__decoder__history_retain_length( + const wuffs_png__decoder* self); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 wuffs_png__decoder__workbuf_len( @@ -11212,6 +11494,11 @@ struct wuffs_png__decoder__struct { return wuffs_png__decoder__tell_me_more(this, a_dst, a_minfo, a_src); } + inline uint64_t + history_retain_length() const { + return wuffs_png__decoder__history_retain_length(this); + } + inline wuffs_base__range_ii_u64 workbuf_len() const { return wuffs_png__decoder__workbuf_len(this); @@ -11235,6 +11522,8 @@ extern const char wuffs_tga__error__unsupported_tga_file[]; // ---------------- Public Consts +#define WUFFS_TGA__DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE 0 + #define WUFFS_TGA__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 // ---------------- Struct Declarations @@ -11368,6 +11657,11 @@ wuffs_tga__decoder__tell_me_more( wuffs_base__more_information* a_minfo, wuffs_base__io_buffer* a_src); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_tga__decoder__history_retain_length( + const wuffs_tga__decoder* self); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 wuffs_tga__decoder__workbuf_len( @@ -11589,6 +11883,11 @@ struct wuffs_tga__decoder__struct { return wuffs_tga__decoder__tell_me_more(this, a_dst, a_minfo, a_src); } + inline uint64_t + history_retain_length() const { + return wuffs_tga__decoder__history_retain_length(this); + } + inline wuffs_base__range_ii_u64 workbuf_len() const { return wuffs_tga__decoder__workbuf_len(this); @@ -11610,6 +11909,8 @@ extern const char wuffs_wbmp__error__truncated_input[]; // ---------------- Public Consts +#define WUFFS_WBMP__DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE 0 + #define WUFFS_WBMP__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 // ---------------- Struct Declarations @@ -11743,6 +12044,11 @@ wuffs_wbmp__decoder__tell_me_more( wuffs_base__more_information* a_minfo, wuffs_base__io_buffer* a_src); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_wbmp__decoder__history_retain_length( + const wuffs_wbmp__decoder* self); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 wuffs_wbmp__decoder__workbuf_len( @@ -11944,6 +12250,11 @@ struct wuffs_wbmp__decoder__struct { return wuffs_wbmp__decoder__tell_me_more(this, a_dst, a_minfo, a_src); } + inline uint64_t + history_retain_length() const { + return wuffs_wbmp__decoder__history_retain_length(this); + } + inline wuffs_base__range_ii_u64 workbuf_len() const { return wuffs_wbmp__decoder__workbuf_len(this); @@ -12044,7 +12355,7 @@ class Input { virtual ~Input(); virtual IOBuffer* BringsItsOwnIOBuffer(); - virtual std::string CopyIn(IOBuffer* dst) = 0; + virtual std::string CopyIn(IOBuffer* dst, uint64_t history_retain_length) = 0; }; // -------- @@ -12056,7 +12367,7 @@ class FileInput : public Input { public: FileInput(FILE* f); - virtual std::string CopyIn(IOBuffer* dst); + virtual std::string CopyIn(IOBuffer* dst, uint64_t history_retain_length); private: FILE* m_f; @@ -12077,7 +12388,7 @@ class MemoryInput : public Input { MemoryInput(const uint8_t* ptr, size_t len); virtual IOBuffer* BringsItsOwnIOBuffer(); - virtual std::string CopyIn(IOBuffer* dst); + virtual std::string CopyIn(IOBuffer* dst, uint64_t history_retain_length); private: IOBuffer m_io; @@ -13745,6 +14056,34 @@ wuffs_base__image_decoder__get_quirk( return 0; } +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_base__image_decoder__history_retain_length( + const wuffs_base__image_decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + const wuffs_base__vtable* v = &self->private_impl.first_vtable; + int i; + for (i = 0; i < 63; i++) { + if (v->vtable_name == wuffs_base__image_decoder__vtable_name) { + const wuffs_base__image_decoder__func_ptrs* func_ptrs = + (const wuffs_base__image_decoder__func_ptrs*)(v->function_pointers); + return (*func_ptrs->history_retain_length)(self); + } else if (v->vtable_name == NULL) { + break; + } + v++; + } + + return 0; +} + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC uint32_t wuffs_base__image_decoder__num_animation_loops( @@ -14014,6 +14353,34 @@ wuffs_base__io_transformer__get_quirk( return 0; } +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_base__io_transformer__history_retain_length( + const wuffs_base__io_transformer* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + const wuffs_base__vtable* v = &self->private_impl.first_vtable; + int i; + for (i = 0; i < 63; i++) { + if (v->vtable_name == wuffs_base__io_transformer__vtable_name) { + const wuffs_base__io_transformer__func_ptrs* func_ptrs = + (const wuffs_base__io_transformer__func_ptrs*)(v->function_pointers); + return (*func_ptrs->history_retain_length)(self); + } else if (v->vtable_name == NULL) { + break; + } + v++; + } + + return 0; +} + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__status wuffs_base__io_transformer__set_quirk( @@ -14109,35 +14476,6 @@ wuffs_base__io_transformer__workbuf_len( // -------- -WUFFS_BASE__GENERATED_C_CODE -WUFFS_BASE__MAYBE_STATIC uint64_t -wuffs_base__token_decoder__get_quirk( - const wuffs_base__token_decoder* self, - uint32_t a_key) { - if (!self) { - return 0; - } - if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && - (self->private_impl.magic != WUFFS_BASE__DISABLED)) { - return 0; - } - - const wuffs_base__vtable* v = &self->private_impl.first_vtable; - int i; - for (i = 0; i < 63; i++) { - if (v->vtable_name == wuffs_base__token_decoder__vtable_name) { - const wuffs_base__token_decoder__func_ptrs* func_ptrs = - (const wuffs_base__token_decoder__func_ptrs*)(v->function_pointers); - return (*func_ptrs->get_quirk)(self, a_key); - } else if (v->vtable_name == NULL) { - break; - } - v++; - } - - return 0; -} - WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__status wuffs_base__token_decoder__decode_tokens( @@ -14171,6 +14509,63 @@ wuffs_base__token_decoder__decode_tokens( return wuffs_base__make_status(wuffs_base__error__bad_vtable); } +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_base__token_decoder__get_quirk( + const wuffs_base__token_decoder* self, + uint32_t a_key) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + const wuffs_base__vtable* v = &self->private_impl.first_vtable; + int i; + for (i = 0; i < 63; i++) { + if (v->vtable_name == wuffs_base__token_decoder__vtable_name) { + const wuffs_base__token_decoder__func_ptrs* func_ptrs = + (const wuffs_base__token_decoder__func_ptrs*)(v->function_pointers); + return (*func_ptrs->get_quirk)(self, a_key); + } else if (v->vtable_name == NULL) { + break; + } + v++; + } + + return 0; +} + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_base__token_decoder__history_retain_length( + const wuffs_base__token_decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + const wuffs_base__vtable* v = &self->private_impl.first_vtable; + int i; + for (i = 0; i < 63; i++) { + if (v->vtable_name == wuffs_base__token_decoder__vtable_name) { + const wuffs_base__token_decoder__func_ptrs* func_ptrs = + (const wuffs_base__token_decoder__func_ptrs*)(v->function_pointers); + return (*func_ptrs->history_retain_length)(self); + } else if (v->vtable_name == NULL) { + break; + } + v++; + } + + return 0; +} + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__status wuffs_base__token_decoder__set_quirk( @@ -26456,6 +26851,7 @@ wuffs_bmp__decoder__func_ptrs_for__wuffs_base__image_decoder = { (wuffs_base__rect_ie_u32(*)(const void*))(&wuffs_bmp__decoder__frame_dirty_rect), (uint64_t(*)(const void*, uint32_t))(&wuffs_bmp__decoder__get_quirk), + (uint64_t(*)(const void*))(&wuffs_bmp__decoder__history_retain_length), (uint32_t(*)(const void*))(&wuffs_bmp__decoder__num_animation_loops), (uint64_t(*)(const void*))(&wuffs_bmp__decoder__num_decoded_frame_configs), (uint64_t(*)(const void*))(&wuffs_bmp__decoder__num_decoded_frames), @@ -28899,6 +29295,23 @@ wuffs_bmp__decoder__do_tell_me_more( return status; } +// -------- func bmp.decoder.history_retain_length + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_bmp__decoder__history_retain_length( + const wuffs_bmp__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + return 0u; +} + // -------- func bmp.decoder.workbuf_len WUFFS_BASE__GENERATED_C_CODE @@ -29229,6 +29642,7 @@ const wuffs_base__io_transformer__func_ptrs wuffs_bzip2__decoder__func_ptrs_for__wuffs_base__io_transformer = { (uint64_t(*)(const void*, uint32_t))(&wuffs_bzip2__decoder__get_quirk), + (uint64_t(*)(const void*))(&wuffs_bzip2__decoder__history_retain_length), (wuffs_base__status(*)(void*, uint32_t, uint64_t))(&wuffs_bzip2__decoder__set_quirk), @@ -29353,6 +29767,23 @@ wuffs_bzip2__decoder__set_quirk( return wuffs_base__make_status(wuffs_base__error__unsupported_option); } +// -------- func bzip2.decoder.history_retain_length + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_bzip2__decoder__history_retain_length( + const wuffs_bzip2__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + return 0u; +} + // -------- func bzip2.decoder.workbuf_len WUFFS_BASE__GENERATED_C_CODE @@ -30765,12 +31196,13 @@ WUFFS_CBOR__TOKEN_LENGTHS[32] WUFFS_BASE__POTENTIALLY_UNUSED = { const wuffs_base__token_decoder__func_ptrs wuffs_cbor__decoder__func_ptrs_for__wuffs_base__token_decoder = { - (uint64_t(*)(const void*, - uint32_t))(&wuffs_cbor__decoder__get_quirk), (wuffs_base__status(*)(void*, wuffs_base__token_buffer*, wuffs_base__io_buffer*, wuffs_base__slice_u8))(&wuffs_cbor__decoder__decode_tokens), + (uint64_t(*)(const void*, + uint32_t))(&wuffs_cbor__decoder__get_quirk), + (uint64_t(*)(const void*))(&wuffs_cbor__decoder__history_retain_length), (wuffs_base__status(*)(void*, uint32_t, uint64_t))(&wuffs_cbor__decoder__set_quirk), @@ -30887,6 +31319,23 @@ wuffs_cbor__decoder__set_quirk( return wuffs_base__make_status(wuffs_base__error__unsupported_option); } +// -------- func cbor.decoder.history_retain_length + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_cbor__decoder__history_retain_length( + const wuffs_cbor__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + return 0u; +} + // -------- func cbor.decoder.workbuf_len WUFFS_BASE__GENERATED_C_CODE @@ -32859,6 +33308,7 @@ const wuffs_base__io_transformer__func_ptrs wuffs_deflate__decoder__func_ptrs_for__wuffs_base__io_transformer = { (uint64_t(*)(const void*, uint32_t))(&wuffs_deflate__decoder__get_quirk), + (uint64_t(*)(const void*))(&wuffs_deflate__decoder__history_retain_length), (wuffs_base__status(*)(void*, uint32_t, uint64_t))(&wuffs_deflate__decoder__set_quirk), @@ -33022,6 +33472,23 @@ wuffs_deflate__decoder__set_quirk( return wuffs_base__make_status(wuffs_base__error__unsupported_option); } +// -------- func deflate.decoder.history_retain_length + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_deflate__decoder__history_retain_length( + const wuffs_deflate__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + return 0u; +} + // -------- func deflate.decoder.workbuf_len WUFFS_BASE__GENERATED_C_CODE @@ -35250,6 +35717,7 @@ wuffs_gif__decoder__func_ptrs_for__wuffs_base__image_decoder = { (wuffs_base__rect_ie_u32(*)(const void*))(&wuffs_gif__decoder__frame_dirty_rect), (uint64_t(*)(const void*, uint32_t))(&wuffs_gif__decoder__get_quirk), + (uint64_t(*)(const void*))(&wuffs_gif__decoder__history_retain_length), (uint32_t(*)(const void*))(&wuffs_gif__decoder__num_animation_loops), (uint64_t(*)(const void*))(&wuffs_gif__decoder__num_decoded_frame_configs), (uint64_t(*)(const void*))(&wuffs_gif__decoder__num_decoded_frames), @@ -35829,6 +36297,23 @@ wuffs_gif__decoder__frame_dirty_rect( wuffs_base__u32__min(self->private_impl.f_dirty_max_excl_y, self->private_impl.f_height)); } +// -------- func gif.decoder.history_retain_length + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_gif__decoder__history_retain_length( + const wuffs_gif__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + return 0u; +} + // -------- func gif.decoder.workbuf_len WUFFS_BASE__GENERATED_C_CODE @@ -38150,6 +38635,7 @@ const wuffs_base__io_transformer__func_ptrs wuffs_gzip__decoder__func_ptrs_for__wuffs_base__io_transformer = { (uint64_t(*)(const void*, uint32_t))(&wuffs_gzip__decoder__get_quirk), + (uint64_t(*)(const void*))(&wuffs_gzip__decoder__history_retain_length), (wuffs_base__status(*)(void*, uint32_t, uint64_t))(&wuffs_gzip__decoder__set_quirk), @@ -38291,6 +38777,23 @@ wuffs_gzip__decoder__set_quirk( return wuffs_base__make_status(wuffs_base__error__unsupported_option); } +// -------- func gzip.decoder.history_retain_length + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_gzip__decoder__history_retain_length( + const wuffs_gzip__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + return 0u; +} + // -------- func gzip.decoder.workbuf_len WUFFS_BASE__GENERATED_C_CODE @@ -39220,6 +39723,7 @@ wuffs_jpeg__decoder__func_ptrs_for__wuffs_base__image_decoder = { (wuffs_base__rect_ie_u32(*)(const void*))(&wuffs_jpeg__decoder__frame_dirty_rect), (uint64_t(*)(const void*, uint32_t))(&wuffs_jpeg__decoder__get_quirk), + (uint64_t(*)(const void*))(&wuffs_jpeg__decoder__history_retain_length), (uint32_t(*)(const void*))(&wuffs_jpeg__decoder__num_animation_loops), (uint64_t(*)(const void*))(&wuffs_jpeg__decoder__num_decoded_frame_configs), (uint64_t(*)(const void*))(&wuffs_jpeg__decoder__num_decoded_frames), @@ -43889,6 +44393,23 @@ wuffs_jpeg__decoder__tell_me_more( return status; } +// -------- func jpeg.decoder.history_retain_length + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_jpeg__decoder__history_retain_length( + const wuffs_jpeg__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + return 0u; +} + // -------- func jpeg.decoder.workbuf_len WUFFS_BASE__GENERATED_C_CODE @@ -45677,12 +46198,13 @@ wuffs_json__decoder__decode_trailer( const wuffs_base__token_decoder__func_ptrs wuffs_json__decoder__func_ptrs_for__wuffs_base__token_decoder = { - (uint64_t(*)(const void*, - uint32_t))(&wuffs_json__decoder__get_quirk), (wuffs_base__status(*)(void*, wuffs_base__token_buffer*, wuffs_base__io_buffer*, wuffs_base__slice_u8))(&wuffs_json__decoder__decode_tokens), + (uint64_t(*)(const void*, + uint32_t))(&wuffs_json__decoder__get_quirk), + (uint64_t(*)(const void*))(&wuffs_json__decoder__history_retain_length), (wuffs_base__status(*)(void*, uint32_t, uint64_t))(&wuffs_json__decoder__set_quirk), @@ -45816,6 +46338,23 @@ wuffs_json__decoder__set_quirk( return wuffs_base__make_status(wuffs_base__error__unsupported_option); } +// -------- func json.decoder.history_retain_length + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_json__decoder__history_retain_length( + const wuffs_json__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + return 0u; +} + // -------- func json.decoder.workbuf_len WUFFS_BASE__GENERATED_C_CODE @@ -47648,6 +48187,7 @@ const wuffs_base__io_transformer__func_ptrs wuffs_lzw__decoder__func_ptrs_for__wuffs_base__io_transformer = { (uint64_t(*)(const void*, uint32_t))(&wuffs_lzw__decoder__get_quirk), + (uint64_t(*)(const void*))(&wuffs_lzw__decoder__history_retain_length), (wuffs_base__status(*)(void*, uint32_t, uint64_t))(&wuffs_lzw__decoder__set_quirk), @@ -47778,6 +48318,23 @@ wuffs_lzw__decoder__set_quirk( return wuffs_base__make_status(wuffs_base__error__unsupported_option); } +// -------- func lzw.decoder.history_retain_length + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_lzw__decoder__history_retain_length( + const wuffs_lzw__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + return 0u; +} + // -------- func lzw.decoder.workbuf_len WUFFS_BASE__GENERATED_C_CODE @@ -48238,6 +48795,7 @@ wuffs_netpbm__decoder__func_ptrs_for__wuffs_base__image_decoder = { (wuffs_base__rect_ie_u32(*)(const void*))(&wuffs_netpbm__decoder__frame_dirty_rect), (uint64_t(*)(const void*, uint32_t))(&wuffs_netpbm__decoder__get_quirk), + (uint64_t(*)(const void*))(&wuffs_netpbm__decoder__history_retain_length), (uint32_t(*)(const void*))(&wuffs_netpbm__decoder__num_animation_loops), (uint64_t(*)(const void*))(&wuffs_netpbm__decoder__num_decoded_frame_configs), (uint64_t(*)(const void*))(&wuffs_netpbm__decoder__num_decoded_frames), @@ -49294,6 +49852,23 @@ wuffs_netpbm__decoder__tell_me_more( return status; } +// -------- func netpbm.decoder.history_retain_length + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_netpbm__decoder__history_retain_length( + const wuffs_netpbm__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + return 0u; +} + // -------- func netpbm.decoder.workbuf_len WUFFS_BASE__GENERATED_C_CODE @@ -49378,6 +49953,7 @@ wuffs_nie__decoder__func_ptrs_for__wuffs_base__image_decoder = { (wuffs_base__rect_ie_u32(*)(const void*))(&wuffs_nie__decoder__frame_dirty_rect), (uint64_t(*)(const void*, uint32_t))(&wuffs_nie__decoder__get_quirk), + (uint64_t(*)(const void*))(&wuffs_nie__decoder__history_retain_length), (uint32_t(*)(const void*))(&wuffs_nie__decoder__num_animation_loops), (uint64_t(*)(const void*))(&wuffs_nie__decoder__num_decoded_frame_configs), (uint64_t(*)(const void*))(&wuffs_nie__decoder__num_decoded_frames), @@ -50354,6 +50930,23 @@ wuffs_nie__decoder__tell_me_more( return status; } +// -------- func nie.decoder.history_retain_length + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_nie__decoder__history_retain_length( + const wuffs_nie__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + return 0u; +} + // -------- func nie.decoder.workbuf_len WUFFS_BASE__GENERATED_C_CODE @@ -50409,6 +51002,7 @@ const wuffs_base__io_transformer__func_ptrs wuffs_zlib__decoder__func_ptrs_for__wuffs_base__io_transformer = { (uint64_t(*)(const void*, uint32_t))(&wuffs_zlib__decoder__get_quirk), + (uint64_t(*)(const void*))(&wuffs_zlib__decoder__history_retain_length), (wuffs_base__status(*)(void*, uint32_t, uint64_t))(&wuffs_zlib__decoder__set_quirk), @@ -50616,6 +51210,23 @@ wuffs_zlib__decoder__set_quirk( return wuffs_base__make_status(wuffs_base__error__unsupported_option); } +// -------- func zlib.decoder.history_retain_length + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_zlib__decoder__history_retain_length( + const wuffs_zlib__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + return 0u; +} + // -------- func zlib.decoder.workbuf_len WUFFS_BASE__GENERATED_C_CODE @@ -51354,6 +51965,7 @@ wuffs_png__decoder__func_ptrs_for__wuffs_base__image_decoder = { (wuffs_base__rect_ie_u32(*)(const void*))(&wuffs_png__decoder__frame_dirty_rect), (uint64_t(*)(const void*, uint32_t))(&wuffs_png__decoder__get_quirk), + (uint64_t(*)(const void*))(&wuffs_png__decoder__history_retain_length), (uint32_t(*)(const void*))(&wuffs_png__decoder__num_animation_loops), (uint64_t(*)(const void*))(&wuffs_png__decoder__num_decoded_frame_configs), (uint64_t(*)(const void*))(&wuffs_png__decoder__num_decoded_frames), @@ -57078,6 +57690,23 @@ wuffs_png__decoder__do_tell_me_more( return status; } +// -------- func png.decoder.history_retain_length + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_png__decoder__history_retain_length( + const wuffs_png__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + return 0u; +} + // -------- func png.decoder.workbuf_len WUFFS_BASE__GENERATED_C_CODE @@ -57521,6 +58150,7 @@ wuffs_tga__decoder__func_ptrs_for__wuffs_base__image_decoder = { (wuffs_base__rect_ie_u32(*)(const void*))(&wuffs_tga__decoder__frame_dirty_rect), (uint64_t(*)(const void*, uint32_t))(&wuffs_tga__decoder__get_quirk), + (uint64_t(*)(const void*))(&wuffs_tga__decoder__history_retain_length), (uint32_t(*)(const void*))(&wuffs_tga__decoder__num_animation_loops), (uint64_t(*)(const void*))(&wuffs_tga__decoder__num_decoded_frame_configs), (uint64_t(*)(const void*))(&wuffs_tga__decoder__num_decoded_frames), @@ -58882,6 +59512,23 @@ wuffs_tga__decoder__tell_me_more( return status; } +// -------- func tga.decoder.history_retain_length + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_tga__decoder__history_retain_length( + const wuffs_tga__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + return 0u; +} + // -------- func tga.decoder.workbuf_len WUFFS_BASE__GENERATED_C_CODE @@ -58957,6 +59604,7 @@ wuffs_wbmp__decoder__func_ptrs_for__wuffs_base__image_decoder = { (wuffs_base__rect_ie_u32(*)(const void*))(&wuffs_wbmp__decoder__frame_dirty_rect), (uint64_t(*)(const void*, uint32_t))(&wuffs_wbmp__decoder__get_quirk), + (uint64_t(*)(const void*))(&wuffs_wbmp__decoder__history_retain_length), (uint32_t(*)(const void*))(&wuffs_wbmp__decoder__num_animation_loops), (uint64_t(*)(const void*))(&wuffs_wbmp__decoder__num_decoded_frame_configs), (uint64_t(*)(const void*))(&wuffs_wbmp__decoder__num_decoded_frames), @@ -59804,6 +60452,23 @@ wuffs_wbmp__decoder__tell_me_more( return status; } +// -------- func wbmp.decoder.history_retain_length + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_wbmp__decoder__history_retain_length( + const wuffs_wbmp__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + return 0u; +} + // -------- func wbmp.decoder.workbuf_len WUFFS_BASE__GENERATED_C_CODE @@ -59915,7 +60580,7 @@ Input::BringsItsOwnIOBuffer() { FileInput::FileInput(FILE* f) : m_f(f) {} std::string // -FileInput::CopyIn(IOBuffer* dst) { +FileInput::CopyIn(IOBuffer* dst, uint64_t history_retain_length) { if (!m_f) { return "wuffs_aux::sync_io::FileInput: nullptr file"; } else if (!dst) { @@ -59923,7 +60588,7 @@ FileInput::CopyIn(IOBuffer* dst) { } else if (dst->meta.closed) { return "wuffs_aux::sync_io::FileInput: end of file"; } else { - dst->compact(); + dst->compact_retaining(history_retain_length); size_t n = fread(dst->writer_pointer(), 1, dst->writer_length(), m_f); dst->meta.wi += n; dst->meta.closed = feof(m_f); @@ -59951,7 +60616,7 @@ MemoryInput::BringsItsOwnIOBuffer() { } std::string // -MemoryInput::CopyIn(IOBuffer* dst) { +MemoryInput::CopyIn(IOBuffer* dst, uint64_t history_retain_length) { if (!dst) { return "wuffs_aux::sync_io::MemoryInput: nullptr IOBuffer"; } else if (dst->meta.closed) { @@ -59961,7 +60626,7 @@ MemoryInput::CopyIn(IOBuffer* dst) { // to it. return "wuffs_aux::sync_io::MemoryInput: overlapping buffers"; } else { - dst->compact(); + dst->compact_retaining(history_retain_length); size_t nd = dst->writer_length(); size_t ns = m_io.reader_length(); size_t n = (nd < ns) ? nd : ns; @@ -60016,7 +60681,7 @@ AdvanceIOBufferTo(const ErrorMessages& error_messages, if (!input.BringsItsOwnIOBuffer()) { io_buf.compact(); } - std::string error_message = input.CopyIn(&io_buf); + std::string error_message = input.CopyIn(&io_buf, 0); if (!error_message.empty()) { return error_message; } @@ -60099,7 +60764,7 @@ HandleMetadata( } else if (!input.BringsItsOwnIOBuffer()) { io_buf.compact(); } - std::string error_message = input.CopyIn(&io_buf); + std::string error_message = input.CopyIn(&io_buf, 0); if (!error_message.empty()) { return error_message; } @@ -60243,14 +60908,14 @@ DecodeCbor(DecodeCborCallbacks& callbacks, "wuffs_aux::DecodeCbor: internal error: io_buf is closed"; goto done; } - io_buf->compact(); + io_buf->compact_retaining(dec->history_retain_length()); if (io_buf->meta.wi >= io_buf->data.len) { ret_error_message = "wuffs_aux::DecodeCbor: internal error: io_buf is full"; goto done; } cursor_index = io_buf->meta.ri; - io_error_message = input.CopyIn(io_buf); + io_error_message = input.CopyIn(io_buf, dec->history_retain_length()); } else { ret_error_message = tok_status.message(); goto done; @@ -60834,7 +61499,7 @@ redirect: fourcc = 0; break; } - std::string error_message = input.CopyIn(&io_buf); + std::string error_message = input.CopyIn(&io_buf, 0); if (!error_message.empty()) { return DecodeImageResult(std::move(error_message)); } @@ -60930,7 +61595,8 @@ redirect: } else if (io_buf.meta.closed) { return DecodeImageResult(DecodeImage_UnexpectedEndOfFile); } else { - std::string error_message = input.CopyIn(&io_buf); + std::string error_message = + input.CopyIn(&io_buf, image_decoder->history_retain_length()); if (!error_message.empty()) { return DecodeImageResult(std::move(error_message)); } @@ -61012,7 +61678,8 @@ redirect: } else if (io_buf.meta.closed) { return DecodeImageResult(DecodeImage_UnexpectedEndOfFile); } else { - std::string error_message = input.CopyIn(&io_buf); + std::string error_message = + input.CopyIn(&io_buf, image_decoder->history_retain_length()); if (!error_message.empty()) { return DecodeImageResult(std::move(error_message)); } @@ -61041,7 +61708,8 @@ redirect: message = DecodeImage_UnexpectedEndOfFile; break; } else { - std::string error_message = input.CopyIn(&io_buf); + std::string error_message = + input.CopyIn(&io_buf, image_decoder->history_retain_length()); if (!error_message.empty()) { message = std::move(error_message); break; @@ -61069,7 +61737,8 @@ redirect: } else if (io_buf.meta.closed) { return DecodeImageResult(DecodeImage_UnexpectedEndOfFile); } else { - std::string error_message = input.CopyIn(&io_buf); + std::string error_message = + input.CopyIn(&io_buf, image_decoder->history_retain_length()); if (!error_message.empty()) { return DecodeImageResult(std::move(error_message)); } @@ -61162,58 +61831,58 @@ DecodeJsonArgJsonPointer::DefaultValue() { // -------- -#define WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN \ - while (tok_buf.meta.ri >= tok_buf.meta.wi) { \ - if (tok_status.repr == nullptr) { \ - goto done; \ - } else if (tok_status.repr == wuffs_base__suspension__short_write) { \ - tok_buf.compact(); \ - } else if (tok_status.repr == wuffs_base__suspension__short_read) { \ - if (!io_error_message.empty()) { \ - ret_error_message = std::move(io_error_message); \ - goto done; \ - } else if (cursor_index != io_buf->meta.ri) { \ - ret_error_message = \ - "wuffs_aux::DecodeJson: internal error: bad cursor_index"; \ - goto done; \ - } else if (io_buf->meta.closed) { \ - ret_error_message = \ - "wuffs_aux::DecodeJson: internal error: io_buf is closed"; \ - goto done; \ - } \ - io_buf->compact(); \ - if (io_buf->meta.wi >= io_buf->data.len) { \ - ret_error_message = \ - "wuffs_aux::DecodeJson: internal error: io_buf is full"; \ - goto done; \ - } \ - cursor_index = io_buf->meta.ri; \ - io_error_message = input.CopyIn(io_buf); \ - } else { \ - ret_error_message = tok_status.message(); \ - goto done; \ - } \ - tok_status = \ - dec->decode_tokens(&tok_buf, io_buf, wuffs_base__empty_slice_u8()); \ - if ((tok_buf.meta.ri > tok_buf.meta.wi) || \ - (tok_buf.meta.wi > tok_buf.data.len) || \ - (io_buf->meta.ri > io_buf->meta.wi) || \ - (io_buf->meta.wi > io_buf->data.len)) { \ - ret_error_message = \ - "wuffs_aux::DecodeJson: internal error: bad buffer indexes"; \ - goto done; \ - } \ - } \ - wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++]; \ - uint64_t token_len = token.length(); \ - if ((io_buf->meta.ri < cursor_index) || \ - ((io_buf->meta.ri - cursor_index) < token_len)) { \ - ret_error_message = \ - "wuffs_aux::DecodeJson: internal error: bad token indexes"; \ - goto done; \ - } \ - uint8_t* token_ptr = io_buf->data.ptr + cursor_index; \ - (void)(token_ptr); \ +#define WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN \ + while (tok_buf.meta.ri >= tok_buf.meta.wi) { \ + if (tok_status.repr == nullptr) { \ + goto done; \ + } else if (tok_status.repr == wuffs_base__suspension__short_write) { \ + tok_buf.compact(); \ + } else if (tok_status.repr == wuffs_base__suspension__short_read) { \ + if (!io_error_message.empty()) { \ + ret_error_message = std::move(io_error_message); \ + goto done; \ + } else if (cursor_index != io_buf->meta.ri) { \ + ret_error_message = \ + "wuffs_aux::DecodeJson: internal error: bad cursor_index"; \ + goto done; \ + } else if (io_buf->meta.closed) { \ + ret_error_message = \ + "wuffs_aux::DecodeJson: internal error: io_buf is closed"; \ + goto done; \ + } \ + io_buf->compact_retaining(dec->history_retain_length()); \ + if (io_buf->meta.wi >= io_buf->data.len) { \ + ret_error_message = \ + "wuffs_aux::DecodeJson: internal error: io_buf is full"; \ + goto done; \ + } \ + cursor_index = io_buf->meta.ri; \ + io_error_message = input.CopyIn(io_buf, dec->history_retain_length()); \ + } else { \ + ret_error_message = tok_status.message(); \ + goto done; \ + } \ + tok_status = \ + dec->decode_tokens(&tok_buf, io_buf, wuffs_base__empty_slice_u8()); \ + if ((tok_buf.meta.ri > tok_buf.meta.wi) || \ + (tok_buf.meta.wi > tok_buf.data.len) || \ + (io_buf->meta.ri > io_buf->meta.wi) || \ + (io_buf->meta.wi > io_buf->data.len)) { \ + ret_error_message = \ + "wuffs_aux::DecodeJson: internal error: bad buffer indexes"; \ + goto done; \ + } \ + } \ + wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++]; \ + uint64_t token_len = token.length(); \ + if ((io_buf->meta.ri < cursor_index) || \ + ((io_buf->meta.ri - cursor_index) < token_len)) { \ + ret_error_message = \ + "wuffs_aux::DecodeJson: internal error: bad token indexes"; \ + goto done; \ + } \ + uint8_t* token_ptr = io_buf->data.ptr + cursor_index; \ + (void)(token_ptr); \ cursor_index += static_cast(token_len) // -------- diff --git a/std/bmp/decode_bmp.wuffs b/std/bmp/decode_bmp.wuffs index 61780c84..3fa44aed 100644 --- a/std/bmp/decode_bmp.wuffs +++ b/std/bmp/decode_bmp.wuffs @@ -19,7 +19,8 @@ pub status "#unsupported BMP file" pri status "@internal note: short read" -pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0 +pub const DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE : base.u64 = 0 +pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0 pri const COMPRESSION_NONE : base.u32 = 0 pri const COMPRESSION_RLE8 : base.u32 = 1 @@ -1260,6 +1261,10 @@ pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inf this.io_redirect_fourcc = 1 } +pub func decoder.history_retain_length() base.u64 { + return 0 +} + pub func decoder.workbuf_len() base.range_ii_u64 { return this.util.make_range_ii_u64(min_incl: 0, max_incl: 0) } diff --git a/std/bzip2/decode_bzip2.wuffs b/std/bzip2/decode_bzip2.wuffs index b0db086e..760f83ba 100644 --- a/std/bzip2/decode_bzip2.wuffs +++ b/std/bzip2/decode_bzip2.wuffs @@ -24,7 +24,8 @@ pub status "#unsupported block randomization" pri status "#internal error: inconsistent Huffman decoder state" -pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0 +pub const DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE : base.u64 = 0 +pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0 pri const CLAMP_TO_5 : roarray[8] base.u8[..= 5] = [0, 1, 2, 3, 4, 5, 5, 5] @@ -121,6 +122,10 @@ pub func decoder.set_quirk!(key: base.u32, value: base.u64) base.status { return base."#unsupported option" } +pub func decoder.history_retain_length() base.u64 { + return 0 +} + pub func decoder.workbuf_len() base.range_ii_u64 { return this.util.make_range_ii_u64( min_incl: DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE, diff --git a/std/cbor/decode_cbor.wuffs b/std/cbor/decode_cbor.wuffs index 475e367f..bafa1b7c 100644 --- a/std/cbor/decode_cbor.wuffs +++ b/std/cbor/decode_cbor.wuffs @@ -20,6 +20,10 @@ pri status "#internal error: inconsistent token length" // -------- +// DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE is the largest +// history_retain_length (for compact_retaining) that a decoder will request. +pub const DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE : base.u64 = 0 + // DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE is the largest workbuf length that a // decoder will request. pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0 @@ -121,6 +125,10 @@ pub func decoder.set_quirk!(key: base.u32, value: base.u64) base.status { return base."#unsupported option" } +pub func decoder.history_retain_length() base.u64 { + return 0 +} + pub func decoder.workbuf_len() base.range_ii_u64 { return this.util.empty_range_ii_u64() } diff --git a/std/deflate/decode_deflate.wuffs b/std/deflate/decode_deflate.wuffs index 933403d2..a78ec5b9 100644 --- a/std/deflate/decode_deflate.wuffs +++ b/std/deflate/decode_deflate.wuffs @@ -32,6 +32,8 @@ pri status "#internal error: inconsistent I/O" pri status "#internal error: inconsistent distance" pri status "#internal error: inconsistent n_bits" +pub const DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE : base.u64 = 0 + // TODO: replace the placeholder 1 value with either 0 or (32768 + 512), // depending on whether we'll move decoder.history into the workbuf. pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 1 @@ -207,6 +209,10 @@ pub func decoder.set_quirk!(key: base.u32, value: base.u64) base.status { return base."#unsupported option" } +pub func decoder.history_retain_length() base.u64 { + return 0 +} + pub func decoder.workbuf_len() base.range_ii_u64 { return this.util.make_range_ii_u64( min_incl: DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE, diff --git a/std/gif/common_consts.wuffs b/std/gif/common_consts.wuffs index d78c3867..dcae73c3 100644 --- a/std/gif/common_consts.wuffs +++ b/std/gif/common_consts.wuffs @@ -23,7 +23,8 @@ pub status "#truncated input" pri status "#internal error: inconsistent I/O" -pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0 +pub const DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE : base.u64 = 0 +pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0 // See the spec appendix E "Interlaced Images" on page 29. The first element // represents either that the frame was non-interlaced, or that all interlace diff --git a/std/gif/decode_gif.wuffs b/std/gif/decode_gif.wuffs index bebcb069..9fac5fc5 100644 --- a/std/gif/decode_gif.wuffs +++ b/std/gif/decode_gif.wuffs @@ -337,6 +337,10 @@ pub func decoder.frame_dirty_rect() base.rect_ie_u32 { max_excl_y: this.dirty_max_excl_y.min(no_more_than: this.height)) } +pub func decoder.history_retain_length() base.u64 { + return 0 +} + pub func decoder.workbuf_len() base.range_ii_u64 { return this.util.make_range_ii_u64( min_incl: DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE, diff --git a/std/gzip/decode_gzip.wuffs b/std/gzip/decode_gzip.wuffs index a3fde7ff..e330ecd3 100644 --- a/std/gzip/decode_gzip.wuffs +++ b/std/gzip/decode_gzip.wuffs @@ -21,6 +21,8 @@ pub status "#bad encoding flags" pub status "#bad header" pub status "#truncated input" +pub const DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE : base.u64 = 0 + // TODO: reference deflate.DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE. pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 1 @@ -48,6 +50,10 @@ pub func decoder.set_quirk!(key: base.u32, value: base.u64) base.status { return base."#unsupported option" } +pub func decoder.history_retain_length() base.u64 { + return 0 +} + pub func decoder.workbuf_len() base.range_ii_u64 { return this.util.make_range_ii_u64( min_incl: DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE, diff --git a/std/jpeg/decode_jpeg.wuffs b/std/jpeg/decode_jpeg.wuffs index c5c4ceec..03d88f9f 100644 --- a/std/jpeg/decode_jpeg.wuffs +++ b/std/jpeg/decode_jpeg.wuffs @@ -36,7 +36,8 @@ pub status "#unsupported scan count" pri status "#internal error: inconsistent decoder state" -pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0xC_00C0_0300 +pub const DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE : base.u64 = 0 +pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0xC_00C0_0300 pub struct decoder? implements base.image_decoder( width : base.u32[..= 0xFFFF], @@ -2110,6 +2111,10 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform return base."#no more information" } +pub func decoder.history_retain_length() base.u64 { + return 0 +} + pub func decoder.workbuf_len() base.range_ii_u64 { return this.util.make_range_ii_u64( min_incl: this.components_workbuf_offsets[8], diff --git a/std/json/common_consts.wuffs b/std/json/common_consts.wuffs index 3b9c315a..4d9b928a 100644 --- a/std/json/common_consts.wuffs +++ b/std/json/common_consts.wuffs @@ -25,6 +25,10 @@ pri status "#internal error: inconsistent I/O" // -------- +// DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE is the largest +// history_retain_length (for compact_retaining) that a decoder will request. +pub const DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE : base.u64 = 0 + // DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE is the largest workbuf length that a // decoder will request. pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0 diff --git a/std/json/decode_json.wuffs b/std/json/decode_json.wuffs index a0e2b2a5..4ed75da7 100644 --- a/std/json/decode_json.wuffs +++ b/std/json/decode_json.wuffs @@ -86,6 +86,10 @@ pub func decoder.set_quirk!(key: base.u32, value: base.u64) base.status { return base."#unsupported option" } +pub func decoder.history_retain_length() base.u64 { + return 0 +} + pub func decoder.workbuf_len() base.range_ii_u64 { return this.util.empty_range_ii_u64() } diff --git a/std/lzw/decode_lzw.wuffs b/std/lzw/decode_lzw.wuffs index 75f75e67..f4e0c9b4 100644 --- a/std/lzw/decode_lzw.wuffs +++ b/std/lzw/decode_lzw.wuffs @@ -17,6 +17,8 @@ pub status "#truncated input" pri status "#internal error: inconsistent I/O" +pub const DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE : base.u64 = 0 + // TODO: move bulk data buffers like decoder.suffixes or decoder.output into // the workbuf? The first attempt at this was a performance regression for // decoding all but the smallest GIFs. See these git commits for numbers: @@ -88,6 +90,10 @@ pub func decoder.set_quirk!(key: base.u32, value: base.u64) base.status { return base."#unsupported option" } +pub func decoder.history_retain_length() base.u64 { + return 0 +} + pub func decoder.workbuf_len() base.range_ii_u64 { return this.util.make_range_ii_u64(min_incl: 0, max_incl: 0) } diff --git a/std/netpbm/decode_netpbm.wuffs b/std/netpbm/decode_netpbm.wuffs index 7dd8b978..9f9edda4 100644 --- a/std/netpbm/decode_netpbm.wuffs +++ b/std/netpbm/decode_netpbm.wuffs @@ -18,7 +18,8 @@ pub status "#unsupported Netpbm file" pri status "@internal note: short read" -pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0 +pub const DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE : base.u64 = 0 +pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0 pub struct decoder? implements base.image_decoder( pixfmt : base.u32, @@ -432,6 +433,10 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform return base."#no more information" } +pub func decoder.history_retain_length() base.u64 { + return 0 +} + pub func decoder.workbuf_len() base.range_ii_u64 { return this.util.make_range_ii_u64(min_incl: 0, max_incl: 0) } diff --git a/std/nie/decode_nie.wuffs b/std/nie/decode_nie.wuffs index 8d190df6..fa06d0ce 100644 --- a/std/nie/decode_nie.wuffs +++ b/std/nie/decode_nie.wuffs @@ -18,7 +18,8 @@ pub status "#unsupported NIE file" pri status "@internal note: short read" -pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0 +pub const DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE : base.u64 = 0 +pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0 pub struct decoder? implements base.image_decoder( pixfmt : base.u32, @@ -328,6 +329,10 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform return base."#no more information" } +pub func decoder.history_retain_length() base.u64 { + return 0 +} + pub func decoder.workbuf_len() base.range_ii_u64 { return this.util.make_range_ii_u64(min_incl: 0, max_incl: 0) } diff --git a/std/png/common_consts.wuffs b/std/png/common_consts.wuffs index 23d28073..9401d13a 100644 --- a/std/png/common_consts.wuffs +++ b/std/png/common_consts.wuffs @@ -30,7 +30,8 @@ pri status "#internal error: inconsistent frame bounds" pri status "#internal error: inconsistent workbuf length" pri status "#internal error: zlib decoder did not exhaust its input" -pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0x0007_FFFF_F100_0007 +pub const DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE : base.u64 = 0 +pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0x0007_FFFF_F100_0007 // DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL is the minimum length of the src // wuffs_base__io_buffer passed to the decoder. diff --git a/std/png/decode_png.wuffs b/std/png/decode_png.wuffs index 8bb00828..a4120466 100644 --- a/std/png/decode_png.wuffs +++ b/std/png/decode_png.wuffs @@ -1723,6 +1723,10 @@ pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inf return ok } +pub func decoder.history_retain_length() base.u64 { + return 0 +} + pub func decoder.workbuf_len() base.range_ii_u64 { return this.util.make_range_ii_u64( min_incl: this.overall_workbuf_length, diff --git a/std/tga/decode_tga.wuffs b/std/tga/decode_tga.wuffs index 9618501d..09c508da 100644 --- a/std/tga/decode_tga.wuffs +++ b/std/tga/decode_tga.wuffs @@ -17,7 +17,8 @@ pub status "#bad run length encoding" pub status "#truncated input" pub status "#unsupported TGA file" -pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0 +pub const DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE : base.u64 = 0 +pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0 pub struct decoder? implements base.image_decoder( width : base.u32[..= 0xFFFF], @@ -615,6 +616,10 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform return base."#no more information" } +pub func decoder.history_retain_length() base.u64 { + return 0 +} + pub func decoder.workbuf_len() base.range_ii_u64 { return this.util.make_range_ii_u64(min_incl: 0, max_incl: 0) } diff --git a/std/wbmp/decode_wbmp.wuffs b/std/wbmp/decode_wbmp.wuffs index 93a3f2ca..afbfc6a2 100644 --- a/std/wbmp/decode_wbmp.wuffs +++ b/std/wbmp/decode_wbmp.wuffs @@ -15,7 +15,8 @@ pub status "#bad header" pub status "#truncated input" -pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0 +pub const DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE : base.u64 = 0 +pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0 pub struct decoder? implements base.image_decoder( width : base.u32[..= 0xFF_FFFF], @@ -313,6 +314,10 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform return base."#no more information" } +pub func decoder.history_retain_length() base.u64 { + return 0 +} + pub func decoder.workbuf_len() base.range_ii_u64 { return this.util.make_range_ii_u64(min_incl: 0, max_incl: 0) } diff --git a/std/zlib/decode_zlib.wuffs b/std/zlib/decode_zlib.wuffs index ebc309d8..4270a17d 100644 --- a/std/zlib/decode_zlib.wuffs +++ b/std/zlib/decode_zlib.wuffs @@ -24,6 +24,8 @@ pub status "#bad parity check" pub status "#incorrect dictionary" pub status "#truncated input" +pub const DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE : base.u64 = 0 + // TODO: reference deflate.DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE. pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 1 @@ -95,6 +97,10 @@ pub func decoder.set_quirk!(key: base.u32, value: base.u64) base.status { return base."#unsupported option" } +pub func decoder.history_retain_length() base.u64 { + return 0 +} + pub func decoder.workbuf_len() base.range_ii_u64 { return this.util.make_range_ii_u64( min_incl: DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE,