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>
This commit is contained in:
parent
6f1ba2c214
commit
d3301684f1
19 changed files with 2468 additions and 2614 deletions
|
|
@ -36,9 +36,9 @@ fn rt_font() -> str {
|
|||
fn rt_init() -> void {
|
||||
rt_fb = words(320 * 240)
|
||||
rt_regs = words(64)
|
||||
mem_set(rt_regs, 0, 64 * 4)
|
||||
fill(rt_regs, 0, 64 * 4)
|
||||
rt_map = bytes(96 * 64)
|
||||
mem_set(rt_map, 32, 96 * 64)
|
||||
fill(rt_map, 32, 96 * 64)
|
||||
rt_statusbuf = bytes(96)
|
||||
rt_statusbuf[0] = 0
|
||||
rt_image_init()
|
||||
|
|
@ -218,7 +218,7 @@ fn rt_poll() -> int {
|
|||
if is_windowed() {
|
||||
return win_poll()
|
||||
}
|
||||
let c = read_byte()
|
||||
let c = read_char()
|
||||
if c < 0 {
|
||||
rt_alive = 0
|
||||
return 0
|
||||
|
|
@ -297,8 +297,8 @@ fn rt_dump_ppm(path: str) -> void {
|
|||
}
|
||||
file_write(f, buf, px * 3)
|
||||
file_close(f)
|
||||
mem_free(buf)
|
||||
mem_free(hdr)
|
||||
free(buf)
|
||||
free(hdr)
|
||||
}
|
||||
|
||||
import "inflate.ludic"
|
||||
|
|
@ -317,7 +317,7 @@ var rt_maph: int = 0
|
|||
fn rt_map_size(w: int, h: int) -> void {
|
||||
rt_mapw = clamp(w, 0, 96)
|
||||
rt_maph = clamp(h, 0, 64)
|
||||
mem_set(rt_map, 32, 96 * 64)
|
||||
fill(rt_map, 32, 96 * 64)
|
||||
}
|
||||
|
||||
fn rt_map_row(y: int, s: str) -> void {
|
||||
|
|
@ -378,7 +378,7 @@ fn rt_save_state(f: ptr) -> void {
|
|||
file_write(f, rt_regs, 64 * 4)
|
||||
file_write(f, rt_map, 96 * 64)
|
||||
file_write(f, rt_statusbuf, 96)
|
||||
mem_free(w)
|
||||
free(w)
|
||||
}
|
||||
|
||||
fn rt_load_state(f: ptr) -> void {
|
||||
|
|
@ -390,5 +390,5 @@ fn rt_load_state(f: ptr) -> void {
|
|||
file_read(f, rt_regs, 64 * 4)
|
||||
file_read(f, rt_map, 96 * 64)
|
||||
file_read(f, rt_statusbuf, 96)
|
||||
mem_free(w)
|
||||
free(w)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ fn rt_image_init() -> void {
|
|||
img_w = words(IMG_MAX)
|
||||
img_h = words(IMG_MAX)
|
||||
spr_px = words(SPR_MAX * SPR_SZ * SPR_SZ)
|
||||
mem_set(spr_px, 0, SPR_MAX * SPR_SZ * SPR_SZ * 4)
|
||||
fill(spr_px, 0, SPR_MAX * SPR_SZ * SPR_SZ * 4)
|
||||
}
|
||||
|
||||
# ---- decoding -------------------------------------------------------------
|
||||
|
|
@ -69,9 +69,9 @@ fn rt_decode_png(path: str) -> bool {
|
|||
let d = rt_read_file(path)
|
||||
if (d == null) { return false }
|
||||
let size = rt_file_len
|
||||
if size < 8 { mem_free(d); return false }
|
||||
if d[0] != 137 { mem_free(d); return false }
|
||||
if d[1] != 80 { mem_free(d); return false }
|
||||
if size < 8 { free(d); return false }
|
||||
if d[0] != 137 { free(d); return false }
|
||||
if d[1] != 80 { free(d); return false }
|
||||
|
||||
var w = 0
|
||||
var h = 0
|
||||
|
|
@ -118,8 +118,8 @@ fn rt_decode_png(path: str) -> bool {
|
|||
}
|
||||
}
|
||||
|
||||
if w <= 0 { mem_free(d); return false }
|
||||
if h <= 0 { mem_free(d); return false }
|
||||
if w <= 0 { free(d); return false }
|
||||
if h <= 0 { free(d); return false }
|
||||
|
||||
var channels = 1
|
||||
if ct == 2 { channels = 3 }
|
||||
|
|
@ -132,7 +132,7 @@ fn rt_decode_png(path: str) -> bool {
|
|||
let rawlen = h * (stride + 1)
|
||||
let raw = bytes(rawlen + 8)
|
||||
if z_uncompress(idat, idlen, raw, rawlen) < 0 {
|
||||
mem_free(d); mem_free(raw); mem_free(idat)
|
||||
free(d); free(raw); free(idat)
|
||||
return false
|
||||
}
|
||||
|
||||
|
|
@ -215,11 +215,11 @@ fn rt_decode_png(path: str) -> bool {
|
|||
}
|
||||
}
|
||||
|
||||
mem_free(d)
|
||||
mem_free(idat)
|
||||
mem_free(raw)
|
||||
mem_free(plte)
|
||||
mem_free(trns)
|
||||
free(d)
|
||||
free(idat)
|
||||
free(raw)
|
||||
free(plte)
|
||||
free(trns)
|
||||
png_w = w
|
||||
png_h = h
|
||||
png_px = out
|
||||
|
|
@ -333,7 +333,7 @@ fn rt_png_load(path: str) -> int {
|
|||
spr_px[base + y * SPR_SZ + x] = px
|
||||
}
|
||||
}
|
||||
mem_free(png_px)
|
||||
free(png_px)
|
||||
png_px = null
|
||||
return id
|
||||
}
|
||||
|
|
@ -380,7 +380,7 @@ fn rt_sprites_load(path: str) -> void {
|
|||
if (d == null) { spr_n = 0; return }
|
||||
let size = rt_file_len
|
||||
let pal: words = words(128)
|
||||
mem_set(pal, 0, 128 * 4)
|
||||
fill(pal, 0, 128 * 4)
|
||||
var cur = 0 - 1
|
||||
var row = 0
|
||||
var i = 0
|
||||
|
|
@ -407,7 +407,7 @@ fn rt_sprites_load(path: str) -> void {
|
|||
if spr_n < SPR_MAX {
|
||||
cur = spr_n
|
||||
spr_n = spr_n + 1
|
||||
mem_set(ptr_add(spr_px, cur * SPR_SZ * SPR_SZ * 4), 0, SPR_SZ * SPR_SZ * 4)
|
||||
fill(offset(spr_px, cur * SPR_SZ * SPR_SZ * 4), 0, SPR_SZ * SPR_SZ * 4)
|
||||
}
|
||||
row = 0
|
||||
}
|
||||
|
|
@ -429,6 +429,6 @@ fn rt_sprites_load(path: str) -> void {
|
|||
}
|
||||
i = start + len + 1
|
||||
}
|
||||
mem_free(pal)
|
||||
mem_free(d)
|
||||
free(pal)
|
||||
free(d)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -75,7 +75,7 @@ fn z_table_build(table: words, lengths: words, n: int) -> void {
|
|||
offs[l] = offs[l] + 1
|
||||
}
|
||||
}
|
||||
mem_free(offs)
|
||||
free(offs)
|
||||
}
|
||||
|
||||
fn z_decode(table: words) -> int {
|
||||
|
|
@ -181,7 +181,7 @@ fn z_fixed_tables(lit: ptr, dist: ptr) -> void {
|
|||
z_table_build(lit, lengths, 288)
|
||||
for i in 0 .. 30 { lengths[i] = 5 }
|
||||
z_table_build(dist, lengths, 30)
|
||||
mem_free(lengths)
|
||||
free(lengths)
|
||||
}
|
||||
|
||||
fn z_dynamic_tables(lit: ptr, dist: ptr) -> int {
|
||||
|
|
@ -233,9 +233,9 @@ fn z_dynamic_tables(lit: ptr, dist: ptr) -> int {
|
|||
let dl: words = words(32)
|
||||
for i in 0 .. ndist { dl[i] = lengths[nlen + i] }
|
||||
z_table_build(dist, dl, ndist)
|
||||
mem_free(dl)
|
||||
mem_free(lengths)
|
||||
mem_free(clen)
|
||||
free(dl)
|
||||
free(lengths)
|
||||
free(clen)
|
||||
return 1
|
||||
}
|
||||
|
||||
|
|
@ -262,8 +262,8 @@ fn z_inflate(src: ptr, len: int, out: ptr, cap: int) -> int {
|
|||
if btype == 3 { return -1 }
|
||||
if w < 0 { return -1 }
|
||||
}
|
||||
mem_free(lit)
|
||||
mem_free(dist)
|
||||
free(lit)
|
||||
free(dist)
|
||||
return w
|
||||
}
|
||||
|
||||
|
|
@ -272,5 +272,5 @@ fn z_uncompress(src: ptr, len: int, out: ptr, cap: int) -> int {
|
|||
if len < 2 { return -1 }
|
||||
let cmf = src[0]
|
||||
if (cmf & 15) != 8 { return -1 }
|
||||
return z_inflate(ptr_add(src, 2), len - 2, out, cap)
|
||||
return z_inflate(offset(src, 2), len - 2, out, cap)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -101,7 +101,7 @@ fn rt_tt_init() -> void {
|
|||
gc_oy = words(TT_GC)
|
||||
gc_adv = words(TT_GC)
|
||||
gc_bmp = bytes(TT_GC * 8)
|
||||
mem_set(gc_used, 0, TT_GC * 4)
|
||||
fill(gc_used, 0, TT_GC * 4)
|
||||
}
|
||||
|
||||
# ---- big-endian readers ---------------------------------------------------
|
||||
|
|
@ -368,9 +368,9 @@ fn tt_load_outline(id: int, gid: int, a: fixed, b: fixed, c: fixed, e: fixed, dx
|
|||
}
|
||||
start = last + 1
|
||||
}
|
||||
mem_free(flags)
|
||||
mem_free(xs)
|
||||
mem_free(ys)
|
||||
free(flags)
|
||||
free(xs)
|
||||
free(ys)
|
||||
} else {
|
||||
# composite glyph: components, each with its own placement and transform
|
||||
var p = g + 10
|
||||
|
|
|
|||
|
|
@ -152,7 +152,7 @@ fn tt_raster(id: int, gid: int, px: int) -> ptr {
|
|||
let SW = W * TT_SS
|
||||
let SH = H * TT_SS
|
||||
let cover = bytes(W * H)
|
||||
mem_set(cover, 0, W * H)
|
||||
fill(cover, 0, W * H)
|
||||
let unit = 255 / (TT_SS * TT_SS)
|
||||
|
||||
for sy in 0 .. SH {
|
||||
|
|
@ -250,7 +250,7 @@ fn tt_glyph_get(font: int, cp: int, px: int) -> int {
|
|||
let s = h
|
||||
if gc_used[s] == 1 {
|
||||
let old = gc_bmp[s]
|
||||
if (old == null) == false { mem_free(old) }
|
||||
if (old == null) == false { free(old) }
|
||||
}
|
||||
let bmp = tt_raster(font, tt_glyph_index(font, cp), px)
|
||||
gc_bmp[s] = bmp
|
||||
|
|
|
|||
|
|
@ -176,9 +176,9 @@ fn rt_ui_static_text(i: int, s: str) -> void {
|
|||
|
||||
# ---- text helpers: TrueType when a font is loaded, bitmap otherwise -------
|
||||
fn ui_str(i: int) -> ptr {
|
||||
if ui_hasdyn[i] == 1 { return ptr_add(ui_dyn, i * 96) }
|
||||
if ui_hasdyn[i] == 1 { return offset(ui_dyn, i * 96) }
|
||||
let t = ui_text[i]
|
||||
if (t == null) { return ptr_add(ui_dyn, i * 96) }
|
||||
if (t == null) { return offset(ui_dyn, i * 96) }
|
||||
return t
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue