Orkuncakilkaya
e4265f5fdb
A registry marked `@Machine(Deer.mood)` is the transitions of a machine over that enum field of the records a state's Table<Deer> holds. Its record has from and to (the enum's variants), on: string (an action's name, "" for a transition the tick asks), guard: fn(Row<Deer>, reads...) -> bool and enter: fn(Row<Deer>, reads...) -> void; the states are the enum's variants and the start is the field's default. The rows are data (an .lres or defs), the names the studio already edits. Written by the compiler (machines.ludic, machines_write.ludic): for each action an `on` names, a row reducer in the registry's file (named ..__machine__DeerSteps, so it sits beside the program's own row reducer on the same action, after it): the row's state, the first transition from it on that action whose guard passes, the field set, enter run - guards and enters called by name. When a row leaves a state on a guard alone, `state DeerStepsMachine` (the kept row view) and deer_steps_tick(m: mut DeerStepsMachine, s: mut Herd, reads...), one transition a row a tick. Nothing allocates. The table is the whole machine: the field written anywhere else - an assignment, or a `machine` block's become over it - is a type error (check_stmt.ludic, ck_machine_write). Guards and enters take the row first, are the record's module's, keep a row reducer's rules (and may be handed the row); a guard writes nothing through it. The graph is checked, each error at its row (in the .lres when the rows are there): a state never reached from the start, a state with no way out, an `on` naming no action or an action with no @Target, a self-transition with no guard, two ways out of a state on one trigger behind an unguarded first. Also refused: @Machine off a registry, a field that is not a plain enum with a default, a @Column field, no table (or two) of the record, a transitions record of another shape, a machine outside its table's state's module. ludic schema's code section gains `machines` (registry, record, field, enum, table, start, states, actions, tick, module, at); ludic deps names a machine's reducer `reducer Deer in Herd.deer on Spook (machine DeerSteps)`. vocab @Machine; docs annot-machine, kw-machine; LANGUAGE.md "A machine as data"; examples actions/machine (+ deer_steps.lres) and ten rejects; test.ludic feat, reject and schema cases (not run); changes/machines.md. Reseeded; bootstrap-cfree fixpoint holds (317642 lines); Maroon Lake's `ludic build --check` is clean against this tree. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
89 lines
3.3 KiB
Text
89 lines
3.3 KiB
Text
# check_env.ludic — L4: the checker's scopes and its errors. A scope is a mark in one list of
|
|
# (name, type) pairs; a lookup walks it from the end, so an inner name hides an outer one.
|
|
var ck_names: []pointer = new []pointer
|
|
var ck_tys: []pointer = new []pointer
|
|
var ck_ret: pointer = "void" # the result type of the function being checked
|
|
var ck_fn_node: Node = null # the function being checked (27.1: a machine's own may set its field)
|
|
var ck_mem_node: Node = null # the member expression ck_member typed last, and its base's type
|
|
var ck_mem_base: pointer = null
|
|
var ck_errors: int = 0
|
|
var ck_report: int = -1 # LUDIC_CHECK_REPORT=1: list every mix-up by category, fail nothing
|
|
|
|
var ck_top: int = 0 # the scope stack's height; the lists only grow
|
|
function ck_bind(name: pointer, ty: pointer) -> void {
|
|
var t = ty
|
|
if (t == "null") or t == null { t = "?" }
|
|
if ck_top < len(ck_names) {
|
|
ck_names[ck_top] = name
|
|
ck_tys[ck_top] = t
|
|
} else {
|
|
push(ck_names, name)
|
|
push(ck_tys, t)
|
|
}
|
|
ck_top += 1
|
|
ck_set_ro(false)
|
|
}
|
|
function ck_mark() -> int { return ck_top }
|
|
function ck_pop(m: int) -> void { ck_top = m }
|
|
function ck_local(name: pointer) -> int {
|
|
var i = ck_top - 1
|
|
while i >= 0 {
|
|
if ck_names[i] == name { return i }
|
|
i -= 1
|
|
}
|
|
return -1
|
|
}
|
|
function ck_reporting() -> bool {
|
|
if ck_report < 0 {
|
|
ck_report = 0
|
|
if getenv("LUDIC_CHECK_REPORT") != null { ck_report = 1 }
|
|
}
|
|
return ck_report == 1
|
|
}
|
|
# every mix-up is reported, not only the first: a type change shows everything it breaks at once
|
|
function ck_err(cat: pointer, n: Node, msg: pointer) -> void {
|
|
var file: pointer = ""
|
|
var line = 0
|
|
var col = 0
|
|
if n != null {
|
|
if n.file != null { file = n.file }
|
|
line = n.line
|
|
col = n.col
|
|
}
|
|
if g_diag_json and not ck_reporting() {
|
|
diag_add(file, line, col, "error", msg)
|
|
ck_errors += 1
|
|
return
|
|
}
|
|
var m = `{file}:{itoa(line)}: error: {msg}\n`
|
|
if ck_reporting() { m = `check[{cat}]: {file}:{itoa(line)}: {msg}\n` }
|
|
file_write(file_stderr(), m, len(m))
|
|
ck_errors += 1
|
|
}
|
|
# a value given where a type is wanted: `what` says where ("argument 2 of f", "x")
|
|
function ck_give(to: pointer, from: pointer, e: Node, what: pointer) -> void {
|
|
# a literal past 2^31 - 1 given to an int would lose its value: say so, rather than wrap it
|
|
if e != null and e.kind == E_INT and e.s != null and ((to == "int") or (to == "byte") or (to == "fixed")) {
|
|
ck_err("literal", e, `{what} wants {ck_a(to)} and {e.s} does not fit one; it is a long`)
|
|
return
|
|
}
|
|
let cat = ck_mismatch(to, from, e)
|
|
if cat == null { return }
|
|
if (cat == "slice-pointer") {
|
|
ck_err(cat, e, `{what} wants a pointer and this is {ck_a(from)}: take the slice itself, or data_of(xs) in unsafe code`)
|
|
return
|
|
}
|
|
if (cat == "pointer-slice") {
|
|
ck_err(cat, e, `{what} wants {ck_a(to)} and this is a pointer: a slice is made with words(n), floats(n) or new, not from an address`)
|
|
return
|
|
}
|
|
if (cat == "key") and ck_is_key(to) {
|
|
ck_err(cat, e, `{what} wants a Key and this is {ck_a(from)}: a key is written k"module.purpose" (kn"..." for a plural)`)
|
|
return
|
|
}
|
|
if (cat == "key") {
|
|
ck_err(cat, e, `{what} wants {ck_a(to)} and this is a Key: text is made from a key (tr(key)), never the key itself`)
|
|
return
|
|
}
|
|
ck_err(cat, e, `{what} wants {ck_a(to)} and this is {ck_a(from)}`)
|
|
}
|