Orkuncakilkaya
dc475b17c2
`struct` and `property` had identical syntax and differed only in semantics, so
they are now one keyword: `property`. How a property is stored follows from how
it is used —
- listed in a `model` or attached by `spawn` -> an ECS component, kept in the
engine's per-entity @S_/@H_ arrays and bound in queries (as before);
- constructed with `new` -> a heap record with reference
semantics (what `struct` used to be).
A program that declares only `property` records and functions — no `model`, no
`handler` — is not an ECS program: it gets record layouts and `new`, but no
entity storage, allocator, snapshot, or runtime splice. This is exactly the
shape of the Ludic compiler itself, whose Node/Tok/Buf/Val are now `property`.
Mechanics:
- record layout (%Cmp_) now always emitted in the header (emit_head), so `new`
works with or without the ECS; the per-entity arrays stay in
emit_ecs_storage. %Str_ is gone — one layout prefix.
- has_ecs() is now `has_systems() or has_models()`, not "any component"; a
property alone no longer drags in the ECS runtime. Added has_models().
- emit_new / member access / layout_ty / layout_node collapse onto find_comp.
Dropped struct keyword, parse_struct, find_struct, is_struct_ty, N_STRUCT
emission (the const stays at kind 0, the default node kind).
Migration done as two reseeds (the old compiler treats any component as ECS, so
it cannot see `property` records in the compiler source until has_ecs is fixed):
A) teach the compiler property-as-record + fix has_ecs, keeping `struct`;
B) migrate the compiler's own records to `property` and remove `struct`.
selfhost/tests/structs.ludic migrated (still prints 7 9 109 2 42). Vocabulary
drops `struct` from DECL (ludic_syntax.h, grammar, LudicTokens.kt). LANGUAGE.md
"Records" section rewritten. Reseeded (21613 lines); C-free fixpoint holds;
goldens identical; 17/17; vocab + doc-fences clean.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
89 lines
4.1 KiB
Text
89 lines
4.1 KiB
Text
# emit_new.ludic — heap construction and slice operations: `new S`, `new []T`,
|
|
# push(slice, v) and len(slice). Slices are a { data, len, cap } header the
|
|
# holder points at, so growth is visible to every holder.
|
|
|
|
fn emit_sizeof(llt: ptr) -> ptr {
|
|
let p = emit_bind(sconcat("getelementptr ", sconcat(llt, ", ptr null, i32 1")))
|
|
return emit_bind(sconcat("ptrtoint ptr ", sconcat(p, " to i64")))
|
|
}
|
|
|
|
fn emit_new_struct(name: ptr) -> Val {
|
|
let s = layout_node(name) # a struct or a property — same shape
|
|
if ptr_is_null(s) { perr("unknown record type in new") }
|
|
let lty = layout_ty(name)
|
|
let sz = emit_sizeof(lty)
|
|
let obj = emit_bind(sconcat("call ptr @malloc(i64 ", sconcat(sz, ")")))
|
|
let f = 0
|
|
while f < len(s.kids) {
|
|
let fd = s.kids[f]
|
|
let addr = nreg()
|
|
emit(" "); emit(addr); emit(" = getelementptr inbounds "); emit(lty)
|
|
emit(", ptr "); emit(obj); emit(", i32 0, i32 "); emit(itoa(f)); emit("\n")
|
|
let lt = llty(fd.ty)
|
|
let v = "0"
|
|
if streq(lt, "ptr") { v = "null" }
|
|
if not ptr_is_null(fd.a) { 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
|
|
}
|
|
return val(obj, name)
|
|
}
|
|
|
|
fn emit_new_slice(ty: ptr) -> Val {
|
|
let sz = emit_sizeof("%LSlice")
|
|
let h = emit_bind(sconcat("call ptr @malloc(i64 ", sconcat(sz, ")")))
|
|
let d0 = nreg(); emit(" "); emit(d0); emit(" = getelementptr inbounds %LSlice, ptr "); emit(h); emit(", i32 0, i32 0\n")
|
|
emit(" store ptr null, ptr "); emit(d0); emit("\n")
|
|
let d1 = nreg(); emit(" "); emit(d1); emit(" = getelementptr inbounds %LSlice, ptr "); emit(h); emit(", i32 0, i32 1\n")
|
|
emit(" store i32 0, ptr "); emit(d1); emit("\n")
|
|
let d2 = nreg(); emit(" "); emit(d2); emit(" = getelementptr inbounds %LSlice, ptr "); emit(h); emit(", i32 0, i32 2\n")
|
|
emit(" store i32 0, ptr "); emit(d2); emit("\n")
|
|
return val(h, ty)
|
|
}
|
|
|
|
fn slice_field(h: ptr, i: int) -> ptr {
|
|
let r = nreg()
|
|
emit(" "); emit(r); emit(" = getelementptr inbounds %LSlice, ptr "); emit(h)
|
|
emit(", i32 0, i32 "); emit(itoa(i)); emit("\n")
|
|
return r
|
|
}
|
|
|
|
fn emit_len(e: Node) -> Val {
|
|
let s = emit_expr(e.kids[0])
|
|
let lp = slice_field(s.code, 1)
|
|
return val(emit_bind(sconcat("load i32, ptr ", lp)), "int")
|
|
}
|
|
|
|
fn emit_push(e: Node) -> Val {
|
|
let s = emit_expr(e.kids[0])
|
|
let el = slice_elem(s.ty)
|
|
let elt = llty(el)
|
|
let h = s.code
|
|
let lp = slice_field(h, 1); let cp = slice_field(h, 2); let dp = slice_field(h, 0)
|
|
let l = emit_bind(sconcat("load i32, ptr ", lp))
|
|
let c = emit_bind(sconcat("load i32, ptr ", cp))
|
|
let full = emit_bind(sconcat("icmp sge i32 ", sconcat(l, sconcat(", ", c))))
|
|
let grow = lbl("grow"); let put = lbl("put")
|
|
emit(" br i1 "); emit(full); emit(", label %"); emit(grow); emit(", label %"); emit(put); emit("\n")
|
|
emit(grow); emit(":\n")
|
|
let dbl = emit_bind(sconcat("mul i32 ", sconcat(c, ", 2")))
|
|
let isz = emit_bind(sconcat("icmp eq i32 ", sconcat(c, ", 0")))
|
|
let nc = emit_bind(sconcat("select i1 ", sconcat(isz, sconcat(", i32 8, i32 ", dbl))))
|
|
let esz = emit_sizeof(elt)
|
|
let ncw = emit_bind(sconcat("zext i32 ", sconcat(nc, " to i64")))
|
|
let bytes = emit_bind(sconcat("mul i64 ", sconcat(ncw, sconcat(", ", esz))))
|
|
let old = emit_bind(sconcat("load ptr, ptr ", dp))
|
|
let nd = emit_bind(sconcat("call ptr @realloc(ptr ", sconcat(old, sconcat(", i64 ", sconcat(bytes, ")")))))
|
|
emit(" store ptr "); emit(nd); emit(", ptr "); emit(dp); emit("\n")
|
|
emit(" store i32 "); emit(nc); emit(", ptr "); emit(cp); emit("\n")
|
|
emit(" br label %"); emit(put); emit("\n")
|
|
emit(put); emit(":\n")
|
|
let v = emit_expr(e.kids[1])
|
|
let data = emit_bind(sconcat("load ptr, ptr ", dp))
|
|
let slot = nreg()
|
|
emit(" "); emit(slot); emit(" = getelementptr inbounds "); emit(elt); emit(", ptr "); emit(data); emit(", i32 "); emit(l); emit("\n")
|
|
emit(" store "); emit(elt); emit(" "); emit(v.code); emit(", ptr "); emit(slot); emit("\n")
|
|
let l1 = emit_bind(sconcat("add i32 ", sconcat(l, ", 1")))
|
|
emit(" store i32 "); emit(l1); emit(", ptr "); emit(lp); emit("\n")
|
|
return val("0", "void")
|
|
}
|