76 lines
2.8 KiB
Text
76 lines
2.8 KiB
Text
# eval_text.ludic - a text with holes ("{n} left") worked out: its pieces are found in the memo by
|
|
# comparing in place, so the text it was last frame (and the frame before) is its kept Value, and a
|
|
# text is built only the first time it reads that way. The memo is bounded; past it a text is built as ever
|
|
function ev_text(ui_st: mut UiState, x: UiExpr, e: UiEnv) -> Val {
|
|
let depth = ui_st.tx_depth # a hole may hold a text of its own: a kept list of pieces a depth
|
|
@alloc_ok("once per depth of nesting, then kept")
|
|
while len(ui_st.tx_pieces) <= depth { push(ui_st.tx_pieces, new []string) }
|
|
let ps = ui_st.tx_pieces[depth]
|
|
ui_st.tx_depth = depth + 1
|
|
List.clear(ps)
|
|
for i in 0 .. len(x.args) { tx_piece(ui_st, ps, ui_eval(ui_st, x.args[i], e)) }
|
|
ui_st.tx_depth = depth
|
|
return tx_memo(ui_st, ps)
|
|
}
|
|
# the text these pieces join into, from the memo when it read this way before, else joined and kept
|
|
function tx_memo(ui_st: mut UiState, ps: []string) -> Val {
|
|
let m = mm_of(ui_st)
|
|
var h = 216613626 ^ (MM_TEXT & 255)
|
|
for p in 0 .. len(ps) {
|
|
let t = ps[p]
|
|
for i in 0 .. len(t) { h = ((h ^ t[i]) * 16777619) & 2147483647 }
|
|
}
|
|
var at = h & (MM_CAP - 1)
|
|
while m.slots[at] != 0 {
|
|
let i = m.slots[at] - 1
|
|
if m.tags[i] == MM_TEXT and tx_same(ps, m.keys[i]) { return m.vals[i] }
|
|
at = (at + 1) & (MM_CAP - 1)
|
|
}
|
|
return ev_text_new(ui_st, m, ps)
|
|
}
|
|
# a text read this way for the first time: joined, and kept in the memo with its Value
|
|
@alloc_ok("a memo miss: once per distinct text, bounded by MM_CAP")
|
|
function ev_text_new(ui_st: mut UiState, m: UiMemo, ps: []string) -> Val {
|
|
var out = ""
|
|
for p in 0 .. len(ps) { out = out + ps[p] }
|
|
let j = mm_add(m, MM_TEXT, out)
|
|
if j < 0 { return uv_str(ui_st, out) }
|
|
m.vals[j] = Value.str(out)
|
|
return m.vals[j]
|
|
}
|
|
function tx_same(ps: []string, k: string) -> bool {
|
|
var at = 0
|
|
for p in 0 .. len(ps) {
|
|
if not sat(k, at, ps[p]) { return false }
|
|
at += len(ps[p])
|
|
}
|
|
return at == len(k)
|
|
}
|
|
# a hole's value as pieces: a float to one decimal from kept texts (its whole part from mm_int, its tenth a
|
|
# literal), so a bar's width moving every frame makes no string - and reads 42.5%, never 7.470598e-07%
|
|
function tx_piece(ui_st: mut UiState, ps: []string, v: Val) -> void {
|
|
let k = Value.kind(v)
|
|
if k != 2 and k != 7 {
|
|
ui_kept(ps, vl_text_u(ui_st, v))
|
|
return
|
|
}
|
|
var t = int(Math.round(Value.as_float(v) * 10.0))
|
|
if t < 0 {
|
|
ui_kept(ps, "-")
|
|
t = 0 - t
|
|
}
|
|
ui_kept(ps, mm_int(ui_st, t / 10))
|
|
let d = t % 10
|
|
if d != 0 { ui_kept(ps, tx_tenth(d)) }
|
|
}
|
|
function tx_tenth(d: int) -> string {
|
|
if d == 1 { return ".1" }
|
|
if d == 2 { return ".2" }
|
|
if d == 3 { return ".3" }
|
|
if d == 4 { return ".4" }
|
|
if d == 5 { return ".5" }
|
|
if d == 6 { return ".6" }
|
|
if d == 7 { return ".7" }
|
|
if d == 8 { return ".8" }
|
|
return ".9"
|
|
}
|