Orkuncakilkaya
4c48077d68
Expand the function-declaration keyword to the full word across the whole
language and toolchain:
fn name(...) -> T { ... } -> function name(...) -> T { ... }
Done as a self-hosting migration: teach the parser both spellings, reseed,
rewrite every .ludic definition to `function`, then drop `fn`. The compiler
now rejects `fn`. Touches the parser, all selfhost/tools/runtime/example/test
sources, the grammars (TextMate shared+vscode, ludic_syntax.h, JetBrains
LudicTokens.kt), the LSP and formatter, the Python doc/vocab tools
(check-impl, check-docs, validate, palette, test-lsp), and the docs
(fences, prose, kw-fn -> kw-function).
Reseeded; C-free bootstrap fixpoint holds. All suites green (45 regression,
24 self-host, 29 tool); the docs site generates and check.py passes.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
93 lines
4 KiB
Text
93 lines
4 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.
|
|
|
|
function emit_sizeof(llt: ptr) -> ptr {
|
|
let p = emit_bind(`getelementptr {llt}, ptr null, i32 1`)
|
|
return emit_bind(`ptrtoint ptr {p} to i64`)
|
|
}
|
|
|
|
function 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)
|
|
}
|
|
|
|
function 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)
|
|
}
|
|
|
|
function 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
|
|
}
|
|
|
|
function emit_len(e: Node) -> Val {
|
|
let s = emit_expr(e.kids[0])
|
|
if is_slice_ty(s.ty) { # a slice: read its header length
|
|
let lp = slice_field(s.code, 1)
|
|
return val(emit_bind(`load i32, ptr {lp}`), "int")
|
|
}
|
|
let r = emit_bind(`call i64 @strlen(ptr {s.code})`) # a string: byte length
|
|
return val(emit_bind(`trunc i64 {r} to i32`), "int")
|
|
}
|
|
|
|
function 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")
|
|
}
|