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 }

# run `cmd` and return its stdout (stderr discarded). Never null.
function capture(cmd: pointer) -> pointer {
  let tmp = "/tmp/x_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 == 47) { 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 = PASS + 1
  print(`  {c_green()}PASS{c_reset()} {msg}`)
}
function bad(msg: pointer) -> void {
  FAIL = 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}]`) }
}

# 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
}