From 71dca5adce5d9459dcdad799a2a544e29324c22b Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Thu, 12 Oct 2023 21:32:59 +1100 Subject: [PATCH] base: add hasher_bitvec256 type --- doc/changelog.md | 2 + doc/std/hashers.md | 5 +- internal/cgen/func.go | 3 + lang/builtin/builtin.go | 20 +- release/c/wuffs-unsupported-snapshot.c | 255 +++++++++++++++++++++++++ 5 files changed, 278 insertions(+), 7 deletions(-) diff --git a/doc/changelog.md b/doc/changelog.md index b30c8ef6..0532bfc1 100644 --- a/doc/changelog.md +++ b/doc/changelog.md @@ -7,6 +7,8 @@ The LICENSE has changed from a single license (Apache 2) to a dual license (Apache 2 or MIT, at your option). - Added `base.bitvec256`. +- Added `base.hasher_bitvec256`. +- Added `base.hasher_u64`. - Added `compact_retaining` and `history_retain_length`. - Added `example/toy-aux-image`. - Added `get_quirk(key: u32) u64`. diff --git a/doc/std/hashers.md b/doc/std/hashers.md index 609f5e43..06fe75f6 100644 --- a/doc/std/hashers.md +++ b/doc/std/hashers.md @@ -36,8 +36,9 @@ In Wuffs syntax, the `base.hasher_u32` methods are: - `update!(x: slice u8)` - `update_u32!(x: slice u8) u32` -The `base.hasher_u64` methods are similar, except for the obvious difference of -calculating a 64-bit (not 32-bit) checksum. +The `base.hasher_u64` and `base.hasher_bitvec256` methods are similar, except +for the obvious difference of calculating a 64-bit or 256-bit (not 32-bit) +checksum. ## Implementations diff --git a/internal/cgen/func.go b/internal/cgen/func.go index 380a0cd7..1da30511 100644 --- a/internal/cgen/func.go +++ b/internal/cgen/func.go @@ -348,6 +348,9 @@ func writeOutParamZeroValue(b *buffer, tm *t.Map, typ *a.TypeExpr) error { } } else if (typ.Decorator() == 0) && (typ.QID()[0] == t.IDBase) { switch typ.QID()[1] { + case t.IDBitvec256: + b.writes("wuffs_base__utility__make_bitvec256(0u, 0u, 0u, 0u)") + return nil case t.IDRangeIEU32: b.writes("wuffs_base__utility__empty_range_ie_u32()") return nil diff --git a/lang/builtin/builtin.go b/lang/builtin/builtin.go index 41d2ae10..cc02bf3f 100644 --- a/lang/builtin/builtin.go +++ b/lang/builtin/builtin.go @@ -942,17 +942,19 @@ var funcsOther = [...]string{ var Interfaces = []string{ "hasher_u32", "hasher_u64", + "hasher_bitvec256", "image_decoder", "io_transformer", "token_decoder", } var InterfacesMap = map[string]bool{ - "hasher_u32": true, - "hasher_u64": true, - "image_decoder": true, - "io_transformer": true, - "token_decoder": true, + "hasher_u32": true, + "hasher_u64": true, + "hasher_bitvec256": true, + "image_decoder": true, + "io_transformer": true, + "token_decoder": true, } var InterfaceFuncs = []string{ @@ -972,6 +974,14 @@ var InterfaceFuncs = []string{ "hasher_u64.update!(x: roslice u8)", "hasher_u64.update_u64!(x: roslice u8) u64", + // ---- hasher_bitvec256 + + "hasher_bitvec256.checksum_bitvec256() bitvec256", + "hasher_bitvec256.get_quirk(key: u32) u64", + "hasher_bitvec256.set_quirk!(key: u32, value: u64) status", + "hasher_bitvec256.update!(x: roslice u8)", + "hasher_bitvec256.update_bitvec256!(x: roslice u8) bitvec256", + // ---- image_decoder "image_decoder.decode_frame?(" + diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index da3852c9..30d5c7dc 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -6222,6 +6222,113 @@ struct wuffs_base__hasher_u64__struct { // -------- +extern const char wuffs_base__hasher_bitvec256__vtable_name[]; + +typedef struct wuffs_base__hasher_bitvec256__func_ptrs__struct { + wuffs_base__bitvec256 (*checksum_bitvec256)( + const void* self); + uint64_t (*get_quirk)( + const void* self, + uint32_t a_key); + wuffs_base__status (*set_quirk)( + void* self, + uint32_t a_key, + uint64_t a_value); + wuffs_base__empty_struct (*update)( + void* self, + wuffs_base__slice_u8 a_x); + wuffs_base__bitvec256 (*update_bitvec256)( + void* self, + wuffs_base__slice_u8 a_x); +} wuffs_base__hasher_bitvec256__func_ptrs; + +typedef struct wuffs_base__hasher_bitvec256__struct wuffs_base__hasher_bitvec256; + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__bitvec256 +wuffs_base__hasher_bitvec256__checksum_bitvec256( + const wuffs_base__hasher_bitvec256* self); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_base__hasher_bitvec256__get_quirk( + const wuffs_base__hasher_bitvec256* self, + uint32_t a_key); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_base__hasher_bitvec256__set_quirk( + wuffs_base__hasher_bitvec256* self, + uint32_t a_key, + uint64_t a_value); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct +wuffs_base__hasher_bitvec256__update( + wuffs_base__hasher_bitvec256* self, + wuffs_base__slice_u8 a_x); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__bitvec256 +wuffs_base__hasher_bitvec256__update_bitvec256( + wuffs_base__hasher_bitvec256* self, + wuffs_base__slice_u8 a_x); + +#if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) + +struct wuffs_base__hasher_bitvec256__struct { + struct { + uint32_t magic; + uint32_t active_coroutine; + wuffs_base__vtable first_vtable; + } private_impl; + +#ifdef __cplusplus +#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) + using unique_ptr = std::unique_ptr; +#endif + + inline wuffs_base__bitvec256 + checksum_bitvec256() const { + return wuffs_base__hasher_bitvec256__checksum_bitvec256(this); + } + + inline uint64_t + get_quirk( + uint32_t a_key) const { + return wuffs_base__hasher_bitvec256__get_quirk( + this, a_key); + } + + inline wuffs_base__status + set_quirk( + uint32_t a_key, + uint64_t a_value) { + return wuffs_base__hasher_bitvec256__set_quirk( + this, a_key, a_value); + } + + inline wuffs_base__empty_struct + update( + wuffs_base__slice_u8 a_x) { + return wuffs_base__hasher_bitvec256__update( + this, a_x); + } + + inline wuffs_base__bitvec256 + update_bitvec256( + wuffs_base__slice_u8 a_x) { + return wuffs_base__hasher_bitvec256__update_bitvec256( + this, a_x); + } + +#endif // __cplusplus +}; // struct wuffs_base__hasher_bitvec256__struct + +#endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) + +// -------- + extern const char wuffs_base__image_decoder__vtable_name[]; typedef struct wuffs_base__image_decoder__func_ptrs__struct { @@ -14443,6 +14550,7 @@ const char wuffs_base__error__too_much_data[] = "#base: too much data"; const char wuffs_base__hasher_u32__vtable_name[] = "{vtable}wuffs_base__hasher_u32"; const char wuffs_base__hasher_u64__vtable_name[] = "{vtable}wuffs_base__hasher_u64"; +const char wuffs_base__hasher_bitvec256__vtable_name[] = "{vtable}wuffs_base__hasher_bitvec256"; const char wuffs_base__image_decoder__vtable_name[] = "{vtable}wuffs_base__image_decoder"; const char wuffs_base__io_transformer__vtable_name[] = "{vtable}wuffs_base__io_transformer"; const char wuffs_base__token_decoder__vtable_name[] = "{vtable}wuffs_base__token_decoder"; @@ -14750,6 +14858,153 @@ wuffs_base__hasher_u64__update_u64( // -------- +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__bitvec256 +wuffs_base__hasher_bitvec256__checksum_bitvec256( + const wuffs_base__hasher_bitvec256* self) { + if (!self) { + return wuffs_base__utility__make_bitvec256(0u, 0u, 0u, 0u); + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return wuffs_base__utility__make_bitvec256(0u, 0u, 0u, 0u); + } + + const wuffs_base__vtable* v = &self->private_impl.first_vtable; + int i; + for (i = 0; i < 63; i++) { + if (v->vtable_name == wuffs_base__hasher_bitvec256__vtable_name) { + const wuffs_base__hasher_bitvec256__func_ptrs* func_ptrs = + (const wuffs_base__hasher_bitvec256__func_ptrs*)(v->function_pointers); + return (*func_ptrs->checksum_bitvec256)(self); + } else if (v->vtable_name == NULL) { + break; + } + v++; + } + + return wuffs_base__utility__make_bitvec256(0u, 0u, 0u, 0u); +} + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_base__hasher_bitvec256__get_quirk( + const wuffs_base__hasher_bitvec256* 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__hasher_bitvec256__vtable_name) { + const wuffs_base__hasher_bitvec256__func_ptrs* func_ptrs = + (const wuffs_base__hasher_bitvec256__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__hasher_bitvec256__set_quirk( + wuffs_base__hasher_bitvec256* self, + uint32_t a_key, + uint64_t a_value) { + if (!self) { + return wuffs_base__make_status(wuffs_base__error__bad_receiver); + } + if (self->private_impl.magic != WUFFS_BASE__MAGIC) { + return wuffs_base__make_status( + (self->private_impl.magic == WUFFS_BASE__DISABLED) + ? wuffs_base__error__disabled_by_previous_error + : wuffs_base__error__initialize_not_called); + } + + const wuffs_base__vtable* v = &self->private_impl.first_vtable; + int i; + for (i = 0; i < 63; i++) { + if (v->vtable_name == wuffs_base__hasher_bitvec256__vtable_name) { + const wuffs_base__hasher_bitvec256__func_ptrs* func_ptrs = + (const wuffs_base__hasher_bitvec256__func_ptrs*)(v->function_pointers); + return (*func_ptrs->set_quirk)(self, a_key, a_value); + } else if (v->vtable_name == NULL) { + break; + } + v++; + } + + return wuffs_base__make_status(wuffs_base__error__bad_vtable); +} + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct +wuffs_base__hasher_bitvec256__update( + wuffs_base__hasher_bitvec256* self, + wuffs_base__slice_u8 a_x) { + if (!self) { + return wuffs_base__make_empty_struct(); + } + if (self->private_impl.magic != WUFFS_BASE__MAGIC) { + return wuffs_base__make_empty_struct(); + } + + const wuffs_base__vtable* v = &self->private_impl.first_vtable; + int i; + for (i = 0; i < 63; i++) { + if (v->vtable_name == wuffs_base__hasher_bitvec256__vtable_name) { + const wuffs_base__hasher_bitvec256__func_ptrs* func_ptrs = + (const wuffs_base__hasher_bitvec256__func_ptrs*)(v->function_pointers); + return (*func_ptrs->update)(self, a_x); + } else if (v->vtable_name == NULL) { + break; + } + v++; + } + + return wuffs_base__make_empty_struct(); +} + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__bitvec256 +wuffs_base__hasher_bitvec256__update_bitvec256( + wuffs_base__hasher_bitvec256* self, + wuffs_base__slice_u8 a_x) { + if (!self) { + return wuffs_base__utility__make_bitvec256(0u, 0u, 0u, 0u); + } + if (self->private_impl.magic != WUFFS_BASE__MAGIC) { + return wuffs_base__utility__make_bitvec256(0u, 0u, 0u, 0u); + } + + const wuffs_base__vtable* v = &self->private_impl.first_vtable; + int i; + for (i = 0; i < 63; i++) { + if (v->vtable_name == wuffs_base__hasher_bitvec256__vtable_name) { + const wuffs_base__hasher_bitvec256__func_ptrs* func_ptrs = + (const wuffs_base__hasher_bitvec256__func_ptrs*)(v->function_pointers); + return (*func_ptrs->update_bitvec256)(self, a_x); + } else if (v->vtable_name == NULL) { + break; + } + v++; + } + + return wuffs_base__utility__make_bitvec256(0u, 0u, 0u, 0u); +} + +// -------- + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__status wuffs_base__image_decoder__decode_frame(