refactor(runtime,packages,examples): named constants, package enums, idiom sweep
- runtime: HEADLESS_FRAME_PATH, STICK_DEADZONE / STICK_LEFT_X/Y, key and byte codes as char literals throughout (`k == 'w'`, `fill(rt_map, ' ', …)`) - ludic.gameplay/stats: drop the duplicate `stat_field` (it answered "atk" for every build stat); Stats.base uses stats_field_name - ludic.shooter: compare aim modes and fire patterns with AimMode.* and WeaponPattern.* instead of raw ints; STICK_RIGHT_X/Y - ludic.npcai: DecisionMade / brain_set_state use AiState.* - examples/games/menu.ludic uses Font.load / Ui.* with FONT_PATH and BACKDROP named; strings.ludic header says what it prints - whole tree: `x = x + 1` → `x += 1` (single-term right-hand sides only), `0 - x` → `-x`, ASCII codes → char literals; every .ludic and every ```ludic fence reformatted with the fixed formatter (whitespace only) Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
parent
e3e1bc7784
commit
bf36bc8a8f
103 changed files with 1256 additions and 1252 deletions
|
|
@ -28,9 +28,9 @@ function zf_read(n: int) -> int {
|
|||
while k < n {
|
||||
let b = (zf_src[zf_pos] >> zf_bit) & 1
|
||||
v = v | (b << k)
|
||||
zf_bit = zf_bit + 1
|
||||
if zf_bit == 8 { zf_bit = 0; zf_pos = zf_pos + 1 }
|
||||
k = k + 1
|
||||
zf_bit += 1
|
||||
if zf_bit == 8 { zf_bit = 0; zf_pos += 1 }
|
||||
k += 1
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
|
@ -45,18 +45,18 @@ var zb_skip: int = 0 # padding bits above the sentinel in the last byt
|
|||
var zb_cur: int = 0 # data-bit index consumed so far
|
||||
|
||||
function zstd_highbit(v: int) -> int {
|
||||
var r = 0 - 1
|
||||
var r = -1
|
||||
var x = v & 255
|
||||
while x > 0 { r = r + 1; x = x >> 1 }
|
||||
while x > 0 { r += 1; x = x >> 1 }
|
||||
return r # position of the most-significant set bit (-1 if 0)
|
||||
}
|
||||
|
||||
# init over stream bytes [s, s+L); the sentinel is the top set bit of the last.
|
||||
function zb_init(src: pointer, s: int, L: int) -> int {
|
||||
zb_src = src; zb_s = s; zb_L = L; zb_cur = 0
|
||||
if L <= 0 { return 0 - 1 }
|
||||
if L <= 0 { return -1 }
|
||||
let hb = zstd_highbit(src[s + L - 1])
|
||||
if hb < 0 { return 0 - 1 } # a zero last byte is invalid
|
||||
if hb < 0 { return -1 } # a zero last byte is invalid
|
||||
zb_skip = 8 - hb # the sentinel bit + anything above it is padding
|
||||
return 0
|
||||
}
|
||||
|
|
@ -65,7 +65,7 @@ function zb_bit() -> int {
|
|||
let j = zb_skip + zb_cur
|
||||
let byteidx = (zb_L - 1) - (j >> 3)
|
||||
let bit = 7 - (j & 7)
|
||||
zb_cur = zb_cur + 1
|
||||
zb_cur += 1
|
||||
if byteidx < 0 { return 0 }
|
||||
return (zb_src[zb_s + byteidx] >> bit) & 1
|
||||
}
|
||||
|
|
@ -73,7 +73,7 @@ function zb_bit() -> int {
|
|||
function zb_read(n: int) -> int {
|
||||
var v = 0
|
||||
var k = 0
|
||||
while k < n { v = (v << 1) | zb_bit(); k = k + 1 }
|
||||
while k < n { v = (v << 1) | zb_bit(); k += 1 }
|
||||
return v
|
||||
}
|
||||
function zb_total() -> int { return 8 * (zb_L - 1) + (8 - zb_skip) } # usable data bits
|
||||
|
|
@ -101,14 +101,14 @@ function fse_build(norm: words, nsym: int, tableLog: int) -> FseDT {
|
|||
var highThreshold = size - 1
|
||||
var s = 0
|
||||
while s < nsym {
|
||||
if norm[s] == (0 - 1) {
|
||||
if norm[s] == (-1) {
|
||||
dt.sym[highThreshold] = s
|
||||
highThreshold = highThreshold - 1
|
||||
highThreshold -= 1
|
||||
symnext[s] = 1
|
||||
} else {
|
||||
symnext[s] = norm[s]
|
||||
}
|
||||
s = s + 1
|
||||
s += 1
|
||||
}
|
||||
# spread the remaining symbols with the standard step
|
||||
let step = (size >> 1) + (size >> 3) + 3
|
||||
|
|
@ -122,21 +122,21 @@ function fse_build(norm: words, nsym: int, tableLog: int) -> FseDT {
|
|||
dt.sym[pos] = s
|
||||
pos = (pos + step) & mask
|
||||
while pos > highThreshold { pos = (pos + step) & mask } # skip the low-prob zone
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
}
|
||||
s = s + 1
|
||||
s += 1
|
||||
}
|
||||
# assign nbBits + newState for each cell
|
||||
var u = 0
|
||||
while u < size {
|
||||
let sy = dt.sym[u]
|
||||
let nextState = symnext[sy]
|
||||
symnext[sy] = symnext[sy] + 1
|
||||
symnext[sy] += 1
|
||||
let nbits = tableLog - zstd_highbit32(nextState)
|
||||
dt.nb[u] = nbits
|
||||
dt.ns[u] = (nextState << nbits) - size
|
||||
u = u + 1
|
||||
u += 1
|
||||
}
|
||||
free(symnext)
|
||||
return dt
|
||||
|
|
@ -144,9 +144,9 @@ function fse_build(norm: words, nsym: int, tableLog: int) -> FseDT {
|
|||
|
||||
# highbit for a full 32-bit-ish value (nextState < size <= 2^tableLog)
|
||||
function zstd_highbit32(v: int) -> int {
|
||||
var r = 0 - 1
|
||||
var r = -1
|
||||
var x = v
|
||||
while x > 0 { r = r + 1; x = x >> 1 }
|
||||
while x > 0 { r += 1; x = x >> 1 }
|
||||
return r
|
||||
}
|
||||
|
||||
|
|
@ -167,11 +167,11 @@ function fse_read_ncount(norm: words, maxsym: int) -> int {
|
|||
var n0 = sym
|
||||
var rep = zf_read(2)
|
||||
while rep == 3 {
|
||||
n0 = n0 + 3
|
||||
n0 += 3
|
||||
rep = zf_read(2)
|
||||
}
|
||||
n0 = n0 + rep
|
||||
while sym < n0 { norm[sym] = 0; sym = sym + 1 }
|
||||
n0 += rep
|
||||
while sym < n0 { norm[sym] = 0; sym += 1 }
|
||||
prev0 = 0
|
||||
} else {
|
||||
let maxv = (2 * threshold - 1) - remaining
|
||||
|
|
@ -183,22 +183,22 @@ function fse_read_ncount(norm: words, maxsym: int) -> int {
|
|||
zf_skip(bitsLeft - 1)
|
||||
} else {
|
||||
count = zf_read(bitsLeft)
|
||||
if count >= threshold { count = count - maxv }
|
||||
if count >= threshold { count -= maxv }
|
||||
}
|
||||
let val = count - 1 # -1 means low-prob (stored as -1)
|
||||
norm[sym] = val
|
||||
if val == (0 - 1) { remaining = remaining - 1 }
|
||||
else { remaining = remaining - val }
|
||||
sym = sym + 1
|
||||
if val == (-1) { remaining -= 1 }
|
||||
else { remaining -= val }
|
||||
sym += 1
|
||||
if val == 0 { prev0 = 1 }
|
||||
# shrink the threshold as `remaining` falls
|
||||
while remaining < threshold {
|
||||
bitsLeft = bitsLeft - 1
|
||||
bitsLeft -= 1
|
||||
threshold = threshold >> 1
|
||||
}
|
||||
}
|
||||
}
|
||||
while sym <= maxsym { norm[sym] = 0; sym = sym + 1 }
|
||||
while sym <= maxsym { norm[sym] = 0; sym += 1 }
|
||||
fse_ncount_n = sym
|
||||
return accLog
|
||||
}
|
||||
|
|
@ -222,13 +222,13 @@ function fse_decompress(dt: FseDT, out: words, cap: int) -> int {
|
|||
# two states alternate; when a state-advance read overruns the stream, the
|
||||
# other state's residual symbol is the final one (FSE_decompress tail).
|
||||
while true {
|
||||
out[n] = dt.sym[s1]; n = n + 1
|
||||
out[n] = dt.sym[s1]; n += 1
|
||||
s1 = dt.ns[s1] + zb_read(dt.nb[s1])
|
||||
if zb_cur > zb_total() { out[n] = dt.sym[s2]; n = n + 1; return n }
|
||||
if zb_cur > zb_total() { out[n] = dt.sym[s2]; n += 1; return n }
|
||||
if n >= cap { return n }
|
||||
out[n] = dt.sym[s2]; n = n + 1
|
||||
out[n] = dt.sym[s2]; n += 1
|
||||
s2 = dt.ns[s2] + zb_read(dt.nb[s2])
|
||||
if zb_cur > zb_total() { out[n] = dt.sym[s1]; n = n + 1; return n }
|
||||
if zb_cur > zb_total() { out[n] = dt.sym[s1]; n += 1; return n }
|
||||
if n >= cap { return n }
|
||||
}
|
||||
return n
|
||||
|
|
@ -245,7 +245,7 @@ property SeqDT { log: int = 0, base: words, addbits: words, nb: words, ns: words
|
|||
function zstd_lits(s: pointer) -> words {
|
||||
var n = 1
|
||||
var i = 0
|
||||
while i < len(s) { if s[i] == 59 { n = n + 1 }; i = i + 1 }
|
||||
while i < len(s) { if s[i] == ';' { n += 1 }; i += 1 }
|
||||
let a = words(n)
|
||||
var idx = 0
|
||||
var cur = 0
|
||||
|
|
@ -253,11 +253,11 @@ function zstd_lits(s: pointer) -> words {
|
|||
i = 0
|
||||
while i < len(s) {
|
||||
let c = s[i]
|
||||
if c == 59 { if neg == 1 { cur = 0 - cur }; a[idx] = cur; idx = idx + 1; cur = 0; neg = 0 }
|
||||
else { if c == 45 { neg = 1 } else { cur = cur * 10 + (c - 48) } }
|
||||
i = i + 1
|
||||
if c == ';' { if neg == 1 { cur = -cur }; a[idx] = cur; idx += 1; cur = 0; neg = 0 }
|
||||
else { if c == '-' { neg = 1 } else { cur = cur * 10 + (c - 48) } }
|
||||
i += 1
|
||||
}
|
||||
if neg == 1 { cur = 0 - cur }
|
||||
if neg == 1 { cur = -cur }
|
||||
a[idx] = cur
|
||||
return a
|
||||
}
|
||||
|
|
@ -309,36 +309,35 @@ function zstd_seq_tables_init() -> void {
|
|||
if zstd_ll_base != null { return }
|
||||
let llb = words(36)
|
||||
var i = 0
|
||||
while i < 16 { llb[i] = i; i = i + 1 }
|
||||
llb[16]=16; llb[17]=18; llb[18]=20; llb[19]=22; llb[20]=24; llb[21]=28
|
||||
llb[22]=32; llb[23]=40; llb[24]=48; llb[25]=64; llb[26]=128; llb[27]=256
|
||||
llb[28]=512; llb[29]=1024; llb[30]=2048; llb[31]=4096; llb[32]=8192
|
||||
llb[33]=16384; llb[34]=32768; llb[35]=65536
|
||||
while i < 16 { llb[i] = i; i += 1 }
|
||||
llb[16] = 16; llb[17] = 18; llb[18] = 20; llb[19] = 22; llb[20] = 24; llb[21] = 28
|
||||
llb[22] = 32; llb[23] = 40; llb[24] = 48; llb[25] = 64; llb[26] = 128; llb[27] = 256
|
||||
llb[28] = 512; llb[29] = 1024; llb[30] = 2048; llb[31] = 4096; llb[32] = 8192
|
||||
llb[33] = 16384; llb[34] = 32768; llb[35] = 65536
|
||||
let llx = words(36)
|
||||
i = 0
|
||||
while i < 16 { llx[i] = 0; i = i + 1 }
|
||||
llx[16]=1; llx[17]=1; llx[18]=1; llx[19]=1; llx[20]=2; llx[21]=2
|
||||
llx[22]=3; llx[23]=3; llx[24]=4; llx[25]=6; llx[26]=7; llx[27]=8
|
||||
llx[28]=9; llx[29]=10; llx[30]=11; llx[31]=12; llx[32]=13; llx[33]=14
|
||||
llx[34]=15; llx[35]=16
|
||||
while i < 16 { llx[i] = 0; i += 1 }
|
||||
llx[16] = 1; llx[17] = 1; llx[18] = 1; llx[19] = 1; llx[20] = 2; llx[21] = 2
|
||||
llx[22] = 3; llx[23] = 3; llx[24] = 4; llx[25] = 6; llx[26] = 7; llx[27] = 8
|
||||
llx[28] = 9; llx[29] = 10; llx[30] = 11; llx[31] = 12; llx[32] = 13; llx[33] = 14
|
||||
llx[34] = 15; llx[35] = 16
|
||||
let mlb = words(53)
|
||||
i = 0
|
||||
while i < 32 { mlb[i] = i + 3; i = i + 1 }
|
||||
mlb[32]=35; mlb[33]=37; mlb[34]=39; mlb[35]=41; mlb[36]=43; mlb[37]=47
|
||||
mlb[38]=51; mlb[39]=59; mlb[40]=67; mlb[41]=83; mlb[42]=99; mlb[43]=131
|
||||
mlb[44]=259; mlb[45]=515; mlb[46]=1027; mlb[47]=2051; mlb[48]=4099
|
||||
mlb[49]=8195; mlb[50]=16387; mlb[51]=32771; mlb[52]=65539
|
||||
while i < 32 { mlb[i] = i + 3; i += 1 }
|
||||
mlb[32] = 35; mlb[33] = 37; mlb[34] = 39; mlb[35] = 41; mlb[36] = 43; mlb[37] = 47
|
||||
mlb[38] = 51; mlb[39] = 59; mlb[40] = 67; mlb[41] = 83; mlb[42] = 99; mlb[43] = 131
|
||||
mlb[44] = 259; mlb[45] = 515; mlb[46] = 1027; mlb[47] = 2051; mlb[48] = 4099
|
||||
mlb[49] = 8195; mlb[50] = 16387; mlb[51] = 32771; mlb[52] = 65539
|
||||
let mlx = words(53)
|
||||
i = 0
|
||||
while i < 32 { mlx[i] = 0; i = i + 1 }
|
||||
mlx[32]=1; mlx[33]=1; mlx[34]=1; mlx[35]=1; mlx[36]=2; mlx[37]=2
|
||||
mlx[38]=3; mlx[39]=3; mlx[40]=4; mlx[41]=4; mlx[42]=5; mlx[43]=7
|
||||
mlx[44]=8; mlx[45]=9; mlx[46]=10; mlx[47]=11; mlx[48]=12; mlx[49]=13
|
||||
mlx[50]=14; mlx[51]=15; mlx[52]=16
|
||||
while i < 32 { mlx[i] = 0; i += 1 }
|
||||
mlx[32] = 1; mlx[33] = 1; mlx[34] = 1; mlx[35] = 1; mlx[36] = 2; mlx[37] = 2
|
||||
mlx[38] = 3; mlx[39] = 3; mlx[40] = 4; mlx[41] = 4; mlx[42] = 5; mlx[43] = 7
|
||||
mlx[44] = 8; mlx[45] = 9; mlx[46] = 10; mlx[47] = 11; mlx[48] = 12; mlx[49] = 13
|
||||
mlx[50] = 14; mlx[51] = 15; mlx[52] = 16
|
||||
zstd_ll_base = llb; zstd_ll_bits = llx; zstd_ml_base = mlb; zstd_ml_bits = mlx
|
||||
}
|
||||
|
||||
|
||||
# ---- Huffman literal decode ------------------------------------------------
|
||||
property HufDT { maxbits: int = 0, sym: words, nb: words }
|
||||
|
||||
|
|
@ -347,7 +346,7 @@ property HufDT { maxbits: int = 0, sym: words, nb: words }
|
|||
function huf_build(weight: words, nweights: int) -> HufDT {
|
||||
var total = 0
|
||||
var i = 0
|
||||
while i < nweights { if weight[i] > 0 { total = total + (1 << (weight[i] - 1)) }; i = i + 1 }
|
||||
while i < nweights { if weight[i] > 0 { total = total + (1 << (weight[i] - 1)) }; i += 1 }
|
||||
let maxbits = zstd_highbit32(total) + 1
|
||||
let left = (1 << maxbits) - total
|
||||
weight[nweights] = zstd_highbit32(left) + 1 # last symbol's weight
|
||||
|
|
@ -360,13 +359,13 @@ function huf_build(weight: words, nweights: int) -> HufDT {
|
|||
# rank start positions: weight w occupies rankCount[w] << (w-1) cells, low weights first
|
||||
let rankcount = words(maxbits + 2)
|
||||
var w = 0
|
||||
while w <= maxbits { rankcount[w] = 0; w = w + 1 }
|
||||
while w <= maxbits { rankcount[w] = 0; w += 1 }
|
||||
i = 0
|
||||
while i < nsym { rankcount[weight[i]] = rankcount[weight[i]] + 1; i = i + 1 }
|
||||
while i < nsym { rankcount[weight[i]] = rankcount[weight[i]] + 1; i += 1 }
|
||||
let rankval = words(maxbits + 2)
|
||||
var next = 0
|
||||
w = 1
|
||||
while w <= maxbits { rankval[w] = next; next = next + (rankcount[w] << (w - 1)); w = w + 1 }
|
||||
while w <= maxbits { rankval[w] = next; next = next + (rankcount[w] << (w - 1)); w += 1 }
|
||||
i = 0
|
||||
while i < nsym {
|
||||
let ww = weight[i]
|
||||
|
|
@ -374,10 +373,10 @@ function huf_build(weight: words, nweights: int) -> HufDT {
|
|||
let len = 1 << (ww - 1)
|
||||
let nb = maxbits + 1 - ww
|
||||
var k = 0
|
||||
while k < len { dt.sym[rankval[ww] + k] = i; dt.nb[rankval[ww] + k] = nb; k = k + 1 }
|
||||
rankval[ww] = rankval[ww] + len
|
||||
while k < len { dt.sym[rankval[ww] + k] = i; dt.nb[rankval[ww] + k] = nb; k += 1 }
|
||||
rankval[ww] += len
|
||||
}
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
free(rankcount); free(rankval)
|
||||
return dt
|
||||
|
|
@ -387,7 +386,7 @@ function huf_build(weight: words, nweights: int) -> HufDT {
|
|||
# leaves zf_pos just past the description.
|
||||
function huf_read_tree() -> HufDT {
|
||||
let header = zf_src[zf_pos]
|
||||
zf_pos = zf_pos + 1
|
||||
zf_pos += 1
|
||||
let weight = words(256)
|
||||
if header >= 128 { # direct: (header-127) 4-bit weights
|
||||
let n = header - 127
|
||||
|
|
@ -397,7 +396,7 @@ function huf_read_tree() -> HufDT {
|
|||
var w = 0
|
||||
if (i & 1) == 0 { w = zf_src[bpos] >> 4 } else { w = zf_src[bpos] & 15 }
|
||||
weight[i] = w
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
zf_pos = zf_pos + ((n + 1) >> 1)
|
||||
return huf_build(weight, n)
|
||||
|
|
@ -423,8 +422,8 @@ function huf_decode_stream(dt: HufDT, out: pointer, at: int, n: int) -> void {
|
|||
while i < n {
|
||||
let bits = zstd_peek_rev(dt.maxbits)
|
||||
out[at + i] = dt.sym[bits]
|
||||
zb_cur = zb_cur + dt.nb[bits]
|
||||
i = i + 1
|
||||
zb_cur += dt.nb[bits]
|
||||
i += 1
|
||||
}
|
||||
}
|
||||
# peek maxbits bits (MSB-first) without consuming — for the Huffman table index.
|
||||
|
|
@ -466,7 +465,7 @@ function zstd_lit_decode(src: pointer, pos: int, blockend: int) -> int {
|
|||
let buf = bytes(regen + 1)
|
||||
let b = src[pos + hdr]
|
||||
var i = 0
|
||||
while i < regen { buf[i] = b; i = i + 1 }
|
||||
while i < regen { buf[i] = b; i += 1 }
|
||||
zstd_lit = buf
|
||||
zstd_litn = regen
|
||||
return pos + hdr + 1
|
||||
|
|
@ -507,7 +506,7 @@ function zstd_lit_huff(src: pointer, pos: int, ltype: int, sf: int) -> int {
|
|||
zf_init(src, hs)
|
||||
dt = huf_read_tree()
|
||||
let treesize = zf_bytepos() - hs
|
||||
hs = hs + treesize
|
||||
hs += treesize
|
||||
payn = comp - treesize
|
||||
zstd_huf_prev = dt
|
||||
}
|
||||
|
|
@ -523,11 +522,11 @@ function zstd_lit_huff(src: pointer, pos: int, ltype: int, sf: int) -> int {
|
|||
let seg = (regen + 3) / 4
|
||||
var o = hs + 6
|
||||
zb_init(src, o, s1); huf_decode_stream(dt, buf, 0, seg)
|
||||
o = o + s1
|
||||
o += s1
|
||||
zb_init(src, o, s2); huf_decode_stream(dt, buf, seg, seg)
|
||||
o = o + s2
|
||||
o += s2
|
||||
zb_init(src, o, s3); huf_decode_stream(dt, buf, 2 * seg, seg)
|
||||
o = o + s3
|
||||
o += s3
|
||||
zb_init(src, o, s4); huf_decode_stream(dt, buf, 3 * seg, regen - 3 * seg)
|
||||
}
|
||||
return pos + hdr + comp
|
||||
|
|
@ -572,7 +571,7 @@ function zstd_seq_table(src: pointer, sp: int, mode: int, kind: int, prev: SeqDT
|
|||
while u < size {
|
||||
dt.base[u] = zstd_seq_base(kind, ft.sym[u])
|
||||
dt.addbits[u] = zstd_seq_bits(kind, ft.sym[u])
|
||||
u = u + 1
|
||||
u += 1
|
||||
}
|
||||
return dt
|
||||
}
|
||||
|
|
@ -595,17 +594,17 @@ function zstd_decomp_block(src: pointer, bstart: int, bsize: int, out: pointer,
|
|||
let blockend = bstart + bsize
|
||||
var sp = zstd_lit_decode(src, bstart, blockend)
|
||||
var nseq = src[sp]
|
||||
if nseq < 128 { sp = sp + 1 }
|
||||
else { if nseq < 255 { nseq = ((nseq - 128) << 8) + src[sp + 1]; sp = sp + 2 }
|
||||
else { nseq = src[sp + 1] + (src[sp + 2] << 8) + 32512; sp = sp + 3 } }
|
||||
if nseq < 128 { sp += 1 }
|
||||
else { if nseq < 255 { nseq = ((nseq - 128) << 8) + src[sp + 1]; sp += 2 }
|
||||
else { nseq = src[sp + 1] + (src[sp + 2] << 8) + 32512; sp += 3 } }
|
||||
var op = opos
|
||||
var litpos = 0
|
||||
if nseq == 0 {
|
||||
var i = 0
|
||||
while i < zstd_litn { out[op] = zstd_lit[i]; op = op + 1; i = i + 1 }
|
||||
while i < zstd_litn { out[op] = zstd_lit[i]; op += 1; i += 1 }
|
||||
return op
|
||||
}
|
||||
let modes = src[sp]; sp = sp + 1
|
||||
let modes = src[sp]; sp += 1
|
||||
let llmode = (modes >> 6) & 3
|
||||
let ofmode = (modes >> 4) & 3
|
||||
let mlmode = (modes >> 2) & 3
|
||||
|
|
@ -641,53 +640,52 @@ function zstd_decomp_block(src: pointer, bstart: int, bsize: int, out: pointer,
|
|||
if ov == 1 { temp = zstd_rep1 }
|
||||
else { if ov == 3 { temp = zstd_rep0 - 1 }
|
||||
else { if ov >= 2 { temp = zstd_rep2 } else { temp = zstd_rep0 } } }
|
||||
if temp == 0 { temp = 0 - 1 }
|
||||
if temp == 0 { temp = -1 }
|
||||
if ov == 1 { } else { zstd_rep2 = zstd_rep1 }
|
||||
zstd_rep1 = zstd_rep0
|
||||
zstd_rep0 = temp
|
||||
offset = temp
|
||||
}
|
||||
}
|
||||
if mlBits > 0 { matchLen = matchLen + zb_read(mlBits) }
|
||||
if llBits > 0 { litLen = litLen + zb_read(llBits) }
|
||||
if mlBits > 0 { matchLen += zb_read(mlBits) }
|
||||
if llBits > 0 { litLen += zb_read(llBits) }
|
||||
var i = 0
|
||||
while i < litLen { out[op] = zstd_lit[litpos]; op = op + 1; litpos = litpos + 1; i = i + 1 }
|
||||
while i < litLen { out[op] = zstd_lit[litpos]; op += 1; litpos += 1; i += 1 }
|
||||
var k = 0
|
||||
while k < matchLen { out[op] = out[op - offset]; op = op + 1; k = k + 1 }
|
||||
q = q + 1
|
||||
while k < matchLen { out[op] = out[op - offset]; op += 1; k += 1 }
|
||||
q += 1
|
||||
if q < nseq {
|
||||
llstate = llt.ns[llstate] + zb_read(llt.nb[llstate])
|
||||
mlstate = mlt.ns[mlstate] + zb_read(mlt.nb[mlstate])
|
||||
ofstate = oft.ns[ofstate] + zb_read(oft.nb[ofstate])
|
||||
}
|
||||
}
|
||||
while litpos < zstd_litn { out[op] = zstd_lit[litpos]; op = op + 1; litpos = litpos + 1 }
|
||||
while litpos < zstd_litn { out[op] = zstd_lit[litpos]; op += 1; litpos += 1 }
|
||||
return op
|
||||
}
|
||||
|
||||
|
||||
# ---- frame / block loop ----------------------------------------------------
|
||||
var zstd_err: int = 0
|
||||
# decompress a single zstd frame. Returns bytes written, or -1.
|
||||
function z_zstd(src: pointer, len: int, out: pointer, cap: int) -> int {
|
||||
if len < 6 { return 0 - 1 }
|
||||
if src[0] != 40 { return 0 - 1 } # 0x28
|
||||
if src[1] != 181 { return 0 - 1 } # 0xB5
|
||||
if src[2] != 47 { return 0 - 1 } # 0x2F
|
||||
if src[3] != 253 { return 0 - 1 } # 0xFD
|
||||
if len < 6 { return -1 }
|
||||
if src[0] != '(' { return -1 } # 0x28
|
||||
if src[1] != 181 { return -1 } # 0xB5
|
||||
if src[2] != '/' { return -1 } # 0x2F
|
||||
if src[3] != 253 { return -1 } # 0xFD
|
||||
let fhd = src[4]
|
||||
let fcsFlag = (fhd >> 6) & 3
|
||||
let single = (fhd >> 5) & 1
|
||||
let dictFlag = fhd & 3
|
||||
var pos = 5
|
||||
if single == 0 { pos = pos + 1 } # window descriptor
|
||||
if dictFlag == 1 { pos = pos + 1 }
|
||||
if dictFlag == 2 { pos = pos + 2 }
|
||||
if dictFlag == 3 { pos = pos + 4 }
|
||||
if fcsFlag == 0 { if single == 1 { pos = pos + 1 } }
|
||||
if fcsFlag == 1 { pos = pos + 2 }
|
||||
if fcsFlag == 2 { pos = pos + 4 }
|
||||
if fcsFlag == 3 { pos = pos + 8 }
|
||||
if single == 0 { pos += 1 } # window descriptor
|
||||
if dictFlag == 1 { pos += 1 }
|
||||
if dictFlag == 2 { pos += 2 }
|
||||
if dictFlag == 3 { pos += 4 }
|
||||
if fcsFlag == 0 { if single == 1 { pos += 1 } }
|
||||
if fcsFlag == 1 { pos += 2 }
|
||||
if fcsFlag == 2 { pos += 4 }
|
||||
if fcsFlag == 3 { pos += 8 }
|
||||
# reset the repeat offsets per frame
|
||||
zstd_rep0 = 1; zstd_rep1 = 4; zstd_rep2 = 8
|
||||
zstd_huf_prev = null
|
||||
|
|
@ -695,27 +693,27 @@ function z_zstd(src: pointer, len: int, out: pointer, cap: int) -> int {
|
|||
var op = 0
|
||||
var last = 0
|
||||
while last == 0 {
|
||||
if pos + 3 > len { return 0 - 1 }
|
||||
if pos + 3 > len { return -1 }
|
||||
let bh = src[pos] | (src[pos + 1] << 8) | (src[pos + 2] << 16)
|
||||
pos = pos + 3
|
||||
pos += 3
|
||||
last = bh & 1
|
||||
let btype = (bh >> 1) & 3
|
||||
let bsize = bh >> 3
|
||||
if btype == 0 { # raw block
|
||||
var i = 0
|
||||
while i < bsize { out[op] = src[pos + i]; op = op + 1; i = i + 1 }
|
||||
pos = pos + bsize
|
||||
while i < bsize { out[op] = src[pos + i]; op += 1; i += 1 }
|
||||
pos += bsize
|
||||
} else { if btype == 1 { # RLE block: one byte * bsize
|
||||
let b = src[pos]
|
||||
var i = 0
|
||||
while i < bsize { out[op] = b; op = op + 1; i = i + 1 }
|
||||
pos = pos + 1
|
||||
while i < bsize { out[op] = b; op += 1; i += 1 }
|
||||
pos += 1
|
||||
} else { if btype == 2 { # compressed block
|
||||
op = zstd_decomp_block(src, pos, bsize, out, op, cap)
|
||||
pos = pos + bsize
|
||||
} else { return 0 - 1 } } } # reserved
|
||||
if op > cap { return 0 - 1 }
|
||||
if zstd_err != 0 { return 0 - 1 }
|
||||
pos += bsize
|
||||
} else { return -1 } } } # reserved
|
||||
if op > cap { return -1 }
|
||||
if zstd_err != 0 { return -1 }
|
||||
}
|
||||
return op
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue