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>
144 lines
6.2 KiB
Text
144 lines
6.2 KiB
Text
# emit_spawn.ludic — spawn / despawn / self(), and seeding a component's fields
|
|
# from its declared defaults plus any per-spawn overrides.
|
|
|
|
fn emit_init_component(e: ptr, comp: ptr, rec: Node) -> void {
|
|
let me = itoa(MAX_ENT)
|
|
let c = find_comp(comp)
|
|
if (c == null) { perr(("spawn: unknown property " + comp)) }
|
|
let hp = nreg(); emit(" "); emit(hp); emit(" = getelementptr inbounds ["); emit(me); emit(" x i8], ptr @H_"); emit(comp); emit(", i32 0, i32 "); emit(e); emit("\n")
|
|
emit(" store i8 1, ptr "); emit(hp); emit("\n")
|
|
let slot = nreg()
|
|
emit(" "); emit(slot); emit(" = getelementptr inbounds ["); emit(me); emit(" x %Cmp_"); emit(comp); emit("], ptr @S_"); emit(comp); emit(", i32 0, i32 "); emit(e); emit("\n")
|
|
# defaults
|
|
var f = 0
|
|
while f < len(c.kids) {
|
|
let fd = c.kids[f]
|
|
let addr = nreg()
|
|
emit(" "); emit(addr); emit(" = getelementptr inbounds %Cmp_"); emit(comp); emit(", ptr "); emit(slot); emit(", i32 0, i32 "); emit(itoa(f)); emit("\n")
|
|
let lt = llty(fd.ty)
|
|
var v = "0"
|
|
if (lt == "ptr") { v = "null" }
|
|
if (fd.a != null) { let dv = emit_expr(fd.a); v = dv.code }
|
|
emit(" store "); emit(lt); emit(" "); emit(v); emit(", ptr "); emit(addr); emit("\n")
|
|
f = f + 1
|
|
}
|
|
# per-spawn overrides
|
|
if (rec != null) {
|
|
var j = 0
|
|
while j < len(rec.kids) {
|
|
let fi = rec.kids[j]
|
|
let fidx = field_index(c, fi.s)
|
|
if fidx >= 0 {
|
|
let addr = nreg()
|
|
emit(" "); emit(addr); emit(" = getelementptr inbounds %Cmp_"); emit(comp); emit(", ptr "); emit(slot); emit(", i32 0, i32 "); emit(itoa(fidx)); emit("\n")
|
|
let dv = emit_expr(fi.a)
|
|
emit(" store "); emit(llty(field_type(c, fi.s))); emit(" "); emit(dv.code); emit(", ptr "); emit(addr); emit("\n")
|
|
}
|
|
j = j + 1
|
|
}
|
|
}
|
|
# @OnAttach(Property) runs once the property is attached and seeded
|
|
let ab = onattach_body(comp)
|
|
if (ab != null) {
|
|
let save = nloc
|
|
let vslot = emit_alloca("ptr")
|
|
emit(" store ptr "); emit(slot); emit(", ptr "); emit(vslot); emit("\n")
|
|
loc_push(comp, vslot, comp)
|
|
emit_block(ab)
|
|
nloc = save
|
|
}
|
|
}
|
|
|
|
# bind each of a model's properties to entity `e`'s component storage, so an
|
|
# @OnSpawn hook body can address them by name (like a query binding for one entity).
|
|
fn emit_bind_props(model: Node, e: ptr) -> void {
|
|
let me = itoa(MAX_ENT)
|
|
var c = 0
|
|
while c < len(model.kids) {
|
|
let pname = model.kids[c].s
|
|
let slot = nreg()
|
|
emit(" "); emit(slot); emit(" = getelementptr inbounds ["); emit(me); emit(" x %Cmp_"); emit(pname); emit("], ptr @S_"); emit(pname); emit(", i32 0, i32 "); emit(e); emit("\n")
|
|
let vslot = emit_alloca("ptr")
|
|
emit(" store ptr "); emit(slot); emit(", ptr "); emit(vslot); emit("\n")
|
|
loc_push(pname, vslot, pname)
|
|
c = c + 1
|
|
}
|
|
}
|
|
|
|
fn emit_spawn(st: Node) -> void {
|
|
let e = emit_bind("call i32 @L_alloc()")
|
|
let ak = find_arch_id(st.s)
|
|
if ak > 0 {
|
|
let me = itoa(MAX_ENT)
|
|
let kp = nreg(); emit(" "); emit(kp); emit(" = getelementptr inbounds ["); emit(me); emit(" x i32], ptr @L_kind, i32 0, i32 "); emit(e); emit("\n")
|
|
emit(" store i32 "); emit(itoa(ak)); emit(", ptr "); emit(kp); emit("\n")
|
|
let arch = find_arch(st.s)
|
|
var c = 0
|
|
while c < len(arch.kids) {
|
|
let cn = arch.kids[c].s
|
|
var rec = null
|
|
var i = 0
|
|
while i < len(st.kids) { if (st.kids[i].s == cn) { rec = st.kids[i].a }; i = i + 1 }
|
|
emit_init_component(e, cn, rec)
|
|
c = c + 1
|
|
}
|
|
let ob = onspawn_body(st.s) # @OnSpawn(Model) hook runs after init
|
|
if (ob != null) {
|
|
let save = nloc
|
|
emit_bind_props(arch, e)
|
|
emit_block(ob)
|
|
nloc = save
|
|
}
|
|
} else {
|
|
var i = 0
|
|
while i < len(st.kids) { emit_init_component(e, st.kids[i].s, st.kids[i].a); i = i + 1 }
|
|
}
|
|
}
|
|
|
|
fn emit_despawn(st: Node) -> void {
|
|
let v = emit_expr(st.a)
|
|
# @OnDespawn: dispatch on the entity's kind and run the matching model's hook
|
|
if len(g_ondespawn) > 0 {
|
|
let me = itoa(MAX_ENT)
|
|
let kp = nreg(); emit(" "); emit(kp); emit(" = getelementptr inbounds ["); emit(me); emit(" x i32], ptr @L_kind, i32 0, i32 "); emit(v.code); emit("\n")
|
|
let kind = emit_bind(("load i32, ptr " + kp))
|
|
var i = 0
|
|
while i < len(g_ondespawn) {
|
|
let mname = g_ondespawn[i].s
|
|
let c = emit_bind(("icmp eq i32 " + (kind + (", " + itoa(find_arch_id(mname))))))
|
|
let yes = lbl("dh"); let no = lbl("dhn")
|
|
emit(" br i1 "); emit(c); emit(", label %"); emit(yes); emit(", label %"); emit(no); emit("\n")
|
|
emit(yes); emit(":\n call void @on_despawn_"); emit(mname); emit("(i32 "); emit(v.code); emit(")\n")
|
|
emit(" br label %"); emit(no); emit("\n"); emit(no); emit(":\n")
|
|
i = i + 1
|
|
}
|
|
}
|
|
emit(" call void @L_free_entity(i32 "); emit(v.code); emit(")\n")
|
|
}
|
|
|
|
# enable/disable. `<P> on <e>` toggles a property's has-flag on an entity (its
|
|
# data persists, so re-enabling restores it, and queries already skip a cleared
|
|
# flag). A bare `<Model>` / `<Handler>` flips a global enabled flag.
|
|
fn emit_toggle(st: Node) -> void {
|
|
var val = "0"; if st.ival == 1 { val = "1" }
|
|
if (st.a != null) {
|
|
let ev = emit_expr(st.a)
|
|
let me = itoa(MAX_ENT)
|
|
let hp = nreg(); emit(" "); emit(hp); emit(" = getelementptr inbounds ["); emit(me); emit(" x i8], ptr @H_"); emit(st.s); emit(", i32 0, i32 "); emit(ev.code); emit("\n")
|
|
emit(" store i8 "); emit(val); emit(", ptr "); emit(hp); emit("\n")
|
|
var hb: Node = null
|
|
if st.ival == 1 { hb = onenable_body(st.s) } else { hb = ondisable_body(st.s) }
|
|
if (hb != null) {
|
|
let save = nloc
|
|
let slot = nreg(); emit(" "); emit(slot); emit(" = getelementptr inbounds ["); emit(me); emit(" x %Cmp_"); emit(st.s); emit("], ptr @S_"); emit(st.s); emit(", i32 0, i32 "); emit(ev.code); emit("\n")
|
|
let vslot = emit_alloca("ptr")
|
|
emit(" store ptr "); emit(slot); emit(", ptr "); emit(vslot); emit("\n")
|
|
loc_push(st.s, vslot, st.s)
|
|
emit_block(hb)
|
|
nloc = save
|
|
}
|
|
} else {
|
|
var g = "@HE_"; if is_model(st.s) { g = "@ME_" } # model vs handler
|
|
emit(" store i32 "); emit(val); emit(", ptr "); emit(g); emit(st.s); emit("\n")
|
|
}
|
|
}
|