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>
89 lines
3.9 KiB
Text
89 lines
3.9 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(("getelementptr " + (llt + ", ptr null, i32 1")))
|
|
return emit_bind(("ptrtoint ptr " + (p + " to i64")))
|
|
}
|
|
|
|
fn emit_new_struct(name: ptr) -> Val {
|
|
let s = layout_node(name) # a struct or a property — same shape
|
|
if (s == null) { perr("unknown record type in new") }
|
|
let lty = layout_ty(name)
|
|
let sz = emit_sizeof(lty)
|
|
let obj = emit_bind(("call ptr @malloc(i64 " + (sz + ")")))
|
|
var 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)
|
|
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
|
|
}
|
|
return val(obj, name)
|
|
}
|
|
|
|
fn emit_new_slice(ty: ptr) -> Val {
|
|
let sz = emit_sizeof("%LSlice")
|
|
let h = emit_bind(("call ptr @malloc(i64 " + (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(("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(("load i32, ptr " + lp))
|
|
let c = emit_bind(("load i32, ptr " + cp))
|
|
let full = emit_bind(("icmp sge i32 " + (l + (", " + 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(("mul i32 " + (c + ", 2")))
|
|
let isz = emit_bind(("icmp eq i32 " + (c + ", 0")))
|
|
let nc = emit_bind(("select i1 " + (isz + (", i32 8, i32 " + dbl))))
|
|
let esz = emit_sizeof(elt)
|
|
let ncw = emit_bind(("zext i32 " + (nc + " to i64")))
|
|
let bytes = emit_bind(("mul i64 " + (ncw + (", " + esz))))
|
|
let old = emit_bind(("load ptr, ptr " + dp))
|
|
let nd = emit_bind(("call ptr @realloc(ptr " + (old + (", i64 " + (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(("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(("add i32 " + (l + ", 1")))
|
|
emit(" store i32 "); emit(l1); emit(", ptr "); emit(lp); emit("\n")
|
|
return val("0", "void")
|
|
}
|