Orkuncakilkaya
a021362cdb
Strings are values now: `a + b` concatenates and `a == b` / `a != b` compare by
content, replacing the 605 `sconcat(...)` / `streq(...)` calls that made the
compiler read like C.
streq(name, "let") -> name == "let"
sconcat("load ", reg) -> "load " + reg
sconcat(a, sconcat(b, c)) -> a + b + c
Implementation: emit_bin gains a string path. Strings are pointer-typed, so any
`+` with a pointer operand concatenates and `==`/`!=` between pointers compares
content — except when one side is the `null` literal, which stays a pointer
identity test (the only two kinds of pointer `==` in the codebase). Both call a
small hand-written IR prelude, @fn_str_eq / @fn_str_concat, emitted once into any
program that uses string ops (so it works for tools, games and the compiler with
no runtime-splice dependency and no duplicate symbols).
Delivered as two reseeds: (A) add the operators + prelude with the full
pointer-aware dispatch, keeping streq/sconcat; (B) migrate every call site
(354 lines, via a string-literal-safe balanced-paren script that leaves the
function definitions alone) and delete streq/sconcat. examples/strings.ludic +
a test.sh smoke (prints 1 2 3 4 5) guard it.
Reseeded (21890 lines); C-free fixpoint holds; goldens byte-identical; 18/18;
vocab + doc-fences clean.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
103 lines
3.7 KiB
Text
103 lines
3.7 KiB
Text
# emit_game.ludic — system functions and the frame loop. A system compiles to a
|
|
# void function; main() boots (Start systems), then runs the per-frame phases in
|
|
# order until the game stops. Runtime hooks (rt_init/poll/running/shutdown) are
|
|
# called only when the runtime defines them.
|
|
|
|
fn emit_system_fn(sys: Node) -> void {
|
|
ll_t = 0; ll_lbl = 0; g_term = false; loc_reset(); nloop = 0; nself = 0
|
|
ret_ty = "void"
|
|
let fbody = buf_new()
|
|
falloc = buf_new()
|
|
let saved = code
|
|
code = fbody
|
|
emit_block(sys.a)
|
|
if not g_term { emit(" br label %ret\n") }
|
|
emit("ret:\n ret void\n")
|
|
code = saved
|
|
emit("define void @sys_"); emit(sys.s); emit("() {\nentry:\n")
|
|
emit(buf_str(falloc))
|
|
emit(buf_str(fbody))
|
|
emit("}\n\n")
|
|
}
|
|
|
|
fn emit_calls_for_phase(phase: ptr) -> void {
|
|
var i = 0
|
|
while i < len(prog) {
|
|
let d = prog[i]
|
|
if d.kind == N_SYS and (d.ty == phase) { # skip a disabled handler
|
|
let he = emit_bind(("load i32, ptr @HE_" + d.s))
|
|
let hc = emit_bind(("icmp ne i32 " + (he + ", 0")))
|
|
let run = lbl("hrun"); let skip = lbl("hskip")
|
|
emit(" br i1 "); emit(hc); emit(", label %"); emit(run); emit(", label %"); emit(skip); emit("\n")
|
|
emit(run); emit(":\n call void @sys_"); emit(d.s); emit("()\n")
|
|
emit(" br label %"); emit(skip); emit("\n"); emit(skip); emit(":\n")
|
|
}
|
|
i = i + 1
|
|
}
|
|
}
|
|
|
|
# @OnDespawn(Model) hooks compile to `@on_despawn_<Model>(entity)` functions that
|
|
# bind the model's properties and run the body — dispatched by kind at `despawn`.
|
|
fn emit_despawn_hooks() -> void {
|
|
var i = 0
|
|
while i < len(g_ondespawn) {
|
|
let hk = g_ondespawn[i]
|
|
let model = find_arch(hk.s)
|
|
ll_t = 0; ll_lbl = 0; g_term = false; loc_reset(); nloop = 0; nself = 0
|
|
ret_ty = "void"
|
|
let fbody = buf_new()
|
|
falloc = buf_new()
|
|
let saved = code
|
|
code = fbody
|
|
emit_bind_props(model, "%e")
|
|
emit_block(hk.a)
|
|
if not g_term { emit(" br label %ret\n") }
|
|
emit("ret:\n ret void\n")
|
|
code = saved
|
|
emit("define void @on_despawn_"); emit(hk.s); emit("(i32 %e) {\nentry:\n")
|
|
emit(buf_str(falloc))
|
|
emit(buf_str(fbody))
|
|
emit("}\n\n")
|
|
i = i + 1
|
|
}
|
|
}
|
|
|
|
fn emit_game_main() -> void {
|
|
# every system becomes a function first
|
|
var i = 0
|
|
while i < len(prog) { if prog[i].kind == N_SYS { emit_system_fn(prog[i]) }; i = i + 1 }
|
|
emit_despawn_hooks()
|
|
|
|
emit("define i32 @main(i32 %argc, ptr %argv) {\nentry:\n")
|
|
emit(" store i32 %argc, ptr @L_argc\n")
|
|
emit(" store ptr %argv, ptr @L_argv\n")
|
|
if (find_fn("rt_init") != null) { emit(" call void @fn_rt_init()\n") }
|
|
emit_calls_for_phase("Start")
|
|
emit(" br label %loop\n")
|
|
emit("loop:\n")
|
|
let r = emit_bind("load i32, ptr @L_running")
|
|
let rc = emit_bind(("icmp ne i32 " + (r + ", 0")))
|
|
if (find_fn("rt_running") != null) {
|
|
let pr = emit_bind("call i32 @fn_rt_running()")
|
|
let pc = emit_bind(("icmp ne i32 " + (pr + ", 0")))
|
|
let go = emit_bind(("and i1 " + (rc + (", " + pc))))
|
|
emit(" br i1 "); emit(go); emit(", label %body, label %done\n")
|
|
} else {
|
|
emit(" br i1 "); emit(rc); emit(", label %body, label %done\n")
|
|
}
|
|
emit("body:\n")
|
|
if (find_fn("rt_poll") != null) {
|
|
let k = emit_bind("call i32 @fn_rt_poll()")
|
|
emit(" store i32 "); emit(k); emit(", ptr @L_key\n")
|
|
}
|
|
emit_calls_for_phase("Input")
|
|
emit_calls_for_phase("FixedUpdate")
|
|
emit_calls_for_phase("Update")
|
|
emit_calls_for_phase("LateUpdate")
|
|
emit_calls_for_phase("Render")
|
|
emit(" br label %loop\n")
|
|
emit("done:\n")
|
|
emit_calls_for_phase("OnQuit") # @OnQuit shutdown hooks run once, before teardown
|
|
if (find_fn("rt_shutdown") != null) { emit(" call void @fn_rt_shutdown()\n") }
|
|
emit(" ret i32 0\n}\n")
|
|
}
|