std: restructure — std/ modules, namespace tail, std/xml.sx

allocators/fs/process/socket/log/trace/test move under modules/std/ (allocators.sx becomes std/mem.sx; the Allocator protocol moves into the std.sx prelude, impls stay in mem.sx). New std/xml.sx holds xml_escape as xml.escape. std.sx gains the carried namespace tail — flat-importing std.sx now also provides mem./xml./log. — with the remaining modules (fs/process/socket/json/cli/hash/test) deferred from the tail until the global last-wins maps are fully own-wins (pulling them into every closure collides bare names corpus-wide; they stay direct imports: modules/std/fs.sx etc.). log.sx's internal emit renamed log_emit (it clobbered consumer fns named emit program-wide). bundle.sx uses xml.escape via the carried alias. Consumer import paths swept mechanically; .ir snapshots recaptured for the larger std closure. m3te + game build unchanged.
2026-06-11 06:10:59 +03:00
parent ee00db849c
commit 59f0aa7716
112 changed files with 18612 additions and 15988 deletions
--- a/library/modules/std/fs.sx
+++ b/library/modules/std/fs.sx
@@ -0,0 +1,268 @@
+#import "modules/std.sx";
+
+// =====================================================================
+// fs.sx — file system stdlib (POSIX backend, macOS values).
+//
+// Allocation contract: every returned `string` or slice is allocated
+// from `context.allocator`. Callers are responsible for releasing it
+// (typically via an arena reset).
+//
+// Handle ownership: `File` is a small value-typed handle wrapping the
+// POSIX file descriptor. Methods are provided for read/write/close;
+// the value is invalid (fd == -1) after `close()`.
+//
+// Scope (Phase 1A): file I/O + directory creation/deletion + path
+// helpers needed for `.app` bundling. Recursive walkers, `stat`, and
+// the full path module land in subsequent phases.
+// =====================================================================
+
+libc :: #library "c";
+
+// ── Low-level libc bindings ─────────────────────────────────────────
+// These declare the actual libc symbols and must use the libc names
+// verbatim (no prefix), so they live at module top-level. The public
+// API below wraps them. Users should not call these directly.
+//
+// macOS `open` is variadic in C (`int open(const char*, int, ...)`);
+// declared with `..args: []s32` so the mode is passed via the C
+// variadic tail. Without that, the mode arg goes to the wrong
+// register on arm64 and the file ends up with mode 0.
+
+open   :: (path: [:0]u8, flags: s32, ..args: []s32) -> s32 #foreign libc;
+close  :: (fd: s32) -> s32 #foreign libc;
+read   :: (fd: s32, buf: [*]u8, count: usize) -> isize #foreign libc;
+write  :: (fd: s32, buf: [*]u8, count: usize) -> isize #foreign libc;
+lseek  :: (fd: s32, offset: s64, whence: s32) -> s64 #foreign libc;
+unlink :: (path: [:0]u8) -> s32 #foreign libc;
+rmdir  :: (path: [:0]u8) -> s32 #foreign libc;
+mkdir  :: (path: [:0]u8, mode: u32) -> s32 #foreign libc;
+access :: (path: [:0]u8, mode: s32) -> s32 #foreign libc;
+chmod  :: (path: [:0]u8, mode: u32) -> s32 #foreign libc;
+rename :: (oldp: [:0]u8, newp: [:0]u8) -> s32 #foreign libc;
+
+// macOS POSIX constants. Linux values differ; split into platform-
+// conditional includes when we gain a Linux host.
+O_RDONLY :s32: 0x0000;
+O_WRONLY :s32: 0x0001;
+O_RDWR   :s32: 0x0002;
+O_APPEND :s32: 0x0008;
+O_CREAT  :s32: 0x0200;
+O_TRUNC  :s32: 0x0400;
+
+SEEK_SET :s32: 0;
+SEEK_CUR :s32: 1;
+SEEK_END :s32: 2;
+
+F_OK :s32: 0;
+
+// ── Public types ─────────────────────────────────────────────────────
+
+OpenMode :: enum {
+    read;        // O_RDONLY
+    write;       // O_WRONLY | O_CREAT | O_TRUNC
+    append;      // O_WRONLY | O_CREAT | O_APPEND
+    read_write;  // O_RDWR
+}
+
+SeekFrom :: enum { set; current; end; }
+
+File :: struct {
+    fd: s32 = -1;
+
+    is_valid :: (self: *File) -> bool { self.fd >= 0 }
+
+    close :: (self: *File) -> bool {
+        if self.fd < 0 { return false; }
+        rc := close(self.fd);
+        self.fd = -1;
+        rc == 0
+    }
+
+    read :: (self: *File, buf: string) -> s64 {
+        if self.fd < 0 { return -1; }
+        n := read(self.fd, buf.ptr, xx buf.len);
+        cast(s64) n
+    }
+
+    write :: (self: *File, data: string) -> s64 {
+        if self.fd < 0 { return -1; }
+        n := write(self.fd, data.ptr, xx data.len);
+        cast(s64) n
+    }
+
+    seek :: (self: *File, offset: s64, whence: SeekFrom) -> s64 {
+        if self.fd < 0 { return -1; }
+        w := SEEK_SET;
+        if whence == .current { w = SEEK_CUR; }
+        if whence == .end     { w = SEEK_END; }
+        lseek(self.fd, offset, w)
+    }
+}
+
+// ── High-level file API ─────────────────────────────────────────────
+// Named `open_file` (not `open`) so they don't shadow libc's `open`
+// symbol; the latter is needed for `#foreign libc` to resolve. Same
+// idea for `delete_file`/`delete_dir` vs libc's `unlink`/`rmdir`,
+// `set_mode` vs libc's `chmod`, etc.
+
+mode_to_flags :: (m: OpenMode) -> s32 {
+    if m == .read       { return O_RDONLY; }
+    if m == .write      { return O_WRONLY | O_CREAT | O_TRUNC; }
+    if m == .append     { return O_WRONLY | O_CREAT | O_APPEND; }
+    if m == .read_write { return O_RDWR; }
+    O_RDONLY
+}
+
+open_file :: (path: [:0]u8, mode: OpenMode) -> ?File {
+    fd := open(path, mode_to_flags(mode), 420); // 0o644 = 420
+    if fd < 0 { return null; }
+    File.{ fd = fd }
+}
+
+// One-shot read: opens, slurps the whole file into a fresh buffer,
+// closes. Returns null on any failure. Uses libc directly (not File
+// methods) so it remains callable from the post-link IR interpreter,
+// which doesn't yet handle `*Self` method dispatch on locally-
+// unwrapped optionals.
+read_file :: (path: [:0]u8) -> ?string {
+    fd := open(path, O_RDONLY, 0);
+    if fd < 0 { return null; }
+    size := lseek(fd, 0, SEEK_END);
+    if size < 0 { close(fd); return null; }
+    lseek(fd, 0, SEEK_SET);
+    buf := cstring(size);
+    n := read(fd, buf.ptr, xx size);
+    close(fd);
+    if cast(s64) n != size { return null; }
+    buf
+}
+
+// One-shot write: creates / truncates and writes the whole buffer.
+write_file :: (path: [:0]u8, data: string) -> bool {
+    fd := open(path, O_WRONLY | O_CREAT | O_TRUNC, 420); // 0o644
+    if fd < 0 { return false; }
+    n := write(fd, data.ptr, xx data.len);
+    close(fd);
+    cast(s64) n == cast(s64) data.len
+}
+
+append_file :: (path: [:0]u8, data: string) -> bool {
+    fd := open(path, O_WRONLY | O_CREAT | O_APPEND, 420);
+    if fd < 0 { return false; }
+    n := write(fd, data.ptr, xx data.len);
+    close(fd);
+    cast(s64) n == cast(s64) data.len
+}
+
+// ── Single-syscall ops ───────────────────────────────────────────────
+
+exists :: (path: [:0]u8) -> bool {
+    access(path, F_OK) == 0
+}
+
+delete_file :: (path: [:0]u8) -> bool {
+    unlink(path) == 0
+}
+
+delete_dir :: (path: [:0]u8) -> bool {
+    rmdir(path) == 0
+}
+
+create_dir :: (path: [:0]u8) -> bool {
+    mkdir(path, 493) == 0 // 0o755 = 493
+}
+
+set_mode :: (path: [:0]u8, mode: u32) -> bool {
+    chmod(path, mode) == 0
+}
+
+move :: (oldp: [:0]u8, newp: [:0]u8) -> bool {
+    rename(oldp, newp) == 0
+}
+
+// Recursive mkdir -p. Walks the path and creates each missing
+// segment. Treats existing directories as success.
+create_dir_all :: (path: [:0]u8) -> bool {
+    if path.len == 0 { return true; }
+    if exists(path) { return true; }
+    last := path.len - 1;
+    while last > 0 {
+        if path[last] == 47 { break; }
+        last -= 1;
+    }
+    if last > 0 {
+        parent := cstring(last);
+        memcpy(parent.ptr, path.ptr, last);
+        if !create_dir_all(parent) { return false; }
+    }
+    create_dir(path)
+}
+
+// Copy a file by streaming through a 64KB buffer. Uses libc directly
+// (not File methods) — same interpreter-compat reason as read_file.
+// No metadata is preserved beyond what `open` creates (mode 0644).
+// Caller is responsible for setting executable bits with `set_mode`.
+copy_file :: (src: [:0]u8, dst: [:0]u8) -> bool {
+    src_fd := open(src, O_RDONLY, 0);
+    if src_fd < 0 { return false; }
+    dst_fd := open(dst, O_WRONLY | O_CREAT | O_TRUNC, 420);
+    if dst_fd < 0 {
+        close(src_fd);
+        return false;
+    }
+    ok := true;
+    buf := cstring(65536);
+    loop := true;
+    while loop {
+        n := read(src_fd, buf.ptr, 65536);
+        if n < 0 { ok = false; loop = false; }
+        if n == 0 { loop = false; }
+        if n > 0 {
+            w := write(dst_fd, buf.ptr, xx n);
+            if w != cast(isize) n { ok = false; loop = false; }
+        }
+    }
+    close(src_fd);
+    close(dst_fd);
+    ok
+}
+
+// ── Path helpers ─────────────────────────────────────────────────────
+// `path_join` is in std.sx (used widely beyond fs). These are the
+// fs-adjacent helpers — basename/dirname operate purely on text.
+
+basename :: (p: string) -> string {
+    if p.len == 0 { return ""; }
+    last := p.len - 1;
+    while last > 0 {
+        if p[last] != 47 { break; }
+        last -= 1;
+    }
+    end := last + 1;
+    while last > 0 {
+        if p[last - 1] == 47 { return substr(p, last, end - last); }
+        last -= 1;
+    }
+    substr(p, 0, end)
+}
+
+dirname :: (p: string) -> string {
+    if p.len == 0 { return ""; }
+    last := p.len - 1;
+    while last > 0 {
+        if p[last] != 47 { break; }
+        last -= 1;
+    }
+    while last > 0 {
+        if p[last] == 47 {
+            while last > 0 {
+                if p[last - 1] != 47 { break; }
+                last -= 1;
+            }
+            return substr(p, 0, last);
+        }
+        last -= 1;
+    }
+    if p[0] == 47 { return "/"; }
+    "."
+}