ludic/tools/x/prelude.ludic

# prelude.ludic — the shared runtime for `x`, the Ludic task runner.
#
# `x` replaces every build/test/bootstrap shell script in the repo: it is a
# single native binary (bin/x) that drives clang, the self-host compiler and the
# unix tools the same way the old *.sh files did — only now it is written in
# Ludic and compiled by Ludic. This fragment is the tiny standard library the
# commands lean on: process control, file IO, string trimming and a colored
# PASS/FAIL test harness. It carries no ECS, so it links as a plain CLI program.
#
# Everything runs relative to the current directory, so `x` must be invoked from
# the repository root (the one-line bootstrap in README.md does exactly that).

# ---- file IO ----------------------------------------------------------------

# read a whole file into a fresh NUL-terminated buffer (null if it cannot open)
function read_file(path: pointer) -> pointer {
  let f = file_open(path, "rb")
  if (f == null) { return null }
  file_seek(f, 0, 2)
  let n = file_tell(f)
  file_seek(f, 0, 0)
  let buf = bytes(n + 1)
  file_read(f, buf, n)
  buf[n] = 0
  file_close(f)
  return buf
}

# overwrite `path` with `s`; returns false if it could not be opened
function write_file(path: pointer, s: pointer) -> bool {
  let f = file_open(path, "wb")
  if (f == null) { return false }
  file_write(f, s, len(s))
  file_close(f)
  return true
}

function file_exists(path: pointer) -> bool { return shq(`test -e {path}`) }
function is_exec(path: pointer) -> bool { return shq(`test -x {path}`) }
# is `a` newer than `b` (like the shell's `-nt`)?
function newer(a: pointer, b: pointer) -> bool { return shq(`test {a} -nt {b}`) }

# ---- process control --------------------------------------------------------

# `run` returns the raw wait status; the program's exit code is the high byte.
function exit_code(st: int) -> int { return (st >> 8) & 255 }
# run a command, returning its exit code (0 = success)
function sh(cmd: pointer) -> int { return exit_code(run(cmd)) }
# run a command, true when it succeeded
function shq(cmd: pointer) -> bool { return exit_code(run(cmd)) == 0 }

# ---- scratch files ------------------------------------------------------------
# Every scratch file the runner writes lives under one per-process directory
# (`$TMPDIR/x_<pid>`), so `x test` and an `x check-*` can run side by side without
# clobbering each other's captures. main removes it on the way out.
var x_tmp: pointer = null

function tmp_dir() -> pointer {
  if x_tmp == null {
    var base = Os.temp_dir()
    if len(base) > 1 and base[len(base) - 1] == '/' { base = base[0..len(base) - 1] }   # macOS: TMPDIR ends in '/'
    x_tmp = `{base}/x_{Os.pid()}`
    run(`mkdir -p {x_tmp}`)
  }
  return x_tmp
}

# a scratch path under tmp_dir(): tmp_path("foo.out")
function tmp_path(name: pointer) -> pointer { return `{tmp_dir()}/{name}` }

# remove the scratch directory (idempotent; a no-op when nothing was written).
# X_KEEP_TMP=1 leaves it in place, and says where, for debugging a failing case.
function tmp_cleanup() -> void {
  if x_tmp == null { return }
  if getenv_or("X_KEEP_TMP", "0") == "1" { print(`scratch kept: {x_tmp}`) }
  else { run(`rm -rf {x_tmp}`) }
  x_tmp = null
}

# run `cmd` and return its stdout (stderr discarded). Never null.
function capture(cmd: pointer) -> pointer {
  let tmp = tmp_path("capture.out")
  run(`{cmd} > {tmp} 2>/dev/null`)
  let s = read_file(tmp)
  if (s == null) { return "" }
  return s
}

# run `cmd`, join its output lines with single spaces and trim — the Ludic twin
# of the shell idiom `$(cmd | tr '\n' ' ' | sed 's/ *$//')`.
function capture_line(cmd: pointer) -> pointer {
  return capture(`{cmd} | tr '\n' ' ' | sed 's/ *$//'`)
}

# the last line of a command's output (for one-line error messages)
function capture_tail(cmd: pointer) -> pointer {
  return capture(`{cmd} 2>&1 | tail -1`)
}

function getenv_or(name: pointer, dflt: pointer) -> pointer {
  let v = getenv(name)
  if (v == null) { return dflt }
  return v
}

# flatten a relative example path into a filesystem-safe token: '/' -> '_', so a
# categorised path like "games/snake" yields a single-segment temp name
# ("games_snake") that never implies a missing /tmp subdirectory.
function flat(p: pointer) -> pointer {
  let n = len(p)
  let b = bytes(n + 1)
  for i in 0 .. n {
    var c = p[i]
    if (c == '/') { c = 95 }   # '/' (47) -> '_' (95)
    b[i] = c
  }
  b[n] = 0
  return b
}

# ---- stdout helpers ---------------------------------------------------------

# write `s` with no trailing newline (print() always adds one)
function out(s: pointer) -> void { file_write(file_stdout(), s, len(s)) }
function err(s: pointer) -> void { file_write(file_stderr(), s, len(s)) }

# an ESC byte — the lexer has no \033, so build it by hand
function esc() -> pointer { let b = bytes(2); b[0] = 27; b[1] = 0; return b }
function c_green() -> pointer { return esc() + "[32m" }
function c_red() -> pointer { return esc() + "[31m" }
function c_reset() -> pointer { return esc() + "[0m" }

# ---- the PASS/FAIL test harness ---------------------------------------------

var PASS: int = 0
var FAIL: int = 0

function ok(msg: pointer) -> void {
  PASS += 1
  print(`  {c_green()}PASS{c_reset()} {msg}`)
}
function bad(msg: pointer) -> void {
  FAIL += 1
  print(`  {c_red()}FAIL{c_reset()} {msg}`)
}
function bad2(msg: pointer, detail: pointer) -> void {
  bad(msg)
  print(`        {detail}`)
}
# assert two strings equal, reporting the mismatch
function check(label: pointer, got: pointer, want: pointer) -> void {
  if (got == want) { ok(label) }
  else { bad2(label, `expected [{want}] got [{got}]`) }
}

# ---- host platform ----------------------------------------------------------
# A few cases exercise macOS-specific runtime ABI — Cocoa windowing, the BSD
# utsname/dirent layout — or compare against renders blessed on macOS. The
# self-hosted compiler and its C-free bootstrap are host-neutral (they produce
# byte-identical IR on any host), so the bulk of the suite runs anywhere; only
# these platform-bound cases are skipped — visibly, never silently — when the
# suite runs off Darwin. That lets a Linux CI runner gate every portable
# guarantee without red from the parts that are macOS-only today.
function host_os() -> pointer { return capture_line("uname -s") }
function is_darwin() -> bool { return host_os() == "Darwin" }
function skip(msg: pointer) -> void { print(`  skip  {msg}`) }

# print the "== N passed, M failed ==" footer and return the process exit code
function report() -> int {
  print("")
  print(`== {string(PASS)} passed, {string(FAIL)} failed ==`)
  if (FAIL == 0) { return 0 }
  return 1
}