60 lines
2.3 KiB
Text
60 lines
2.3 KiB
Text
# baked_hash.ludic - a bake's inputs as one number, and the header's little-endian fields. The hash
|
|
# is FNV-1a 64 over each input in order: its path's bytes, a 0, then its bytes - or, for an input that
|
|
# is itself a bake ("LBAK"), its payload alone, so a re-bake that makes the same bytes under a new
|
|
# header leaves what reads it current (tools/bake/baked.py and the check compute the same)
|
|
const BK_FNV_OFFSET: long = -3750763034362895579 # 0xcbf29ce484222325
|
|
const BK_FNV_PRIME: long = 1099511628211
|
|
|
|
# `inputs` space-separated, as a Bakes row lists them; a missing input hashes as its path alone
|
|
export function bake_inputs_hash(inputs: string) -> long {
|
|
var h = BK_FNV_OFFSET
|
|
var a = 0
|
|
while a < len(inputs) {
|
|
while a < len(inputs) and inputs[a] == 32 { a += 1 }
|
|
var e = a
|
|
while e < len(inputs) and inputs[e] != 32 { e += 1 }
|
|
if e > a {
|
|
let p = inputs[a .. e]
|
|
for i in 0 .. len(p) { h = bk_fnv(h, p[i]) }
|
|
h = bk_fnv(h, 0)
|
|
let b = Fs.read_bytes(p)
|
|
if b != null { h = bk_fnv_bytes(h, b) }
|
|
}
|
|
a = e
|
|
}
|
|
return h
|
|
}
|
|
function bk_fnv(h: long, c: int) -> long { return (h ^ long(c & 255)) * BK_FNV_PRIME }
|
|
# an input's bytes into the hash: a baked file's payload, anything else whole
|
|
function bk_fnv_bytes(h0: long, b: []byte) -> long {
|
|
var h = h0
|
|
var lo = 0
|
|
var hi = len(b)
|
|
if bk_is_bake(b) {
|
|
lo = bk_u32(b, 12)
|
|
let n = bk_u64(b, 24)
|
|
if lo > len(b) { lo = len(b) }
|
|
if n < long(hi - lo) { hi = lo + int(n) }
|
|
}
|
|
for i in lo .. hi { h = bk_fnv(h, b[i]) }
|
|
return h
|
|
}
|
|
# "LBAK" and a whole header
|
|
function bk_is_bake(b: []byte) -> bool {
|
|
if len(b) < 32 { return false }
|
|
return b[0] == 76 and b[1] == 66 and b[2] == 65 and b[3] == 75
|
|
}
|
|
|
|
function bk_u32(b: []byte, at: int) -> int { return (b[at] & 255) | ((b[at + 1] & 255) << 8) | ((b[at + 2] & 255) << 16) | ((b[at + 3] & 255) << 24) }
|
|
function bk_u64(b: []byte, at: int) -> long { return long(bk_u32(b, at)) & 4294967295 | (long(bk_u32(b, at + 4)) << 32) }
|
|
function bk_put32(b: []byte, at: int, v: int) -> void {
|
|
for i in 0 .. 4 { b[at + i] = (v >> (i * 8)) & 255 }
|
|
}
|
|
function bk_put64(b: []byte, at: int, v: long) -> void {
|
|
for i in 0 .. 8 { b[at + i] = int((v >> long(i * 8)) & 255) }
|
|
}
|
|
function bk_last_slash(p: string) -> int {
|
|
var k = -1
|
|
for i in 0 .. len(p) { if p[i] == 47 { k = i } }
|
|
return k
|
|
}
|