Orkuncakilkaya
e175619543
`ludic help` ended with a section titled "contributing to the toolchain itself", listing bootstrap, reseed, docs-gen and release tasks. None of that is available to someone who installed the language — those tasks need the repository — so the shipped tool was advertising work its user cannot do, in a namespace they have to read past to find `new` and `run`. The tasks move to a second program, dev.ludic -> bin/ludic-dev, built from a checkout and excluded from every release artifact. `ludic` keeps the project and package commands and nothing else; `ludic dev …` now explains where the tasks went instead of failing as an unknown command. What this shook out: the two programs share prelude/build/project/pkg, so the helpers each had accreted in whichever file first needed them — cc(), ensure_ludicc, the string functions, title_case, cmd_version — moved to where both can see them. The argument-shift indirection added for the `dev` namespace is gone with the namespace, so commands read argv directly again. `ludic-dev test` asserts the split rather than trusting it: the staged install must build a project, and `ludic dev build` there must fail while naming ludic-dev. install.sh keeps building older tags, whose bootstrap goes through main.ludic. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
74 lines
3.4 KiB
Text
74 lines
3.4 KiB
Text
# build.ludic — turning a .ludic file into an executable.
|
|
#
|
|
# compile_app is the one place that happens, shared by `ludic build` / `ludic
|
|
# run` and by the contributor tool, so a user's build and the repo's own example
|
|
# builds cannot drift apart. Everything the toolchain owns — the compiler, the
|
|
# engine runtime it splices — is addressed through ludic_home(), so the same code
|
|
# path works from a checkout and from an installed ~/.ludic.
|
|
|
|
# ensure bin/ludicc exists and is current with the seed. Built from the checked-in
|
|
# IR seed with clang alone — no C compiler is ever involved.
|
|
function ensure_ludicc() -> void {
|
|
if not in_toolchain_repo() { return }
|
|
run("mkdir -p bin build")
|
|
if (not is_exec("bin/ludicc")) or newer("selfhost/ludicc.seed.ll", "bin/ludicc") {
|
|
print("cc: selfhost/ludicc.seed.ll -> bin/ludicc (from the IR seed, no C compiler)")
|
|
if not shq(`{cc()} selfhost/ludicc.seed.ll -o bin/ludicc`) {
|
|
err("ludic: could not assemble the seed\n"); exit(1)
|
|
}
|
|
}
|
|
}
|
|
|
|
# ---- compiling one program to a native binary -------------------------------
|
|
#
|
|
# mode 1 = windowed (a game opens a real window), 2 = headless (the last frame is
|
|
# rendered to build/out.ppm from piped input — deterministic output for tests).
|
|
# Returns true on success. `ludic build`, `ludic run` and the contributor tool all
|
|
# go through here.
|
|
function compile_app(src: pointer, out: pointer, mode: int, save: bool) -> bool {
|
|
ensure_ludicc() # in a checkout: assemble the seed if bin/ludicc is missing or stale
|
|
let home = ludic_home()
|
|
let pbf = prebuilt_link_flags() # #64: link resolved prebuilt module dylibs, if any
|
|
let odir = dir_of_path(out)
|
|
if len(odir) > 0 { run(`mkdir -p {odir}`) }
|
|
run("mkdir -p build")
|
|
let ll = `{out}.ll`
|
|
|
|
if mode == 2 {
|
|
if not shq(`{ludicc()} --headless {src} --emit-llvm -o {ll}`) { return false }
|
|
if not shq(`{cc()} -O2 {ll}{pbf} -o {out}`) { return false }
|
|
if not save { run(`rm -f {ll}`) }
|
|
return true
|
|
}
|
|
|
|
if not shq(`{ludicc()} --windowed {src} --emit-llvm -o {ll}`) { return false }
|
|
# audio.ll (#22) is always linked here — unused snd_* are dead-stripped; the
|
|
# canonical `ludicc -o` path links it only when Audio.* is used.
|
|
let cocoa = `{home}runtime/native/cocoa.ll`
|
|
let audio = `{home}runtime/native/audio.ll`
|
|
if not shq(`{cc()} -O2 {ll} {cocoa} {audio} -framework Cocoa -Wl,-needed_framework,GameController -Wl,-needed_framework,AVFoundation -Wl,-rpath,@loader_path{pbf} -o {out}`) { return false }
|
|
if not save { run(`rm -f {ll}`) }
|
|
return true
|
|
}
|
|
|
|
# the directory part of a path, without the trailing '/' ("" when there is none)
|
|
function dir_of_path(p: pointer) -> pointer {
|
|
var last = -1
|
|
var i = 0
|
|
while p[i] != 0 { if p[i] == '/' { last = i }; i += 1 }
|
|
if last < 0 { return "" }
|
|
return p[0..last]
|
|
}
|
|
|
|
# Remove every generated artifact and leave the tracked source untouched: the
|
|
# whole build/ tree (IR, objects, compiled apps, the headless render at
|
|
# build/out.ppm), and any stray *.tmp/*.ll left behind by a failed build. A
|
|
# legacy out.ppm in the root (from an older toolchain) is swept too. Binaries in
|
|
# bin/ are kept so the running CLI survives; in the toolchain repo, rebuild them
|
|
# any time with `ludic-dev build`.
|
|
function cmd_clean() -> int {
|
|
run("rm -rf build")
|
|
run("rm -f out.ppm bin/*.tmp")
|
|
print("cleaned: build/ (incl. build/out.ppm) and stray artifacts (bin/ is left alone)")
|
|
return 0
|
|
}
|