Phase 8b: modern names for the raw-memory and OS/IO primitives

Groups B and C of the leftover-primitive cleanup — renames, not new machinery,
and deliberately NO unsafe_ prefix (a __-prefix is itself a C convention, and an
`unsafe` marker carries no signal in a fully-manual-memory language with no safe
subset to contrast against).

  memory:  mem_free -> free   mem_realloc -> resize   mem_set -> fill
           ptr_add -> offset
  process: os_argc -> arg_count   os_arg -> arg   os_exit -> exit
           os_system -> run   os_getenv -> getenv   read_byte -> read_char
  dead:    mem_copy, os_time, write_byte (0 uses) — deleted

Two reseeds: accept both old and new names in the intrinsic dispatch, then
migrate every call site and drop the old names. file_open/read/write/seek/tell/
close are left as-is — they're the domain-prefixed syscall layer wrapped by
read_file, not the argc/argv-style C-ness the audit targeted; a `File` type is a
separate, larger design if wanted.

test.sh's CLI smoke updated (os_exit -> exit); check-vocabulary's grammar marker
moved off the deleted names. Reseeded (22243 lines); C-free fixpoint holds;
goldens identical; 18/18; vocab + doc-fences clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

selfhost/buf.ludic

@@ -14,7 +14,7 @@ fn buf_new() -> Buf {
 fn buf_ensure(b: Buf, extra: int) -> void {
   if b.len + extra + 1 <= b.cap { return }
   while b.len + extra + 1 > b.cap { b.cap = b.cap * 2 }
-  b.data = mem_realloc(b.data, b.cap)
+  b.data = resize(b.data, b.cap)
 }
 fn buf_putc(b: Buf, c: int) -> void {
   buf_ensure(b, 1)

selfhost/emit_intrin.ludic

@@ -7,12 +7,12 @@ var g_intrin_ok: bool = false
 # is `name` a low-level intrinsic? A pure name check, so it can gate dispatch
 # without evaluating arguments (which could clobber shared state).
 fn is_intrinsic(name: ptr) -> bool {
-  if (name == "mem_realloc") { return true }
+  if (name == "resize") { return true }
   if (name == "file_open") or (name == "file_read") or (name == "file_write") { return true }
   if (name == "file_seek") or (name == "file_tell") or (name == "file_close") { return true }
-  if (name == "os_argc") or (name == "os_arg") or (name == "os_exit") or (name == "file_stderr") { return true }
-  if (name == "file_stdout") { return true }
-  if (name == "os_system") or (name == "os_getenv") { return true }
+  if (name == "arg_count") or (name == "arg") or (name == "exit") { return true }
+  if (name == "file_stderr") or (name == "file_stdout") { return true }
+  if (name == "run") or (name == "getenv") { return true }
   return false
 }
 # emit "  <r> = <rest>\n" and return r
@@ -24,7 +24,7 @@ fn emit_intrinsic(name: ptr, e: Node) -> Val {
   g_intrin_ok = true
   # ptr_null / ptr_is_null are the `null` literal and `x == null` now.
   # mem_alloc is bytes(n) / words(n) now (see emit_call).
-  if (name == "mem_realloc") {
+  if (name == "resize") {
     let p = arg_code(e, 0);  let n = arg_code(e, 1)
     let w = emit_bind(`zext i32 {n} to i64`)
     return val(emit_bind(`call ptr @realloc(ptr {p}, i64 {w})`), "ptr")
@@ -57,14 +57,14 @@ fn emit_intrinsic(name: ptr, e: Node) -> Val {
     return val("0", "void")
   }
   # print_str / print_int are the polymorphic `print(x)` builtin now (emit_call).
-  if (name == "os_argc") { return val(emit_bind("load i32, ptr @L_argc"), "int") }
-  if (name == "os_arg") {
+  if (name == "arg_count") { return val(emit_bind("load i32, ptr @L_argc"), "int") }
+  if (name == "arg") {
     let i = arg_code(e, 0)
     let v = emit_bind("load ptr, ptr @L_argv")
     let q = emit_bind(`getelementptr ptr, ptr {v}, i32 {i}`)
     return val(emit_bind(`load ptr, ptr {q}`), "str")
   }
-  if (name == "os_exit") {
+  if (name == "exit") {
     let n = arg_code(e, 0)
     emit("  call void @exit(i32 ");  emit(n);  emit(")\n")
     emit("  unreachable\n")
@@ -73,11 +73,11 @@ fn emit_intrinsic(name: ptr, e: Node) -> Val {
   }
   if (name == "file_stderr") { return val(emit_bind("load ptr, ptr @__stderrp"), "ptr") }
   if (name == "file_stdout") { return val(emit_bind("load ptr, ptr @__stdoutp"), "ptr") }
-  if (name == "os_system") {
+  if (name == "run") {
     let c = arg_code(e, 0)
     return val(emit_bind(`call i32 @system(ptr {c})`), "int")
   }
-  if (name == "os_getenv") {
+  if (name == "getenv") {
     let n = arg_code(e, 0)
     return val(emit_bind(`call ptr @getenv(ptr {n})`), "str")
   }

selfhost/emit_intrin2.ludic

@@ -5,9 +5,8 @@
 var g_windowed: bool = false     # headless by default (games read stdin / dump PPM)
 
 fn is_intrinsic2(name: ptr) -> bool {
-  if (name == "mem_free") or (name == "mem_copy") or (name == "mem_set") { return true }
-  if (name == "ptr_add") or (name == "read_byte") or (name == "write_byte") { return true }
-  if (name == "os_time") { return true }
+  if (name == "free") or (name == "fill") { return true }
+  if (name == "offset") or (name == "read_char") { return true }
   if (name == "as_fixed") or (name == "as_int") { return true }
   if (name == "is_windowed") or (name == "game_title") { return true }
   if (name == "win_open") or (name == "win_poll") or (name == "win_present") { return true }
@@ -16,35 +15,22 @@ fn is_intrinsic2(name: ptr) -> bool {
 }
 
 fn emit_intrinsic2(name: ptr, e: Node) -> Val {
-  if (name == "mem_free") {
+  if (name == "free") {
     let p = arg_code(e, 0);  emit("  call void @free(ptr ");  emit(p);  emit(")\n");  return val("0", "void")
   }
-  if (name == "mem_copy") {
-    let d = arg_code(e, 0);  let s = arg_code(e, 1);  let n = arg_code(e, 2)
-    let w = emit_bind(`zext i32 {n} to i64`)
-    emit("  call ptr @memcpy(ptr ");  emit(d);  emit(", ptr ");  emit(s);  emit(", i64 ");  emit(w);  emit(")\n")
-    return val("0", "void")
-  }
-  if (name == "mem_set") {
+  if (name == "fill") {
     let p = arg_code(e, 0);  let v = arg_code(e, 1);  let n = arg_code(e, 2)
     let w = emit_bind(`zext i32 {n} to i64`)
     emit("  call ptr @memset(ptr ");  emit(p);  emit(", i32 ");  emit(v);  emit(", i64 ");  emit(w);  emit(")\n")
     return val("0", "void")
   }
-  if (name == "ptr_add") {
+  if (name == "offset") {
     let p = arg_code(e, 0);  let n = arg_code(e, 1)
     let g = nreg()
     emit("  ");  emit(g);  emit(" = getelementptr inbounds i8, ptr ");  emit(p);  emit(", i32 ");  emit(n);  emit("\n")
     return val(g, "ptr")
   }
-  if (name == "read_byte") { return val(emit_bind("call i32 @getchar()"), "int") }
-  if (name == "write_byte") {
-    let v = arg_code(e, 0);  emit("  call i32 @putchar(i32 ");  emit(v);  emit(")\n");  return val("0", "void")
-  }
-  if (name == "os_time") {
-    let r = emit_bind("call i64 @time(ptr null)")
-    return val(emit_bind(`trunc i64 {r} to i32`), "int")
-  }
+  if (name == "read_char") { return val(emit_bind("call i32 @getchar()"), "int") }
   if (name == "as_fixed") { let a = emit_expr(e.kids[0]);  return val(a.code, "fixed") }
   if (name == "as_int")   { let a = emit_expr(e.kids[0]);  return val(a.code, "int") }
   if (name == "is_windowed") { if g_windowed { return val("1", "bool") };  return val("0", "bool") }

selfhost/main.ludic

@@ -33,7 +33,7 @@ fn strip_ludic(name: ptr) -> ptr {
 
 # env var with a fallback when unset
 fn getenv_or(name: ptr, dflt: ptr) -> ptr {
-  let v = os_getenv(name)
+  let v = getenv(name)
   if (v == null) { return dflt }
   return v
 }
@@ -48,7 +48,7 @@ fn ensure_slash(d: ptr) -> ptr {
 
 fn die(msg: ptr) -> void {
   file_write(file_stderr(), msg, len(msg))
-  os_exit(1)
+  exit(1)
 }
 
 entry {
@@ -61,18 +61,18 @@ entry {
   var run = false         # compile then execute the result
 
   # multi-call: invoked as `ludic` -> run mode by default
-  if (base_name(os_arg(0)) == "ludic") { run = true }
+  if (base_name(arg(0)) == "ludic") { run = true }
 
   var ai = 1
-  while ai < os_argc() {
-    let a = os_arg(ai)
+  while ai < arg_count() {
+    let a = arg(ai)
     if (a == ("--windowed")) { want = 1 }
     else { if (a == ("--headless")) { want = 2 }
     else { if (a == ("--emit-llvm")) { emit_ir = true }
     else { if (a == ("--fmt")) { fmt = true }
     else { if (a == ("--save-temps")) { save = true }
     else { if (a == ("--run")) { run = true }
-    else { if (a == ("-o")) { ai = ai + 1;  if ai < os_argc() { out = os_arg(ai) } }
+    else { if (a == ("-o")) { ai = ai + 1;  if ai < arg_count() { out = arg(ai) } }
     else {
       # an unknown flag is ignored (with a note) rather than mistaken for the
       # input file — '-' is ASCII 45
@@ -97,7 +97,7 @@ entry {
   # --fmt is the doc-check gate: reaching here means it lexed and parsed. A parse
   # error would already have exited nonzero, so a clean parse exits 0. (Canonical
   # formatting output is not yet reimplemented on the self-hosted toolchain.)
-  if fmt { os_exit(0) }
+  if fmt { exit(0) }
 
   maybe_splice_runtime()
 
@@ -122,13 +122,13 @@ entry {
 
   # make the output directory if the user asked for e.g. bin/app
   let odir = dir_of(out)
-  if len(odir) > 0 { os_system(`mkdir -p {odir}`) }
+  if len(odir) > 0 { run(`mkdir -p {odir}`) }
 
   let ll = `{out}.ll`
   if not ir_flush(ll) { die("ludicc: cannot write IR\n") }
 
   let cc   = getenv_or("LUDIC_CC", "clang")
-  let home = ensure_slash(getenv_or("LUDIC_HOME", dir_of(os_arg(0))))
+  let home = ensure_slash(getenv_or("LUDIC_HOME", dir_of(arg(0))))
 
   # clang twice: assemble the IR, then link. A windowed build adds the macOS
   # platform layer and the Cocoa framework.
@@ -141,13 +141,13 @@ entry {
   }
   cmd = `{cmd} -o {out}`
 
-  let rc = os_system(cmd)
-  if not save { os_system(`rm -f {ll}`) }
+  let rc = run(cmd)
+  if not save { run(`rm -f {ll}`) }
   if rc != 0 { die("ludicc: link failed\n") }
 
   # run mode: execute the binary we just built and forward its exit code
   if run {
-    let st = os_system(out)
-    os_exit(((st >> 8) & 255))
+    let st = run(out)
+    exit(((st >> 8) & 255))
   }
 }

selfhost/parse.ludic

@@ -17,7 +17,7 @@ fn perr(msg: ptr) -> void {
   file_write(e, "ludicc(self): parse error: ", 27)
   file_write(e, msg, len(msg))
   file_write(e, "\n", 1)
-  os_exit(1)
+  exit(1)
 }
 
 fn eat_op(v: ptr) -> void { if not is_op(v) { perr(v) }; pi = pi + 1 }