workshopsoft/ludic
2
0
Fork 0
Code Issues Pull requests Projects Releases 26 Packages Wiki Activity Actions
ludic/runtime/native/lres.ludic

852 lines
24 KiB
Text
Raw Blame History

# ============================================================================
# lres.ludic — the reader behind map-scoped tables (`@PerMap registry R of T from "file.lres"`).
#
# A @PerMap registry's rows are not compiled in: they are read when a map loads, or a chunk comes
# in, from `<maps root>/<map>/<file>`. This file reads one .lres - the grammar the compiler's
# resource files use: entries `key { field: value, ... }`, nested records `{ ... }`, lists `[ ... ]`,
# "strings" (\n \r \t \0 and \x for any other x), text keys k"a.b" and kn"a.b", numbers (-3, 0x1F, 1.5, 2e-3), true / false, a
# constant by NAME, `fn name`, and `#` comments to the end of a line; commas and newlines separate.
#
# ludicc splices it when a program declares a @PerMap registry, and writes the typed fill for each
# record (`r__fill_T`, frontend/permap_gen.ludic) on top of the few questions below.
#
# NOTHING HERE ALLOCATES PAST ITS HIGH WATER. A tree is a flat pool of nodes kept as parallel
# lists that are reused from one file to the next (`nn` is how many are in use); the file's bytes go
# into a buffer that grows only when a bigger file comes; a string is unescaped into a kept scratch
# buffer and interned (intern() copies a text once and hands the same one back after), so a string
# field is safe to keep; the path being opened is built in a kept buffer, so no concatenation. Only
# an error's message is made on the heap, and only when a file is wrong.
# ============================================================================
numbers float
const LRES_K_REC: int = 1
const LRES_K_LIST: int = 2
const LRES_K_INT: int = 3
const LRES_K_FLOAT: int = 4
const LRES_K_STR: int = 5
const LRES_K_BOOL: int = 6
const LRES_K_NAME: int = 7
const LRES_K_FN: int = 8
const LRES_K_KEY: int = 9 # k"pause.resume" / kn"catch.count": a text key, kept after its marker byte
# one reader: the file, its tree, the program's constants by name, and the first error
property LresTree {
buf: pointer = null # the file's bytes, NUL-terminated; grows to the largest file read
bcap: int = 0
n: int = 0 # bytes in the file being read
sb: pointer = null # a string being unescaped, before it is interned
scap: int = 0
pb: pointer = null # the path being opened, NUL-terminated
pcap: int = 0
plen: int = 0
kind: []int = new []int # per node: LRES_K_*
ival: []int = new []int # an int, a bool (0/1)
fval: []float = new []float # a float (an int's value too)
sval: []string = new []string # a string, a name, a fn's name (interned)
name: []string = new []string # an entry's key, a field's name ("" in a list)
local: bool = false # a chunk's file: an entry's key is left in the file (koff, klen), never interned
koff: []int = new []int # per entry, when local: where its key starts in buf ...
klen: []int = new []int # ... and how long it is
kid: []int = new []int # the first child of a record or a list, -1
nxt: []int = new []int # the next sibling, -1
line: []int = new []int
col: []int = new []int
nn: int = 0 # nodes in use
top: int = -1 # the first entry
ntop: int = 0 # how many entries
p: int = 0 # the cursor, its line and where that line starts
ln: int = 1
ls: int = 0
bad: bool = false
err: string = "" # "file:line:col: what" - the first thing wrong
cready: bool = false # the constants' index is built (on the first name read)
ctab: string = "" # "NAME i 12;NAME f 1.5;..." sorted by name, written by the compiler
coff: []int = new []int
clen: []int = new []int
cflt: []bool = new []bool
civ: []int = new []int
cfv: []float = new []float
}
# a chunk slot's own keys: a chunked table's keys are unique across a map (t0 .. t91842), so interning
# them would fill the intern table as a player walks and keep every one for good. Row i's key lives
# in buffer i, rewritten in place when the slot is refilled and grown only past the longest key it held.
property LresKeys {
bufs: []pointer = new []pointer
caps: []int = new []int
}
# entry e's key as row i of a slot: in the slot's own buffer, or interned for a whole-map table (ks null)
@alloc_ok("a slot's key buffer past the most rows or the longest key it has held (high water)")
function lres_key_of(t: LresTree, e: int, ks: LresKeys, i: int) -> string {
if ks == null or not t.local { return t.name[e] }
let n = t.klen[e]
if i >= len(ks.bufs) {
var c = 16
while c < n + 1 { c = c * 2 }
push(ks.bufs, bytes(c))
push(ks.caps, c)
} else if ks.caps[i] < n + 1 {
var c = ks.caps[i] * 2
while c < n + 1 { c = c * 2 }
ks.bufs[i] = resize(ks.bufs[i], c)
ks.caps[i] = c
}
let kb = ks.bufs[i]
let buf = t.buf
let a = t.koff[e]
var j = 0
while j < n {
kb[j] = buf[a + j]
j += 1
}
kb[n] = 0
let k: string = kb
return k
}
# a key -> row index table over interned keys: open addressing, rebuilt in place on every load
property LresHash {
slot: []int = new []int # a row's index + 1; 0 is empty
keys: []string = new []string
mask: int = 0
}
# ---- the path ------------------------------------------------------------------------------------
function lres_path_room(t: LresTree, need: int) -> void {
if need <= t.pcap { return }
var c = t.pcap * 2
if c < 256 { c = 256 }
while c < need { c = c * 2 }
if t.pb == null { t.pb = bytes(c) } else { t.pb = resize(t.pb, c) }
t.pcap = c
}
function lres_path_begin(t: LresTree, root: string) -> void {
t.plen = 0
lres_path_room(t, 1)
let pb = t.pb
pb[0] = 0
lres_path_add(t, root)
}
function lres_path_add(t: LresTree, s: string) -> void {
let k = len(s)
lres_path_room(t, t.plen + k + 1)
let pb = t.pb
var i = 0
while i < k {
pb[t.plen + i] = s[i]
i += 1
}
t.plen += k
pb[t.plen] = 0
}
# a chunk's coordinate, as decimal: -3 is "-3"
function lres_path_int(t: LresTree, v: int) -> void {
lres_path_room(t, t.plen + 13)
let pb = t.pb
var x = v
if x < 0 {
pb[t.plen] = '-'
t.plen += 1
x = 0 - x
}
let d0 = t.plen
if x == 0 {
pb[t.plen] = '0'
t.plen += 1
}
while x > 0 {
pb[t.plen] = '0' + x % 10
t.plen += 1
x = x / 10
}
var a = d0
var b = t.plen - 1
while a < b {
let c = pb[a]
pb[a] = pb[b]
pb[b] = c
a += 1
b -= 1
}
pb[t.plen] = 0
}
# ---- reading -------------------------------------------------------------------------------------
# the file at the path built: 1 read and parsed, 0 there is no such file, -1 it is wrong (t.err)
function lres_read(t: LresTree) -> int {
t.bad = false
t.err = ""
t.nn = 0
t.top = -1
t.ntop = 0
let f = file_open(t.pb, "rb")
if f == null { return 0 }
file_seek(f, 0, 2)
var n = file_tell(f)
file_seek(f, 0, 0)
if n < 0 { n = 0 }
if n + 1 > t.bcap {
var c = t.bcap * 2
if c < 4096 { c = 4096 }
while c < n + 1 { c = c * 2 }
if t.buf == null { t.buf = bytes(c) } else { t.buf = resize(t.buf, c) }
t.bcap = c
}
let buf = t.buf
var got = 0
if n > 0 { got = file_read(f, buf, n) }
file_close(f)
if got < 0 { got = 0 }
t.n = got
buf[got] = 0
lres_parse(t)
if t.bad { return -1 }
return 1
}
# a whole-map table's file that is not there: an error (a chunk's is an empty chunk)
function lres_missing(t: LresTree) -> void {
t.bad = true
t.err = `{lres_path_text(t)}: there is no such file`
}
function lres_path_text(t: LresTree) -> string {
if t.pb == null { return "" }
return `{t.pb}`
}
# ---- errors --------------------------------------------------------------------------------------
# the first thing wrong, at a line and column of the file
function lres_fail_at(t: LresTree, line: int, col: int, msg: string) -> void {
if t.bad { return }
t.bad = true
t.err = `{lres_path_text(t)}:{line}:{col}: {msg}`
}
function lres_fail(t: LresTree, msg: string) -> void {
lres_fail_at(t, t.ln, t.p - t.ls + 1, msg)
}
function lres_fail_node(t: LresTree, n: int, msg: string) -> void {
lres_fail_at(t, t.line[n], t.col[n], msg)
}
function lres_ok(t: LresTree) -> bool { return not t.bad }
function lres_error(t: LresTree) -> string { return t.err }
# ---- the tree ------------------------------------------------------------------------------------
# a node, reused from an earlier file when the pool has one
function lres_node(t: LresTree, kind: int, line: int, col: int) -> int {
let i = t.nn
if i < len(t.kind) {
t.kind[i] = kind
t.ival[i] = 0
t.fval[i] = 0.0
t.sval[i] = ""
t.name[i] = ""
t.kid[i] = -1
t.nxt[i] = -1
t.line[i] = line
t.col[i] = col
t.koff[i] = 0
t.klen[i] = 0
} else {
push(t.kind, kind)
push(t.ival, 0)
push(t.fval, 0.0)
push(t.sval, "")
push(t.name, "")
push(t.kid, -1)
push(t.nxt, -1)
push(t.line, line)
push(t.col, col)
push(t.koff, 0)
push(t.klen, 0)
}
t.nn = i + 1
return i
}
function lres_ch(t: LresTree) -> int {
if t.p >= t.n { return 0 }
let buf = t.buf
return buf[t.p]
}
function lres_is_alpha(c: int) -> bool {
return (c >= 'a' and c <= 'z') or (c >= 'A' and c <= 'Z') or c == '_'
}
function lres_is_digit(c: int) -> bool { return c >= '0' and c <= '9' }
# blanks, newlines, commas and comments
function lres_skip(t: LresTree) -> void {
let buf = t.buf
while t.p < t.n {
let c = buf[t.p]
if c == ' ' or c == 9 or c == 13 or c == ',' {
t.p += 1
} else if c == 10 {
t.p += 1
t.ln += 1
t.ls = t.p
} else if c == '#' {
while t.p < t.n and buf[t.p] != 10 { t.p += 1 }
} else {
return
}
}
}
# the scratch string, grown to hold n bytes and its NUL
function lres_sb_room(t: LresTree, n: int) -> void {
if n <= t.scap { return }
var c = t.scap * 2
if c < 256 { c = 256 }
while c < n { c = c * 2 }
if t.sb == null { t.sb = bytes(c) } else { t.sb = resize(t.sb, c) }
t.scap = c
}
# bytes a..b of the file, interned
function lres_intern(t: LresTree, a: int, b: int) -> string {
lres_sb_room(t, b - a + 1)
let sb = t.sb
let buf = t.buf
var i = a
while i < b {
sb[i - a] = buf[i]
i += 1
}
sb[b - a] = 0
return intern(sb)
}
function lres_ident(t: LresTree) -> string {
let a = lres_ident_at(t)
if a < 0 { return "" }
return lres_intern(t, a, t.p)
}
# a name's first byte, the cursor left past it; -1 (and the tree bad) when there is none
function lres_ident_at(t: LresTree) -> int {
let c = lres_ch(t)
if not lres_is_alpha(c) {
lres_fail(t, "a name was expected here")
return -1
}
let buf = t.buf
let a = t.p
while t.p < t.n and (lres_is_alpha(buf[t.p]) or lres_is_digit(buf[t.p])) { t.p += 1 }
return a
}
function lres_link(t: LresTree, parent: int, last: int, k: int) -> void {
if last < 0 { t.kid[parent] = k } else { t.nxt[last] = k }
}
# the whole file: its entries, each `key { ... }`
function lres_parse(t: LresTree) -> void {
t.p = 0
t.ln = 1
t.ls = 0
var last = -1
while not t.bad {
lres_skip(t)
if t.p >= t.n { return }
let line = t.ln
let col = t.p - t.ls + 1
let ka = lres_ident_at(t)
if t.bad { return }
let kb = t.p
var key = ""
if not t.local { key = lres_intern(t, ka, kb) }
lres_skip(t)
if lres_ch(t) != '{' {
if t.local { key = lres_intern(t, ka, kb) } # a wrong file only: its message names the key
lres_fail(t, `the entry {key} is its key and a record: {key} {{ field: value }}`)
return
}
let e = lres_record(t)
if t.bad { return }
t.name[e] = key
t.koff[e] = ka
t.klen[e] = kb - ka
t.line[e] = line
t.col[e] = col
if last < 0 { t.top = e } else { t.nxt[last] = e }
last = e
t.ntop += 1
}
}
function lres_record(t: LresTree) -> int {
let r = lres_node(t, LRES_K_REC, t.ln, t.p - t.ls + 1)
let oline = t.ln
let ocol = t.p - t.ls + 1
t.p += 1
var last = -1
while not t.bad {
lres_skip(t)
let c = lres_ch(t)
if c == '}' {
t.p += 1
return r
}
if t.p >= t.n {
lres_fail_at(t, oline, ocol, "this record is never closed with }")
return r
}
let fline = t.ln
let fcol = t.p - t.ls + 1
let fname = lres_ident(t)
if t.bad { return r }
lres_skip(t)
if lres_ch(t) != ':' {
lres_fail(t, `the field {fname} wants a ':' and its value`)
return r
}
t.p += 1
lres_skip(t)
let v = lres_value(t)
if t.bad { return r }
t.name[v] = fname
t.line[v] = fline
t.col[v] = fcol
lres_link(t, r, last, v)
last = v
}
return r
}
function lres_list(t: LresTree) -> int {
let l = lres_node(t, LRES_K_LIST, t.ln, t.p - t.ls + 1)
let oline = t.ln
let ocol = t.p - t.ls + 1
t.p += 1
var last = -1
while not t.bad {
lres_skip(t)
let c = lres_ch(t)
if c == ']' {
t.p += 1
return l
}
if t.p >= t.n {
lres_fail_at(t, oline, ocol, "this list is never closed with ]")
return l
}
let v = lres_value(t)
if t.bad { return l }
lres_link(t, l, last, v)
last = v
}
return l
}
function lres_value(t: LresTree) -> int {
let c = lres_ch(t)
if c == '{' { return lres_record(t) }
if c == '[' { return lres_list(t) }
if c == '"' { return lres_string(t) }
if c == '-' or c == '+' or c == '.' or lres_is_digit(c) { return lres_number(t) }
if c == 'k' and lres_key_ahead(t) { return lres_keylit(t) }
if lres_is_alpha(c) {
let line = t.ln
let col = t.p - t.ls + 1
let id = lres_ident(t)
if id == "true" or id == "false" {
let b = lres_node(t, LRES_K_BOOL, line, col)
if id == "true" { t.ival[b] = 1 }
return b
}
if id == "fn" {
let buf = t.buf
while t.p < t.n and (buf[t.p] == ' ' or buf[t.p] == 9) { t.p += 1 }
let f = lres_node(t, LRES_K_FN, line, col)
t.sval[f] = lres_ident(t)
return f
}
let k = lres_node(t, LRES_K_NAME, line, col)
t.sval[k] = id
return k
}
lres_fail(t, "a value was expected: a number, a \"string\", true, false, a NAME, fn name, { ... } or [ ... ]")
return lres_node(t, LRES_K_INT, t.ln, t.p - t.ls + 1)
}
function lres_hex(c: int) -> int {
if c >= '0' and c <= '9' { return c - '0' }
if c >= 'a' and c <= 'f' { return c - 'a' + 10 }
if c >= 'A' and c <= 'F' { return c - 'A' + 10 }
return -1
}
function lres_number(t: LresTree) -> int {
let line = t.ln
let col = t.p - t.ls + 1
let buf = t.buf
let a = t.p
var neg = false
if buf[t.p] == '-' {
neg = true
t.p += 1
} else if buf[t.p] == '+' {
t.p += 1
}
if t.p + 1 < t.n and buf[t.p] == '0' and (buf[t.p + 1] == 'x' or buf[t.p + 1] == 'X') {
t.p += 2
var v = 0
var any = false
while t.p < t.n and (lres_hex(buf[t.p]) >= 0 or buf[t.p] == '_') {
if buf[t.p] != '_' {
v = v * 16 + lres_hex(buf[t.p])
any = true
}
t.p += 1
}
if not any { lres_fail_at(t, line, col, "0x wants hex digits") }
if neg { v = 0 - v }
let h = lres_node(t, LRES_K_INT, line, col)
t.ival[h] = v
t.fval[h] = float(v)
return lres_number_end(t, h)
}
var v = 0
var digits = 0
var fl = false
while t.p < t.n {
let c = buf[t.p]
if lres_is_digit(c) {
v = v * 10 + (c - '0')
digits += 1
t.p += 1
} else if c == '_' {
t.p += 1
} else if c == '.' and not fl and t.p + 1 < t.n and lres_is_digit(buf[t.p + 1]) {
fl = true
t.p += 1
} else if (c == 'e' or c == 'E') and digits > 0 {
fl = true
t.p += 1
if t.p < t.n and (buf[t.p] == '-' or buf[t.p] == '+') { t.p += 1 }
} else {
break
}
}
if digits == 0 {
lres_fail_at(t, line, col, "a number was expected")
return lres_node(t, LRES_K_INT, line, col)
}
if not fl {
if neg { v = 0 - v }
let i = lres_node(t, LRES_K_INT, line, col)
t.ival[i] = v
t.fval[i] = float(v)
return lres_number_end(t, i)
}
lres_sb_room(t, t.p - a + 1)
let sb = t.sb
var k = 0
var j = a
while j < t.p {
if buf[j] != '_' {
sb[k] = buf[j]
k += 1
}
j += 1
}
sb[k] = 0
let f = lres_node(t, LRES_K_FLOAT, line, col)
t.fval[f] = Text.to_float(sb)
return lres_number_end(t, f)
}
# a number runs into nothing: `12ab` is wrong, not 12 and a name
function lres_number_end(t: LresTree, k: int) -> int {
let c = lres_ch(t)
if lres_is_alpha(c) or lres_is_digit(c) { lres_fail(t, "this is not a number") }
return k
}
# k"..." or kn"...", the cursor on the k
function lres_key_ahead(t: LresTree) -> bool {
let buf = t.buf
if t.p + 1 < t.n and buf[t.p + 1] == '"' { return true }
return t.p + 2 < t.n and buf[t.p + 1] == 'n' and buf[t.p + 2] == '"'
}
# the key's text after its marker byte (1, or 2 for a plural), as the compiler writes k"..."
function lres_keylit(t: LresTree) -> int {
let line = t.ln
let col = t.p - t.ls + 1
let buf = t.buf
var mark = 1
t.p += 1
if buf[t.p] == 'n' {
mark = 2
t.p += 1
}
let s = lres_string_marked(t, mark)
t.kind[s] = LRES_K_KEY
t.line[s] = line
t.col[s] = col
return s
}
function lres_string(t: LresTree) -> int { return lres_string_marked(t, 0) }
function lres_string_marked(t: LresTree, mark: int) -> int {
let s = lres_node(t, LRES_K_STR, t.ln, t.p - t.ls + 1)
let oline = t.ln
let ocol = t.p - t.ls + 1
t.p += 1
let buf = t.buf
var k = 0
if mark > 0 {
lres_sb_room(t, 2)
let sb0 = t.sb
sb0[0] = mark
k = 1
}
while true {
if t.p >= t.n {
lres_fail_at(t, oline, ocol, "this string is never closed with \"")
return s
}
var c = buf[t.p]
if c == '"' {
t.p += 1
break
}
if c == 10 {
t.ln += 1
t.ls = t.p + 1
}
if c == 92 and t.p + 1 < t.n {
t.p += 1
c = buf[t.p]
if c == 'n' { c = 10 }
else if c == 'r' { c = 13 }
else if c == 't' { c = 9 }
else if c == '0' { c = 0 }
}
lres_sb_room(t, k + 2)
let sb = t.sb
sb[k] = c
k += 1
t.p += 1
}
lres_sb_room(t, k + 1)
let sb = t.sb
sb[k] = 0
t.sval[s] = intern(sb)
return s
}
# ---- the questions a typed fill asks --------------------------------------------------------------
function lres_top(t: LresTree) -> int { return t.top }
function lres_entries(t: LresTree) -> int { return t.ntop }
function lres_kid(t: LresTree, n: int) -> int { return t.kid[n] }
function lres_next(t: LresTree, n: int) -> int { return t.nxt[n] }
function lres_name(t: LresTree, n: int) -> string { return t.name[n] }
function lres_kind_text(k: int) -> string {
if k == LRES_K_REC { return "a record" }
if k == LRES_K_LIST { return "a list" }
if k == LRES_K_INT { return "an int" }
if k == LRES_K_FLOAT { return "a float" }
if k == LRES_K_STR { return "a string" }
if k == LRES_K_BOOL { return "true or false" }
if k == LRES_K_NAME { return "a name" }
if k == LRES_K_KEY { return "a key" }
return "fn name"
}
function lres_want(t: LresTree, n: int, what: string) -> void {
var who = t.name[n]
if len(who) == 0 { who = "an element" }
lres_fail_node(t, n, `{who} wants {what}, not {lres_kind_text(t.kind[n])}`)
}
function lres_int(t: LresTree, n: int) -> int {
let k = t.kind[n]
if k == LRES_K_INT { return t.ival[n] }
if k == LRES_K_NAME {
let c = lres_const(t, t.sval[n])
if c >= 0 and not t.cflt[c] { return t.civ[c] }
if c >= 0 { lres_fail_node(t, n, `{t.sval[n]} is a float constant, and {t.name[n]} wants an int`) }
else { lres_fail_node(t, n, `unknown constant {t.sval[n]}`) }
return 0
}
lres_want(t, n, "an int")
return 0
}
function lres_float(t: LresTree, n: int) -> float {
let k = t.kind[n]
if k == LRES_K_FLOAT or k == LRES_K_INT { return t.fval[n] }
if k == LRES_K_NAME {
let c = lres_const(t, t.sval[n])
if c >= 0 {
if t.cflt[c] { return t.cfv[c] }
return float(t.civ[c])
}
lres_fail_node(t, n, `unknown constant {t.sval[n]}`)
return 0.0
}
lres_want(t, n, "a float")
return 0.0
}
function lres_bool(t: LresTree, n: int) -> bool {
if t.kind[n] == LRES_K_BOOL { return t.ival[n] != 0 }
lres_want(t, n, "true or false")
return false
}
function lres_str(t: LresTree, n: int) -> string {
if t.kind[n] == LRES_K_STR { return t.sval[n] }
lres_want(t, n, "a \"string\"")
return ""
}
# a Key field's value: k"..." (its marker kept, as the compiler writes the literal)
function lres_key(t: LresTree, n: int) -> Key {
if t.kind[n] == LRES_K_KEY {
let p: pointer = t.sval[n]
return p
}
lres_want(t, n, "a key k\"...\"")
return null
}
# `fn name`: the name, which the fill resolves among the program's functions of the field's type
function lres_fn(t: LresTree, n: int) -> string {
if t.kind[n] == LRES_K_FN { return t.sval[n] }
lres_want(t, n, "fn name")
return ""
}
function lres_is_rec(t: LresTree, n: int) -> bool {
if t.kind[n] == LRES_K_REC { return true }
lres_want(t, n, "a record { ... }")
return false
}
function lres_is_list(t: LresTree, n: int) -> bool {
if t.kind[n] == LRES_K_LIST { return true }
lres_want(t, n, "a list [ ... ]")
return false
}
function lres_no_field(t: LresTree, n: int, rec: string) -> void {
lres_fail_node(t, n, `{rec} has no field {t.name[n]}`)
}
function lres_no_fn(t: LresTree, n: int, ty: string) -> void {
lres_fail_node(t, n, `there is no function {t.sval[n]} of type {ty}`)
}
function lres_dup(t: LresTree, n: int) -> void {
var key = t.name[n]
if t.local { key = lres_intern(t, t.koff[n], t.koff[n] + t.klen[n]) } # a wrong file only
lres_fail_node(t, n, `the key {key} is written twice`)
}
# ---- the program's constants, by name ------------------------------------------------------------
# lres_consts__() is written by the compiler: every int and float constant it could evaluate, as
# "NAME i 12;NAME f 1.5;", sorted by name. The index is made once, on the first name a file uses.
function lres_consts_index(t: LresTree) -> void {
t.cready = true
let s = lres_consts__()
t.ctab = s
let n = len(s)
var i = 0
while i < n {
let a = i
while i < n and s[i] != ' ' { i += 1 }
let nl = i - a
i += 1
let fl = i < n and s[i] == 'f'
i += 2
let va = i
while i < n and s[i] != ';' { i += 1 }
push(t.coff, a)
push(t.clen, nl)
push(t.cflt, fl)
if fl {
lres_sb_room(t, i - va + 1)
let sb = t.sb
var j = va
while j < i {
sb[j - va] = s[j]
j += 1
}
sb[i - va] = 0
push(t.civ, 0)
push(t.cfv, Text.to_float(sb))
} else {
var v = 0
var neg = false
var j = va
if j < i and s[j] == '-' {
neg = true
j += 1
}
while j < i {
v = v * 10 + (s[j] - '0')
j += 1
}
if neg { v = 0 - v }
push(t.civ, v)
push(t.cfv, 0.0)
}
i += 1
}
}
# name against the table's entry c: <0, 0, >0
function lres_const_cmp(t: LresTree, name: string, c: int) -> int {
let s = t.ctab
let off = t.coff[c]
let m = t.clen[c]
let k = len(name)
var i = 0
while i < k and i < m {
let x = name[i]
let y = s[off + i]
if x != y { return x - y }
i += 1
}
return k - m
}
# the constant called name: its index in the table, or -1
function lres_const(t: LresTree, name: string) -> int {
if not t.cready { lres_consts_index(t) }
var lo = 0
var hi = len(t.coff) - 1
while lo <= hi {
let mid = (lo + hi) / 2
let d = lres_const_cmp(t, name, mid)
if d == 0 { return mid }
if d < 0 { hi = mid - 1 } else { lo = mid + 1 }
}
return -1
}
# ---- rows by key ---------------------------------------------------------------------------------
function lres_hash_of(s: string) -> int {
var h = -2128831035
let n = len(s)
var i = 0
while i < n {
h = (h ^ s[i]) * 16777619
i += 1
}
return h
}
# empty, sized for n keys; the slots grow only past the most a table has ever had
function lres_hash_reset(h: LresHash, n: int) -> void {
var size = 16
while size < n * 2 { size = size * 2 }
while len(h.slot) < size {
push(h.slot, 0)
push(h.keys, "")
}
var i = 0
while i < size {
h.slot[i] = 0
h.keys[i] = ""
i += 1
}
h.mask = size - 1
}
# key -> i; when the key is already there, the index it has (and nothing changes), else -1
function lres_hash_put(h: LresHash, key: string, i: int) -> int {
var at = lres_hash_of(key) & h.mask
while true {
let v = h.slot[at]
if v == 0 {
h.slot[at] = i + 1
h.keys[at] = key
return -1
}
if h.keys[at] == key { return v - 1 }
at = (at + 1) & h.mask
}
return -1
}
# the row whose key is key, or -1
function lres_hash_get(h: LresHash, key: string) -> int {
if h.mask == 0 { return -1 }
var at = lres_hash_of(key) & h.mask
while true {
let v = h.slot[at]
if v == 0 { return -1 }
if h.keys[at] == key { return v - 1 }
at = (at + 1) & h.mask
}
return -1
}
Reference in a new issue View git blame Copy permalink