From 80b1988237b95e2ac8c8a86953f3b427ec076669 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Thu, 5 Oct 2023 19:24:50 +1100 Subject: [PATCH] std: add hasher_u32 update!, checksum_u32 methods --- doc/changelog.md | 1 + doc/std/hashers.md | 2 + lang/builtin/builtin.go | 2 + release/c/wuffs-unsupported-snapshot.c | 292 +++++++++++++++++++++++-- std/adler32/common_adler32.wuffs | 10 +- std/crc32/common_crc32.wuffs | 10 +- std/xxhash32/common_xxhash32.wuffs | 7 +- 7 files changed, 299 insertions(+), 25 deletions(-) diff --git a/doc/changelog.md b/doc/changelog.md index eb423e7b..9ee799b3 100644 --- a/doc/changelog.md +++ b/doc/changelog.md @@ -6,6 +6,7 @@ - Added `compact_retaining` and `history_retain_length`. - Added `example/toy-aux-image`. - Added `get_quirk(key: u32) u64`. +- Added `hasher_u32` `update!` and `checksum_u32` methods - Added `if.likely` and `if.unlikely`. - Added `slice_var as nptr array[etc] etc` conversion. - Added `std/jpeg`. diff --git a/doc/std/hashers.md b/doc/std/hashers.md index 339bc316..03f132ca 100644 --- a/doc/std/hashers.md +++ b/doc/std/hashers.md @@ -23,8 +23,10 @@ resist timing attacks. In Wuffs syntax, the `base.hasher_u32` methods are: +- `checksum_u32() u32` - `get_quirk(key: u32) u64` - `set_quirk!(key: u32, value: u64) status` +- `update!(x: slice u8)` - `update_u32!(x: slice u8) u32` diff --git a/lang/builtin/builtin.go b/lang/builtin/builtin.go index af6dcfb3..17d6e55e 100644 --- a/lang/builtin/builtin.go +++ b/lang/builtin/builtin.go @@ -956,8 +956,10 @@ var InterfacesMap = map[string]bool{ var InterfaceFuncs = []string{ // ---- hasher_u32 + "hasher_u32.checksum_u32() u32", "hasher_u32.get_quirk(key: u32) u64", "hasher_u32.set_quirk!(key: u32, value: u64) status", + "hasher_u32.update!(x: roslice u8)", "hasher_u32.update_u32!(x: roslice u8) u32", // ---- image_decoder diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 3fa5e073..9a4cb667 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -6000,6 +6000,8 @@ wuffs_base__ascii__longest_valid_prefix(const uint8_t* s_ptr, size_t s_len); extern const char wuffs_base__hasher_u32__vtable_name[]; typedef struct wuffs_base__hasher_u32__func_ptrs__struct { + uint32_t (*checksum_u32)( + const void* self); uint64_t (*get_quirk)( const void* self, uint32_t a_key); @@ -6007,6 +6009,9 @@ typedef struct wuffs_base__hasher_u32__func_ptrs__struct { void* self, uint32_t a_key, uint64_t a_value); + wuffs_base__empty_struct (*update)( + void* self, + wuffs_base__slice_u8 a_x); uint32_t (*update_u32)( void* self, wuffs_base__slice_u8 a_x); @@ -6014,6 +6019,11 @@ typedef struct wuffs_base__hasher_u32__func_ptrs__struct { typedef struct wuffs_base__hasher_u32__struct wuffs_base__hasher_u32; +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint32_t +wuffs_base__hasher_u32__checksum_u32( + const wuffs_base__hasher_u32* self); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC uint64_t wuffs_base__hasher_u32__get_quirk( @@ -6027,6 +6037,12 @@ wuffs_base__hasher_u32__set_quirk( uint32_t a_key, uint64_t a_value); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct +wuffs_base__hasher_u32__update( + wuffs_base__hasher_u32* self, + wuffs_base__slice_u8 a_x); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC uint32_t wuffs_base__hasher_u32__update_u32( @@ -6047,6 +6063,11 @@ struct wuffs_base__hasher_u32__struct { using unique_ptr = std::unique_ptr; #endif + inline uint32_t + checksum_u32() const { + return wuffs_base__hasher_u32__checksum_u32(this); + } + inline uint64_t get_quirk( uint32_t a_key) const { @@ -6062,6 +6083,13 @@ struct wuffs_base__hasher_u32__struct { this, a_key, a_value); } + inline wuffs_base__empty_struct + update( + wuffs_base__slice_u8 a_x) { + return wuffs_base__hasher_u32__update( + this, a_x); + } + inline uint32_t update_u32( wuffs_base__slice_u8 a_x) { @@ -6630,12 +6658,23 @@ wuffs_adler32__hasher__set_quirk( uint32_t a_key, uint64_t a_value); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct +wuffs_adler32__hasher__update( + wuffs_adler32__hasher* self, + wuffs_base__slice_u8 a_x); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC uint32_t wuffs_adler32__hasher__update_u32( wuffs_adler32__hasher* self, wuffs_base__slice_u8 a_x); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint32_t +wuffs_adler32__hasher__checksum_u32( + const wuffs_adler32__hasher* self); + #ifdef __cplusplus } // extern "C" #endif @@ -6746,12 +6785,23 @@ struct wuffs_adler32__hasher__struct { return wuffs_adler32__hasher__set_quirk(this, a_key, a_value); } + inline wuffs_base__empty_struct + update( + wuffs_base__slice_u8 a_x) { + return wuffs_adler32__hasher__update(this, a_x); + } + inline uint32_t update_u32( wuffs_base__slice_u8 a_x) { return wuffs_adler32__hasher__update_u32(this, a_x); } + inline uint32_t + checksum_u32() const { + return wuffs_adler32__hasher__checksum_u32(this); + } + #endif // __cplusplus }; // struct wuffs_adler32__hasher__struct @@ -7776,12 +7826,23 @@ wuffs_crc32__ieee_hasher__set_quirk( uint32_t a_key, uint64_t a_value); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct +wuffs_crc32__ieee_hasher__update( + wuffs_crc32__ieee_hasher* self, + wuffs_base__slice_u8 a_x); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC uint32_t wuffs_crc32__ieee_hasher__update_u32( wuffs_crc32__ieee_hasher* self, wuffs_base__slice_u8 a_x); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint32_t +wuffs_crc32__ieee_hasher__checksum_u32( + const wuffs_crc32__ieee_hasher* self); + #ifdef __cplusplus } // extern "C" #endif @@ -7891,12 +7952,23 @@ struct wuffs_crc32__ieee_hasher__struct { return wuffs_crc32__ieee_hasher__set_quirk(this, a_key, a_value); } + inline wuffs_base__empty_struct + update( + wuffs_base__slice_u8 a_x) { + return wuffs_crc32__ieee_hasher__update(this, a_x); + } + inline uint32_t update_u32( wuffs_base__slice_u8 a_x) { return wuffs_crc32__ieee_hasher__update_u32(this, a_x); } + inline uint32_t + checksum_u32() const { + return wuffs_crc32__ieee_hasher__checksum_u32(this); + } + #endif // __cplusplus }; // struct wuffs_crc32__ieee_hasher__struct @@ -12338,12 +12410,23 @@ wuffs_xxhash32__hasher__set_quirk( uint32_t a_key, uint64_t a_value); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct +wuffs_xxhash32__hasher__update( + wuffs_xxhash32__hasher* self, + wuffs_base__slice_u8 a_x); + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC uint32_t wuffs_xxhash32__hasher__update_u32( wuffs_xxhash32__hasher* self, wuffs_base__slice_u8 a_x); +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint32_t +wuffs_xxhash32__hasher__checksum_u32( + const wuffs_xxhash32__hasher* self); + #ifdef __cplusplus } // extern "C" #endif @@ -12458,12 +12541,23 @@ struct wuffs_xxhash32__hasher__struct { return wuffs_xxhash32__hasher__set_quirk(this, a_key, a_value); } + inline wuffs_base__empty_struct + update( + wuffs_base__slice_u8 a_x) { + return wuffs_xxhash32__hasher__update(this, a_x); + } + inline uint32_t update_u32( wuffs_base__slice_u8 a_x) { return wuffs_xxhash32__hasher__update_u32(this, a_x); } + inline uint32_t + checksum_u32() const { + return wuffs_xxhash32__hasher__checksum_u32(this); + } + #endif // __cplusplus }; // struct wuffs_xxhash32__hasher__struct @@ -14013,6 +14107,34 @@ const char wuffs_base__token_decoder__vtable_name[] = "{vtable}wuffs_base__token // ---------------- Interface Definitions. +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint32_t +wuffs_base__hasher_u32__checksum_u32( + const wuffs_base__hasher_u32* 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__hasher_u32__vtable_name) { + const wuffs_base__hasher_u32__func_ptrs* func_ptrs = + (const wuffs_base__hasher_u32__func_ptrs*)(v->function_pointers); + return (*func_ptrs->checksum_u32)(self); + } else if (v->vtable_name == NULL) { + break; + } + v++; + } + + return 0; +} + WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC uint64_t wuffs_base__hasher_u32__get_quirk( @@ -14074,6 +14196,34 @@ wuffs_base__hasher_u32__set_quirk( 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_u32__update( + wuffs_base__hasher_u32* 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_u32__vtable_name) { + const wuffs_base__hasher_u32__func_ptrs* func_ptrs = + (const wuffs_base__hasher_u32__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 uint32_t wuffs_base__hasher_u32__update_u32( @@ -26492,11 +26642,14 @@ wuffs_adler32__hasher__up_x86_sse42( const wuffs_base__hasher_u32__func_ptrs wuffs_adler32__hasher__func_ptrs_for__wuffs_base__hasher_u32 = { + (uint32_t(*)(const void*))(&wuffs_adler32__hasher__checksum_u32), (uint64_t(*)(const void*, uint32_t))(&wuffs_adler32__hasher__get_quirk), (wuffs_base__status(*)(void*, uint32_t, uint64_t))(&wuffs_adler32__hasher__set_quirk), + (wuffs_base__empty_struct(*)(void*, + wuffs_base__slice_u8))(&wuffs_adler32__hasher__update), (uint32_t(*)(void*, wuffs_base__slice_u8))(&wuffs_adler32__hasher__update_u32), }; @@ -26613,18 +26766,18 @@ wuffs_adler32__hasher__set_quirk( return wuffs_base__make_status(wuffs_base__error__unsupported_option); } -// -------- func adler32.hasher.update_u32 +// -------- func adler32.hasher.update WUFFS_BASE__GENERATED_C_CODE -WUFFS_BASE__MAYBE_STATIC uint32_t -wuffs_adler32__hasher__update_u32( +WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct +wuffs_adler32__hasher__update( wuffs_adler32__hasher* self, wuffs_base__slice_u8 a_x) { if (!self) { - return 0; + return wuffs_base__make_empty_struct(); } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - return 0; + return wuffs_base__make_empty_struct(); } if ( ! self->private_impl.f_started) { @@ -26640,6 +26793,24 @@ wuffs_adler32__hasher__update_u32( self->private_impl.choosy_up); } wuffs_adler32__hasher__up(self, a_x); + return wuffs_base__make_empty_struct(); +} + +// -------- func adler32.hasher.update_u32 + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint32_t +wuffs_adler32__hasher__update_u32( + wuffs_adler32__hasher* self, + wuffs_base__slice_u8 a_x) { + if (!self) { + return 0; + } + if (self->private_impl.magic != WUFFS_BASE__MAGIC) { + return 0; + } + + wuffs_adler32__hasher__update(self, a_x); return self->private_impl.f_state; } @@ -26719,6 +26890,23 @@ wuffs_adler32__hasher__up__choosy_default( return wuffs_base__make_empty_struct(); } +// -------- func adler32.hasher.checksum_u32 + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint32_t +wuffs_adler32__hasher__checksum_u32( + const wuffs_adler32__hasher* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + return self->private_impl.f_state; +} + // ‼ WUFFS MULTI-FILE SECTION +arm_neon // -------- func adler32.hasher.up_arm_neon @@ -32760,11 +32948,14 @@ wuffs_crc32__ieee_hasher__up_x86_sse42( const wuffs_base__hasher_u32__func_ptrs wuffs_crc32__ieee_hasher__func_ptrs_for__wuffs_base__hasher_u32 = { + (uint32_t(*)(const void*))(&wuffs_crc32__ieee_hasher__checksum_u32), (uint64_t(*)(const void*, uint32_t))(&wuffs_crc32__ieee_hasher__get_quirk), (wuffs_base__status(*)(void*, uint32_t, uint64_t))(&wuffs_crc32__ieee_hasher__set_quirk), + (wuffs_base__empty_struct(*)(void*, + wuffs_base__slice_u8))(&wuffs_crc32__ieee_hasher__update), (uint32_t(*)(void*, wuffs_base__slice_u8))(&wuffs_crc32__ieee_hasher__update_u32), }; @@ -32881,18 +33072,18 @@ wuffs_crc32__ieee_hasher__set_quirk( return wuffs_base__make_status(wuffs_base__error__unsupported_option); } -// -------- func crc32.ieee_hasher.update_u32 +// -------- func crc32.ieee_hasher.update WUFFS_BASE__GENERATED_C_CODE -WUFFS_BASE__MAYBE_STATIC uint32_t -wuffs_crc32__ieee_hasher__update_u32( +WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct +wuffs_crc32__ieee_hasher__update( wuffs_crc32__ieee_hasher* self, wuffs_base__slice_u8 a_x) { if (!self) { - return 0; + return wuffs_base__make_empty_struct(); } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - return 0; + return wuffs_base__make_empty_struct(); } if (self->private_impl.f_state == 0u) { @@ -32909,6 +33100,24 @@ wuffs_crc32__ieee_hasher__update_u32( self->private_impl.choosy_up); } wuffs_crc32__ieee_hasher__up(self, a_x); + return wuffs_base__make_empty_struct(); +} + +// -------- func crc32.ieee_hasher.update_u32 + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint32_t +wuffs_crc32__ieee_hasher__update_u32( + wuffs_crc32__ieee_hasher* self, + wuffs_base__slice_u8 a_x) { + if (!self) { + return 0; + } + if (self->private_impl.magic != WUFFS_BASE__MAGIC) { + return 0; + } + + wuffs_crc32__ieee_hasher__update(self, a_x); return self->private_impl.f_state; } @@ -33017,6 +33226,23 @@ wuffs_crc32__ieee_hasher__up__choosy_default( return wuffs_base__make_empty_struct(); } +// -------- func crc32.ieee_hasher.checksum_u32 + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint32_t +wuffs_crc32__ieee_hasher__checksum_u32( + const wuffs_crc32__ieee_hasher* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + return self->private_impl.f_state; +} + // ‼ WUFFS MULTI-FILE SECTION +arm_crc32 // -------- func crc32.ieee_hasher.up_arm_crc32 @@ -60726,20 +60952,18 @@ wuffs_xxhash32__hasher__up( wuffs_xxhash32__hasher* self, wuffs_base__slice_u8 a_x); -WUFFS_BASE__GENERATED_C_CODE -static uint32_t -wuffs_xxhash32__hasher__checksum_u32( - const wuffs_xxhash32__hasher* self); - // ---------------- VTables const wuffs_base__hasher_u32__func_ptrs wuffs_xxhash32__hasher__func_ptrs_for__wuffs_base__hasher_u32 = { + (uint32_t(*)(const void*))(&wuffs_xxhash32__hasher__checksum_u32), (uint64_t(*)(const void*, uint32_t))(&wuffs_xxhash32__hasher__get_quirk), (wuffs_base__status(*)(void*, uint32_t, uint64_t))(&wuffs_xxhash32__hasher__set_quirk), + (wuffs_base__empty_struct(*)(void*, + wuffs_base__slice_u8))(&wuffs_xxhash32__hasher__update), (uint32_t(*)(void*, wuffs_base__slice_u8))(&wuffs_xxhash32__hasher__update_u32), }; @@ -60854,18 +61078,18 @@ wuffs_xxhash32__hasher__set_quirk( return wuffs_base__make_status(wuffs_base__error__unsupported_option); } -// -------- func xxhash32.hasher.update_u32 +// -------- func xxhash32.hasher.update WUFFS_BASE__GENERATED_C_CODE -WUFFS_BASE__MAYBE_STATIC uint32_t -wuffs_xxhash32__hasher__update_u32( +WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct +wuffs_xxhash32__hasher__update( wuffs_xxhash32__hasher* self, wuffs_base__slice_u8 a_x) { if (!self) { - return 0; + return wuffs_base__make_empty_struct(); } if (self->private_impl.magic != WUFFS_BASE__MAGIC) { - return 0; + return wuffs_base__make_empty_struct(); } wuffs_base__slice_u8 v_remaining = {0}; @@ -60885,6 +61109,24 @@ wuffs_xxhash32__hasher__update_u32( wuffs_xxhash32__hasher__up(self, a_x); a_x = v_remaining; } + return wuffs_base__make_empty_struct(); +} + +// -------- func xxhash32.hasher.update_u32 + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint32_t +wuffs_xxhash32__hasher__update_u32( + wuffs_xxhash32__hasher* self, + wuffs_base__slice_u8 a_x) { + if (!self) { + return 0; + } + if (self->private_impl.magic != WUFFS_BASE__MAGIC) { + return 0; + } + + wuffs_xxhash32__hasher__update(self, a_x); return wuffs_xxhash32__hasher__checksum_u32(self); } @@ -61015,9 +61257,17 @@ wuffs_xxhash32__hasher__up( // -------- func xxhash32.hasher.checksum_u32 WUFFS_BASE__GENERATED_C_CODE -static uint32_t +WUFFS_BASE__MAYBE_STATIC uint32_t wuffs_xxhash32__hasher__checksum_u32( const wuffs_xxhash32__hasher* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + uint32_t v_ret = 0; uint32_t v_i = 0; uint32_t v_n = 0; diff --git a/std/adler32/common_adler32.wuffs b/std/adler32/common_adler32.wuffs index e5522ca4..b78350d9 100644 --- a/std/adler32/common_adler32.wuffs +++ b/std/adler32/common_adler32.wuffs @@ -26,7 +26,7 @@ pub func hasher.set_quirk!(key: base.u32, value: base.u64) base.status { return base."#unsupported option" } -pub func hasher.update_u32!(x: roslice base.u8) base.u32 { +pub func hasher.update!(x: roslice base.u8) { if not this.started { this.started = true this.state = 1 @@ -39,6 +39,10 @@ pub func hasher.update_u32!(x: roslice base.u8) base.u32 { up_x86_sse42] } this.up!(x: args.x) +} + +pub func hasher.update_u32!(x: roslice base.u8) base.u32 { + this.update!(x: args.x) return this.state } @@ -74,3 +78,7 @@ pri func hasher.up!(x: roslice base.u8), } endwhile this.state = ((s2 & 0xFFFF) << 16) | (s1 & 0xFFFF) } + +pub func hasher.checksum_u32() base.u32 { + return this.state +} diff --git a/std/crc32/common_crc32.wuffs b/std/crc32/common_crc32.wuffs index b1f8e610..74ad533b 100644 --- a/std/crc32/common_crc32.wuffs +++ b/std/crc32/common_crc32.wuffs @@ -28,7 +28,7 @@ pub func ieee_hasher.set_quirk!(key: base.u32, value: base.u64) base.status { // TODO: should it be ? instead of ! because it's public, and might need a way // to signal "initializer not called"? Should the return type, in the generated // C code, be "struct{ uint32_t checksum; wuffs_crc32__status status }"? -pub func ieee_hasher.update_u32!(x: roslice base.u8) base.u32 { +pub func ieee_hasher.update!(x: roslice base.u8) { if this.state == 0 { choose up = [ up_arm_crc32, @@ -36,6 +36,10 @@ pub func ieee_hasher.update_u32!(x: roslice base.u8) base.u32 { up_x86_sse42] } this.up!(x: args.x) +} + +pub func ieee_hasher.update_u32!(x: roslice base.u8) base.u32 { + this.update!(x: args.x) return this.state } @@ -77,6 +81,10 @@ pri func ieee_hasher.up!(x: roslice base.u8), this.state = 0xFFFF_FFFF ^ s } +pub func ieee_hasher.checksum_u32() base.u32 { + return this.state +} + // The table below was created by script/print-crc32-magic-numbers.go. pri const IEEE_TABLE : roarray[16] roarray[256] base.u32 = [[ diff --git a/std/xxhash32/common_xxhash32.wuffs b/std/xxhash32/common_xxhash32.wuffs index e79418a2..a7fad5e8 100644 --- a/std/xxhash32/common_xxhash32.wuffs +++ b/std/xxhash32/common_xxhash32.wuffs @@ -47,7 +47,7 @@ pub func hasher.set_quirk!(key: base.u32, value: base.u64) base.status { return base."#unsupported option" } -pub func hasher.update_u32!(x: roslice base.u8) base.u32 { +pub func hasher.update!(x: roslice base.u8) { var remaining : roslice base.u8 if (this.length_modulo_u32 == 0) and not this.length_overflows_u32 { @@ -68,7 +68,10 @@ pub func hasher.update_u32!(x: roslice base.u8) base.u32 { args.x = remaining } endwhile +} +pub func hasher.update_u32!(x: roslice base.u8) base.u32 { + this.update!(x: args.x) return this.checksum_u32() } @@ -183,7 +186,7 @@ pri func hasher.up!(x: roslice base.u8) { this.v3 = v3 } -pri func hasher.checksum_u32() base.u32 { +pub func hasher.checksum_u32() base.u32 { var ret : base.u32 var i : base.u32[..= 16] var n : base.u32[..= 16]