package core:hash/xxhash

Source

Alignment :: enum int {
	Aligned, 
	Unaligned, 
}

Error :: enum int {
	None  = 0, 
	Error, 
}

XXH128_canonical :: struct {
	digest: [16]u8,
}

XXH128_hash_t :: struct #raw_union {
	using raw: struct {
		low:  u64,
		// !< `value & 0xFFFFFFFFFFFFFFFF` 
		high: u64,
	},
	h:   u128,
}

XXH32_canonical :: struct {
	digest: [4]u8,
}

XXH32_hash :: u32

XXH32_state :: struct {
	total_len_32: u32,
	// !< Total length hashed, modulo 2^32 
	large_len:    u32,
	// !< Whether the hash is >= 16 (handles @ref total_len_32 overflow) 
	v1:           u32,
	// !< First accumulator lane 
	v2:           u32,
	// !< Second accumulator lane 
	v3:           u32,
	// !< Third accumulator lane 
	v4:           u32,
	// !< Fourth accumulator lane 
	mem32:        [4]u32,
	// !< Internal buffer for partial reads. Treated as unsigned char[16]. 
	memsize:      u32,
	// !< Amount of data in @ref mem32 
	reserved:     u32,
}

XXH3_128_hash :: u128

XXH3_accumulate_512_f :: proc(acc: []u64, input: []u8, secret: []u8)

XXH3_hashLong128_f :: proc(input: []u8, seed: u64, secret: []u8) -> (res: u128)

XXH3_hashLong64_f :: proc(input: []u8, seed: u64, secret: []u8) -> (res: u64)

XXH3_init_custom_secret_f :: proc(custom_secret: []u8, seed64: u64)

XXH3_scramble_accumulator_f :: proc(acc: []u64, secret: []u8)

XXH3_state :: struct #align (64) {
	acc:               [8]u64,
	custom_secret:     [192]u8,
	buffer:            [256]u8,
	buffered_size:     u32,
	reserved32:        u32,
	stripes_so_far:    uint,
	total_length:      u64,
	stripes_per_block: uint,
	secret_limit:      uint,
	seed:              u64,
	reserved64:        u64,
	external_secret:   []u8,
}

XXH64_canonical :: struct {
	digest: [8]u8,
}

XXH64_hash :: u64

XXH64_state :: struct {
	total_len:  u64,
	// !< Total length hashed. This is always 64-bit. 
	v1:         u64,
	// !< First accumulator lane 
	v2:         u64,
	// !< Second accumulator lane 
	v3:         u64,
	// !< Third accumulator lane 
	v4:         u64,
	// !< Fourth accumulator lane 
	mem64:      [4]u64,
	// !< Internal buffer for partial reads. Treated as unsigned char[32]. 
	memsize:    u32,
	// !< Amount of data in @ref mem64 
	reserved32: u32,
	// !< Reserved field, needed for padding anyways
	reserved64: u64,
}

xxh_u128 :: u128

xxh_u32 :: u32

xxh_u64 :: u64

XXH32_DEFAULT_SEED: u32 : XXH32_hash(0)

XXH3_INIT_ACC: [8]u64 : [XXH_ACC_NB]xxh_u64{XXH_PRIME32_3, XXH_PRIME64_1, XXH_PRIME64_2, XXH_PRIME64_3, XXH_PRIME64_4, XXH_PRIME32_2, XXH_PRIME64_5, XXH_PRIME32_1}

XXH3_INTERNAL_BUFFER_SIZE :: 256

XXH3_MIDSIZE_LASTOFFSET :: 17

XXH3_MIDSIZE_MAX :: 240

XXH3_MIDSIZE_STARTOFFSET :: 3

XXH3_SECRET_SIZE_MIN :: 136

XXH64_DEFAULT_SEED: u64 : XXH64_hash(0)

XXH_ACC_ALIGN :: 8

XXH_ACC_NB :: XXH_STRIPE_LEN / size_of(xxh_u64)

XXH_DISABLE_PREFETCH :: #config(XXH_DISABLE_PREFETCH, true)

-define:XXH_DISABLE_PREFETCH=true

XXH_FORCE_ALIGN_CHECK :: #config(XXH_FORCE_ALIGN_CHECK, false)

-define:XXH_FORCE_ALIGN_CHECK=false

XXH_FORCE_MEMORY_ACCESS :: #config(XXH_FORCE_MEMORY_ACCESS, 2)

-define:XXH_FORCE_MEMORY_ACCESS=2

XXH_MAX_WIDTH :: #config(XXH_MAX_WIDTH, 512) / 64

XXH_NATIVE_WIDTH :: min(XXH_MAX_WIDTH, 8 when intrinsics.has_target_feature(AVX512_FEATURES) else 4 when intrinsics.has_target_feature(AVX2_FEATURES) else 2 when intrinsics.has_target_feature(SSE2_FEATURES) else 1)

XXH_PREFETCH_DIST :: 320

XXH_PRIME32_1 :: 0x9E3779B1

XXH_PRIME32_2 :: 0x85EBCA77

XXH_PRIME32_3 :: 0xC2B2AE3D

XXH_PRIME32_4 :: 0x27D4EB2F

XXH_PRIME32_5 :: 0x165667B1

XXH_PRIME64_1 :: 0x9E3779B185EBCA87

XXH_PRIME64_2 :: 0xC2B2AE3D27D4EB4F

XXH_PRIME64_3 :: 0x165667B19E3779F9

XXH_PRIME64_4 :: 0x85EBCA77C2B2AE63

XXH_PRIME64_5 :: 0x27D4EB2F165667C5

XXH_SECRET_CONSUME_RATE :: 8

XXH_SECRET_DEFAULT_SIZE :: max(XXH3_SECRET_SIZE_MIN, #config(XXH_SECRET_DEFAULT_SIZE, 192))

XXH_SECRET_LASTACC_START :: 7

XXH_SECRET_MERGEACCS_START :: 11

XXH_STRIPE_LEN :: 64

XXH_VERSION_MAJOR :: 0

XXH_VERSION_MINOR :: 8

XXH_VERSION_NUMBER :: XXH_VERSION_MAJOR * 100 * 100 + XXH_VERSION_MINOR * 100 + XXH_VERSION_RELEASE

XXH_VERSION_RELEASE :: 1

XXH3_kSecret: [192]u8 = …

@(optimization_mode="favor_size")
XXH128_mix32B :: proc(
	acc:     u128, 
	input_1: []u8, 
	input_2: []u8, 
	secret:  []u8, 
	seed:    u64, 
) -> (res: u128) {…}

XXH32 :: proc(input: []u8, seed: u32 = XXH32_DEFAULT_SEED) -> (digest: u32) {…}

@(optimization_mode="favor_size")
XXH32_avalanche :: proc(h32: u32) -> (res: u32) {…}

XXH32_canonical_from_hash :: proc(hash: u32) -> (canonical: XXH32_canonical) {…}

XXH32_copy_state :: proc(dest, src: ^XXH32_state) {…}

XXH32_create_state :: proc(allocator := context.allocator) -> (res: ^XXH32_state, err: Error) {…}

XXH32_destroy_state :: proc(
	state:     ^XXH32_state, 
	allocator := context.allocator, 
) -> (err: Error) {…}

XXH32_digest :: proc(state: ^XXH32_state) -> (res: u32) {…}

@(optimization_mode="favor_size")
XXH32_endian_align :: proc(
	input:     []u8, 
	seed:      u32 = XXH32_DEFAULT_SEED, 
	alignment: Alignment, 
) -> (res: u32) {…}

@(optimization_mode="favor_size")
XXH32_finalize :: proc(h32: u32, buf: []u8, alignment: Alignment) -> (res: u32) {…}

XXH32_hash_from_canonical :: proc(canonical: ^XXH32_canonical) -> (hash: u32) {…}

@(optimization_mode="favor_size")
XXH32_read32 :: proc(buf: []u8, alignment: Alignment = Alignment.Unaligned) -> (res: u32) {…}

XXH32_reset_state :: proc(
	state_ptr: ^XXH32_state, 
	seed:      u32 = XXH32_DEFAULT_SEED, 
) -> (err: Error) {…}

@(optimization_mode="favor_size")
XXH32_round :: proc(seed, input: u32) -> (res: u32) {…}

XXH32_update :: proc(state: ^XXH32_state, input: []u8) -> (err: Error) {…}

XXH3_128_canonical_from_hash :: proc(hash: XXH128_hash_t) -> (canonical: XXH128_canonical) {…}

@(optimization_mode="favor_size")
XXH3_128_default :: proc(input: []u8) -> (hash: u128) {…}

XXH3_128_digest :: proc(state: ^XXH3_state) -> (hash: u128) {…}

XXH3_128_hash_from_canonical :: proc(src: ^XXH128_canonical) -> (hash: u128) {…}

XXH3_128_reset :: proc(state: ^XXH3_state) -> (err: Error) {…}

XXH3_128_reset_with_secret :: proc(state: ^XXH3_state, secret: []u8) -> (err: Error) {…}

XXH3_128_reset_with_seed :: proc(state: ^XXH3_state, seed: u64) -> (err: Error) {…}

XXH3_128_update :: proc(state: ^XXH3_state, input: []u8) -> (err: Error) {…}

@(optimization_mode="favor_size")
XXH3_128_with_secret :: proc(input: []u8, secret: []u8) -> (hash: u128) {…}

@(optimization_mode="favor_size")
XXH3_128_with_seed :: proc(input: []u8, seed: u64) -> (hash: u128) {…}

@(optimization_mode="favor_size")
XXH3_128bits_internal :: proc(
	input:   []u8, 
	seed:    u64, 
	secret:  []u8, 
	f_hl128: XXH3_hashLong128_f, 
) -> (res: u128) {…}

@(optimization_mode="favor_size")
XXH3_64_default :: proc(input: []u8) -> (hash: u64) {…}

XXH3_64_digest :: proc(state: ^XXH3_state) -> (hash: u64) {…}

XXH3_64_reset :: XXH3_128_reset

XXH3_64_reset_with_secret :: XXH3_128_reset_with_secret

XXH3_64_reset_with_seed :: XXH3_128_reset_with_seed

XXH3_64_update :: XXH3_128_update

@(optimization_mode="favor_size")
XXH3_64_with_secret :: proc(input: []u8, secret: []u8) -> (hash: u64) {…}

@(optimization_mode="favor_size")
XXH3_64_with_seed :: proc(input: []u8, seed: u64) -> (hash: u64) {…}

@(optimization_mode="favor_size")
XXH3_64bits_internal :: proc(
	input:      []u8, 
	seed:       u64, 
	secret:     []u8, 
	f_hashLong: XXH3_hashLong64_f, 
) -> (hash: u64) {…}

@(optimization_mode="favor_size")
XXH3_accumulate :: proc(
	acc:       []u64, 
	input:     []u8, 
	secret:    []u8, 
	nbStripes: uint, 
	f_acc512:  XXH3_accumulate_512_f, 
) {…}

XXH3_accumulate_512 :: proc(acc: []u64, input: []u8, secret: []u8) {…}

@(optimization_mode="favor_size")
XXH3_accumulate_512_scalar :: proc(acc: []u64, input: []u8, secret: []u8) {…}

XXH3_accumulate_512_simd_generic :: proc(acc: []u64, input: []u8, secret: []u8, $W: uint) {…}

@(optimization_mode="favor_size")
XXH3_avalanche :: proc(h64: u64) -> (res: u64) {…}

XXH3_consume_stripes :: proc(
	acc:               []u64, 
	stripes_so_far:    ^uint, 
	stripes_per_block: uint, 
	input:             []u8, 
	number_of_stripes: uint, 
	secret:            []u8, 
	secret_limit:      uint, 
	f_acc512:          XXH3_accumulate_512_f, 
	f_scramble:        XXH3_scramble_accumulator_f, 
) {…}

XXH3_copy_state :: proc(dest, src: ^XXH3_state) {…}

XXH3_create_state :: proc(allocator := context.allocator) -> (res: ^XXH3_state, err: Error) {…}

XXH3_destroy_state :: proc(state: ^XXH3_state, allocator := context.allocator) -> (err: Error) {…}

XXH3_digest_long :: proc(acc: []u64, state: ^XXH3_state, secret: []u8) {…}

XXH3_generate_secret :: proc(secret_buffer: []u8, custom_seed: []u8) {…}

XXH3_hashLong_128b_default :: proc(input: []u8, seed: u64, secret: []u8) -> (res: u128) {…}

XXH3_hashLong_128b_internal :: proc(
	input:      []u8, 
	secret:     []u8, 
	f_acc512:   XXH3_accumulate_512_f, 
	f_scramble: XXH3_scramble_accumulator_f, 
) -> (res: u128) {…}

XXH3_hashLong_128b_withSecret :: proc(input: []u8, seed: u64, secret: []u8) -> (res: u128) {…}

XXH3_hashLong_128b_withSeed :: proc(input: []u8, seed: u64, secret: []u8) -> (res: u128) {…}

XXH3_hashLong_128b_withSeed_internal :: proc(
	input:      []u8, 
	seed:       u64, 
	secret:     []u8, 
	f_acc512:   XXH3_accumulate_512_f, 
	f_scramble: XXH3_scramble_accumulator_f, 
	f_initSec:  XXH3_init_custom_secret_f, 
) -> (res: u128) {…}

XXH3_hashLong_64b_default :: proc(input: []u8, seed64: u64, secret: []u8) -> (hash: u64) {…}

@(optimization_mode="favor_size")
XXH3_hashLong_64b_internal :: proc(
	input:      []u8, 
	secret:     []u8, 
	f_acc512:   XXH3_accumulate_512_f, 
	f_scramble: XXH3_scramble_accumulator_f, 
) -> (hash: u64) {…}

XXH3_hashLong_64b_withSecret :: proc(input: []u8, seed64: u64, secret: []u8) -> (hash: u64) {…}

XXH3_hashLong_64b_withSeed :: proc(input: []u8, seed: u64, secret: []u8) -> (hash: u64) {…}

XXH3_hashLong_64b_withSeed_internal :: proc(
	input:      []u8, 
	seed:       u64, 
	f_acc512:   XXH3_accumulate_512_f, 
	f_scramble: XXH3_scramble_accumulator_f, 
	f_init_sec: XXH3_init_custom_secret_f, 
) -> (hash: u64) {…}

@(optimization_mode="favor_size")
XXH3_hashLong_internal_loop :: proc(
	acc:        []u64, 
	input:      []u8, 
	secret:     []u8, 
	f_acc512:   XXH3_accumulate_512_f, 
	f_scramble: XXH3_scramble_accumulator_f, 
) {…}

XXH3_init_custom_secret :: proc(custom_secret: []u8, seed64: u64) {…}

@(optimization_mode="favor_size")
XXH3_init_custom_secret_scalar :: proc(custom_secret: []u8, seed64: u64) {…}

XXH3_init_custom_secret_simd_generic :: proc(custom_secret: []u8, seed64: u64, $W: uint) {…}

XXH3_init_state :: proc(state: ^XXH3_state) {…}

@(optimization_mode="favor_size")
XXH3_len_0to16_128b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u128) {…}

@(optimization_mode="favor_size")
XXH3_len_0to16_64b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u64) {…}

@(optimization_mode="favor_size")
XXH3_len_129to240_128b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u128) {…}

@(optimization_mode="favor_size")
XXH3_len_129to240_64b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u64) {…}

@(optimization_mode="favor_size")
XXH3_len_17to128_128b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u128) {…}

@(optimization_mode="favor_size")
XXH3_len_17to128_64b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u64) {…}

@(optimization_mode="favor_size")
XXH3_len_1to3_128b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u128) {…}

@(optimization_mode="favor_size")
XXH3_len_1to3_64b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u64) {…}

@(optimization_mode="favor_size")
XXH3_len_4to8_128b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u128) {…}

@(optimization_mode="favor_size")
XXH3_len_4to8_64b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u64) {…}

@(optimization_mode="favor_size")
XXH3_len_9to16_128b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u128) {…}

@(optimization_mode="favor_size")
XXH3_len_9to16_64b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u64) {…}

@(optimization_mode="favor_size")
XXH3_mergeAccs :: proc(acc: []u64, secret: []u8, start: u64) -> (res: u64) {…}

@(optimization_mode="favor_size")
XXH3_mix16B :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u64) {…}

@(optimization_mode="favor_size")
XXH3_mix2Accs :: proc(acc: []u64, secret: []u8) -> (res: u64) {…}

XXH3_reset_internal :: proc(state: ^XXH3_state, seed: u64, secret: []u8, secret_size: uint) {…}

@(optimization_mode="favor_size")
XXH3_rrmxmx :: proc(h64, length: u64) -> (res: u64) {…}

XXH3_scramble_accumulator :: proc(acc: []u64, secret: []u8) {…}

@(optimization_mode="favor_size")
XXH3_scramble_accumulator_scalar :: proc(acc: []u64, secret: []u8) {…}

XXH3_scramble_accumulator_simd_generic :: proc(acc: []u64, secret: []u8, $W: uint) {…}

XXH3_update :: proc(
	state:      ^XXH3_state, 
	input:      []u8, 
	f_acc512:   XXH3_accumulate_512_f, 
	f_scramble: XXH3_scramble_accumulator_f, 
) -> (err: Error) {…}

XXH64 :: proc(input: []u8, seed: u64 = XXH64_DEFAULT_SEED) -> (digest: u64) {…}

@(optimization_mode="favor_size")
XXH64_avalanche :: proc(h64: u64) -> (res: u64) {…}

XXH64_canonical_from_hash :: proc(hash: u64) -> (canonical: XXH64_canonical) {…}

XXH64_copy_state :: proc(dest, src: ^XXH64_state) {…}

XXH64_create_state :: proc(allocator := context.allocator) -> (res: ^XXH64_state, err: Error) {…}

XXH64_destroy_state :: proc(
	state:     ^XXH64_state, 
	allocator := context.allocator, 
) -> (err: Error) {…}

@(optimization_mode="favor_size")
XXH64_digest :: proc(state: ^XXH64_state) -> (res: u64) {…}

@(optimization_mode="favor_size")
XXH64_endian_align :: proc(
	input:     []u8, 
	seed:      u64 = XXH64_DEFAULT_SEED, 
	alignment: Alignment = Alignment.Unaligned, 
) -> (res: u64) {…}

@(optimization_mode="favor_size")
XXH64_finalize :: proc(h64: u64, buf: []u8, alignment: Alignment) -> (res: u64) {…}

XXH64_hash_from_canonical :: proc(canonical: ^XXH64_canonical) -> (hash: u64) {…}

@(optimization_mode="favor_size")
XXH64_mergeRound :: proc(acc, val: u64) -> (res: u64) {…}

@(optimization_mode="favor_size")
XXH64_read64 :: proc(buf: []u8, alignment: Alignment = Alignment.Unaligned) -> (res: u64) {…}

XXH64_read64_simd :: proc(
	buf:       []$E, 
	$W:         uint, 
	alignment: Alignment = Alignment.Unaligned, 
) -> (res: [0]u64) {…}

XXH64_reset_state :: proc(
	state_ptr: ^XXH64_state, 
	seed:      u64 = XXH64_DEFAULT_SEED, 
) -> (err: Error) {…}

@(optimization_mode="favor_size")
XXH64_round :: proc(acc, input: u64) -> (res: u64) {…}

@(optimization_mode="favor_size")
XXH64_update :: proc(state: ^XXH64_state, input: []u8) -> (err: Error) {…}

XXH64_write64_simd :: proc(
	buf:       []$E, 
	value:     $V/#simd[0]u64, 
	alignment: Alignment = Alignment.Unaligned, 
) {…}

@(optimization_mode="favor_size")
XXH_mul_64_to_128_fold_64 :: proc(lhs, rhs: u64) -> (res: u64) {…}

@(optimization_mode="favor_size")
XXH_rotl32 :: proc(x, r: u32) -> (res: u32) {…}

@(optimization_mode="favor_size")
XXH_rotl64 :: proc(x, r: u64) -> (res: u64) {…}

@(optimization_mode="favor_size")
XXH_writeLE64 :: proc(dst: []u8, v64: u64le) {…}

@(optimization_mode="favor_size")
XXH_xorshift_64 :: proc(v: u64, #any_int shift: uint) -> (res: u64) {…}

byte_swap :: intrinsics.byte_swap
byte_swap :: proc(x: $T) -> T where type_is_integer(T) || type_is_float(T) {…}

mem_copy :: runtime.mem_copy

prefetch_address :: proc(address: rawptr) {…}

prefetch_offset :: proc(address: rawptr, #any_int offset: uintptr) {…}

XXH3_128 :: proc{
	XXH3_128_default,
	XXH3_128_with_seed,
	XXH3_128_with_secret,
}

XXH3_64 :: proc{
	XXH3_64_default,
	XXH3_64_with_seed,
	XXH3_64_with_secret,
}