Orkuncakilkaya
c804c4b0ee
stdin is read once, whole, and read_file serves a copy of it wherever the program opens <path> -
the entry, an import through a barrel, a component's .xml / .lss, an .lres. Paths match after
normalising both ('/' separators, relative under $PWD, . / .. / // folded, case on Windows);
diagnostics keep the file's usual name, with the buffer's lines and columns. A <path> nothing
opens is one warning. On ludic build it implies --check. Reseeded; bootstrap-cfree fixpoint holds.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
439 lines
21 KiB
Text
439 lines
21 KiB
Text
# main.ludic — the self-hosted Ludic front-end.
|
|
#
|
|
# ludicc lexes, parses, checks and lowers a .ludic file to LLVM IR, then drives
|
|
# clang (the IR assembler + system linker, the same role rustc/swiftc give it)
|
|
# to produce a native binary. No C is compiled: the emitted IR is Ludic's, and
|
|
# clang only assembles and links it.
|
|
#
|
|
# ludicc app.ludic -o bin/app # native binary (windowed if a game)
|
|
# ludicc app.ludic -o bin/app --headless # force headless
|
|
# ludicc app.ludic --emit-llvm -o app.ll # stop at the IR
|
|
# ludicc app.ludic --run # compile to a temp binary and run it
|
|
# ludicc app.ludic --target x86_64-pc-windows-msvc --emit-llvm -o app.ll
|
|
# # IR for another platform
|
|
#
|
|
# This is the compiler, not the command line a user of the language meets: that
|
|
# is `ludic` (tools/ludic-cli), which drives this. With no -o and no --run, IR
|
|
# still goes to stdout — the contract `ludic-dev reseed` and `ludic dev
|
|
# bootstrap` rely on, so the bootstrap is untouched.
|
|
#
|
|
# The target is the host unless --target names another. Only its platform is
|
|
# read, and only to choose between two runtimes: macOS (libSystem, Cocoa) and
|
|
# Windows (the UCRT and Win32, emit_win.ludic). The IR carries no triple either
|
|
# way; clang assembles it for the machine it runs on.
|
|
|
|
# basename: the part of a path after the last separator.
|
|
function base_name(path: pointer) -> pointer {
|
|
var last = -1
|
|
var i = 0
|
|
while path[i] != 0 { if is_sep(path[i]) { last = i }; i += 1 }
|
|
return path[last + 1..i]
|
|
}
|
|
|
|
# drop a trailing ".ludic" if present
|
|
function strip_ludic(name: pointer) -> pointer {
|
|
let n = len(name)
|
|
if n > 6 {
|
|
if (name[n - 6..n] == ".ludic") { return name[0..n - 6] }
|
|
}
|
|
return name
|
|
}
|
|
|
|
# env var with a fallback when unset
|
|
function getenv_or(name: pointer, dflt: pointer) -> pointer {
|
|
let v = getenv(name)
|
|
if (v == null) { return dflt }
|
|
return v
|
|
}
|
|
|
|
# guarantee a directory string ends in '/' so join_path concatenates cleanly
|
|
function ensure_slash(d: pointer) -> pointer {
|
|
let n = len(d)
|
|
if n == 0 { return d }
|
|
if d[n - 1] == '/' { return d }
|
|
return d + "/"
|
|
}
|
|
|
|
function die(msg: pointer) -> void {
|
|
if g_diag_json {
|
|
diag_add("", 0, 0, "error", msg)
|
|
diag_exit(1)
|
|
}
|
|
file_write(file_stderr(), msg, len(msg))
|
|
exit(1)
|
|
}
|
|
|
|
# strip trailing newline/carriage-return/space (the VERSION file's trailing \n)
|
|
function chomp(s: pointer) -> pointer {
|
|
var n = len(s)
|
|
while (n > 0) and ((s[n - 1] == '\n') or (s[n - 1] == '\r') or (s[n - 1] == ' ')) { n -= 1 }
|
|
return s[0..n]
|
|
}
|
|
|
|
# does `s` contain `sub`?
|
|
function has_sub(s: pointer, sub: pointer) -> bool {
|
|
let n = len(s); let m = len(sub)
|
|
var i = 0
|
|
while i + m <= n {
|
|
if s[i..i + m] == sub { return true }
|
|
i += 1
|
|
}
|
|
return false
|
|
}
|
|
|
|
# ---- the host shell ------------------------------------------------------------
|
|
# run() is the C library's system(), which is /bin/sh on macOS and cmd.exe on
|
|
# Windows. The compiler asks the shell for three things only - make a directory,
|
|
# delete a file, run a program - and says each in the host's own words.
|
|
|
|
# a copy of `p` with every '/' as '\', for cmd.exe, which reads '/' as a switch
|
|
function win_path(p: pointer) -> pointer {
|
|
let n = len(p)
|
|
let out = bytes(n + 1)
|
|
var i = 0
|
|
while i < n { if p[i] == '/' { out[i] = 92 } else { out[i] = p[i] }; i += 1 }
|
|
out[n] = 0
|
|
return out
|
|
}
|
|
|
|
function make_dir(d: pointer) -> void {
|
|
if host_is_windows() { let w = win_path(d); run(`if not exist "{w}" mkdir "{w}"`) }
|
|
else { run(`mkdir -p {d}`) }
|
|
}
|
|
|
|
function remove_file(p: pointer) -> void {
|
|
if host_is_windows() { run(`del /f /q "{win_path(p)}" 2>nul`) }
|
|
else { run(`rm -f {p}`) }
|
|
}
|
|
|
|
# the clang that assembles and links: $LUDIC_CC, else `clang` from $PATH - or, on a
|
|
# Windows host, the LLVM installer's own location when it is there, because that
|
|
# installer does not put clang on %PATH% unless asked to.
|
|
function find_cc() -> pointer {
|
|
let env = getenv("LUDIC_CC")
|
|
if (env != null) { return env }
|
|
if host_is_windows() {
|
|
let llvm = "C:/Program Files/LLVM/bin/clang.exe"
|
|
let f = file_open(llvm, "rb")
|
|
if (f != null) { file_close(f); return `"{llvm}"` }
|
|
}
|
|
return "clang"
|
|
}
|
|
|
|
# print "ludic <version>" and exit. The version is read at runtime from the
|
|
# VERSION file at the install root (the single source of truth a release bumps),
|
|
# so a version change never requires reseeding the compiler.
|
|
function show_version() -> void {
|
|
let v = read_file(join_path(ludic_home(), "VERSION"))
|
|
if (v == null) { print("ludic (version unknown)") }
|
|
else { print(`ludic {chomp(v)}`) }
|
|
exit(0)
|
|
}
|
|
|
|
entry {
|
|
var path = null
|
|
var out = null
|
|
var want = 0 # 0 = auto, 1 = windowed, 2 = headless
|
|
var emit_ir = false # --emit-llvm: stop after writing IR
|
|
var fmt = false # --fmt: lex + parse only, then exit (the doc-check gate)
|
|
var save = false # --save-temps: keep the intermediate .ll
|
|
var run = false # compile then execute the result
|
|
var target = null # --target <triple>: null means the host
|
|
var title = null # --title <name>: game_title() - the window's first title - instead of the program name
|
|
var gui = false # --gui: a Windows GUI-subsystem program (no console behind the window)
|
|
var links = new []pointer # --link <file>: an extra input to the link (a compiled resource)
|
|
var natives_out = null # --natives-out <file>: the package libraries linked, one a line (ludic bundle)
|
|
g_coverage = false # --coverage: instrument each statement with a per-line hit counter
|
|
|
|
var ai = 1
|
|
while ai < arg_count() {
|
|
let a = arg(ai)
|
|
if a == "--version" { show_version() }
|
|
else if a == "--windowed" { want = 1 }
|
|
else if a == "--headless" { want = 2 }
|
|
else if a == "--emit-llvm" { emit_ir = true }
|
|
else if a == "--unsafe" { g_unsafe_all = true } # L7: this program's own files may write `unsafe`
|
|
else if a == "--emit-module" { g_emit_module = true; emit_ir = true } # issue #64: prebuilt binary module IR
|
|
else if a == "--fmt" { fmt = true }
|
|
else if a == "--save-temps" { save = true }
|
|
else if a == "--run" { run = true }
|
|
else if a == "--check" { g_check_only = true }
|
|
else if a == "--no-maps" { g_pm_no_maps = true } # --check leaves the map directories alone (permap_check.ludic)
|
|
else if a == "--release" { g_release = true } # what ships: Build.schema_hash() is 0 (emit_schema_hash.ludic)
|
|
else if a == "--diagnostics=json" { g_diag_json = true } # every error, as JSON on stdout (diag.ludic)
|
|
else if a == "--diagnostics=text" { g_diag_json = false }
|
|
else if a == "--stdin-file" { ai += 1; if ai < arg_count() { stdin_file_set(arg(ai)) } } # stdin stands for that file (stdin_file.ludic)
|
|
else if a == "--emit-schema" { ai += 1; if ai < arg_count() { g_schema_out = arg(ai) } } # emit_schema.ludic
|
|
else if a == "--globals" { g_allow_globals = true }
|
|
else if a == "--migrate-state" { # 0.S2: write the plan ludic migrate state applies
|
|
ai += 1
|
|
if ai < arg_count() { g_mg_plan = arg(ai) }
|
|
g_migrate = true
|
|
g_allow_globals = true
|
|
}
|
|
else if a == "--migrate-prune" { g_mg_prune = true } # 0.S2: state parameters nothing uses go too
|
|
else if a == "--migrate-tighten" { # 0.R5: and `mut` goes where nothing down the chain writes
|
|
g_mg_prune = true
|
|
g_mg_tighten = true
|
|
}
|
|
else if a == "--migrate-runtime" { g_mg_runtime = true } # 0.S: the toolchain's own programs keep module-level vars # parse, type, module and port checks; nothing emitted
|
|
else if a == "--coverage" { g_coverage = true }
|
|
else if a == "--target" { ai += 1; if ai < arg_count() { target = arg(ai) } }
|
|
else if a == "--gui" { gui = true }
|
|
else if a == "--title" { ai += 1; if ai < arg_count() { title = arg(ai) } }
|
|
else if a == "--natives-out" { ai += 1; if ai < arg_count() { natives_out = arg(ai) } }
|
|
else if a == "--link" { ai += 1; if ai < arg_count() { push(links, arg(ai)) } }
|
|
else if a == "-o" { ai += 1; if ai < arg_count() { out = arg(ai) } }
|
|
else if a == "--escape-report" { g_es_report = true } # 25.3: the escape analysis alone, reported
|
|
else if fence_flag(a) { } # 25.1: --fence=, --fence-warm=, --fence-census=
|
|
else if a[0] == '-' {
|
|
# an unknown flag is ignored (with a note) rather than mistaken for the input file
|
|
let m = `ludicc: ignoring unknown flag {a}\n`
|
|
file_write(file_stderr(), m, len(m))
|
|
}
|
|
else { path = a }
|
|
ai += 1
|
|
}
|
|
|
|
if (path == null) {
|
|
die("usage: ludicc <file.ludic> [-o out] [--windowed|--headless] [--target triple] [--emit-llvm] [--save-temps]\n")
|
|
}
|
|
if (target != null) { g_target_win = has_sub(target, "windows") }
|
|
else { g_target_win = host_is_windows() }
|
|
|
|
let src = read_file(path)
|
|
if (src == null) { die("ludicc: cannot open input\n") }
|
|
|
|
fm_put(g_fm_src, path, src) # the schema reads docs and spans from it
|
|
cur_dir = dir_of(path)
|
|
g_src_name = base_name(path) # for panic/expect file:line messages
|
|
g_parse_file = path # for the compiler's own file:line diagnostics
|
|
g_act_main = path # 0.R: where the action drain is written
|
|
lex(src)
|
|
parse_program()
|
|
g_prog_user_end = len(prog)
|
|
# `ludic build` passes the package's `app name`, so the window opens under the name the
|
|
# player knows rather than the `program` name and is not retitled a moment later
|
|
if (title != null) and (len(title) > 0) { g_game_name = title } # decls from the user's source; runtime splice appends after
|
|
|
|
# --fmt is the doc-check gate: reaching here means it lexed and parsed. A parse
|
|
# error would already have exited nonzero, so a clean parse exits 0. (Canonical
|
|
# formatting output is not yet reimplemented on the self-hosted toolchain.)
|
|
if fmt { exit(0) }
|
|
|
|
maybe_splice_runtime()
|
|
fence_manifest(path) # 25.1: a `fence` line in the program's package.ludic
|
|
i18n_manifest(path) # phase 26: a `lang` line, and its en.po (i18n.ludic)
|
|
ui_register_gotos() # `goto:` buttons -> generated UiClicked listeners
|
|
|
|
# a game gets a window by default; a plain program stays headless. An explicit
|
|
# flag always wins. The stdout-IR path (no target) also stays headless, which
|
|
# is what `ludic-dev reseed` compiles the compiler itself with.
|
|
let has_target = run or (out != null)
|
|
if want == 1 { g_windowed = true }
|
|
else if want == 2 { g_windowed = false }
|
|
else { g_windowed = has_target and has_systems() }
|
|
|
|
g_parsing = false # lowering errors now locate by statement, not token
|
|
privates_rename() # L3: a module's private names are its own (privates.ludic)
|
|
check_duplicate_fns() # two declarations of one name: the cause, before its symptoms
|
|
check_duplicate_decls()
|
|
g_mg_entry = path
|
|
if g_migrate { mg_collect() } # 0.S2: the vars that move (migrate.ludic)
|
|
ix_start() # the lookups by name, as tables (emit_core.ludic)
|
|
check_program() # L4: the types agree before anything is emitted
|
|
i18n_check() # phase 26: keys against en.po, English left (i18n.ludic)
|
|
if g_es_report { escape_report() } # 25.3: which allocations never outlive their frame
|
|
else if g_arena { escape_analyse() } # 25.3: and they allocate from the frame's scratch
|
|
if g_arena_strict and (getenv_or("LUDIC_DEPS", "") == "") { # 25.3: the region rule, before anything is emitted
|
|
let sink = file_open("/dev/null", "wb")
|
|
deps_reach(sink)
|
|
file_close(sink)
|
|
}
|
|
if g_migrate { mg_finish() }
|
|
# --emit-schema FILE: the declarations, the registries and their entries as the checker resolved
|
|
# them (emit_schema.ludic); on its own it stops there, with -o or --check the build goes on
|
|
schema_hash_compute() # Build.schema_hash(), when the program asks and it is no release
|
|
if g_schema_out != null {
|
|
if not schema_write(g_schema_out) { die(`ludicc: cannot write {g_schema_out}\n`) }
|
|
if not g_check_only and not has_target and not emit_ir { diag_exit(0) }
|
|
}
|
|
# --check: every check a build makes - the emitter refuses things too (a bind to a function that is
|
|
# gone, an unknown name) - and nothing written
|
|
if g_check_only {
|
|
pm_check_maps() # every map's tables against their records (permap_check.ludic)
|
|
emit_program()
|
|
stdin_file_unreached() # --stdin-file naming a file nothing opened
|
|
if g_dg_errors > 0 { diag_exit(1) }
|
|
diag_exit(0)
|
|
}
|
|
emit_program()
|
|
stdin_file_unreached()
|
|
if g_dg_errors > 0 { diag_exit(1) } # errors a pass went on from (diag.ludic)
|
|
deps_flush() # LUDIC_DEPS=<file>: the module graph (ludic deps)
|
|
|
|
# --emit-llvm, or no binary target: emit IR and stop (stdout when out is null).
|
|
if emit_ir { ir_flush(out); return }
|
|
if not has_target { ir_flush(null); return }
|
|
|
|
|
|
# a run with no explicit -o lands in a temp file
|
|
if run and (out == null) {
|
|
if host_is_windows() { out = `{fwd_slashes(getenv_or("TEMP", "."))}/ludic-run-{strip_ludic(base_name(path))}` }
|
|
else { out = `/tmp/ludic-run-{strip_ludic(base_name(path))}` }
|
|
}
|
|
# a Windows program is found and run by its extension
|
|
if g_target_win {
|
|
let n = len(out)
|
|
var has_exe = false
|
|
if n >= 4 { has_exe = (out[n - 4..n] == ".exe") }
|
|
if not has_exe { out = out + ".exe" }
|
|
}
|
|
|
|
# make the output directory if the user asked for e.g. bin/app
|
|
let odir = dir_of(out)
|
|
if len(odir) > 0 { make_dir(odir) }
|
|
|
|
let ll = `{out}.ll`
|
|
if not ir_flush(ll) { die("ludicc: cannot write IR\n") }
|
|
|
|
let cc = find_cc()
|
|
let home = ludic_home()
|
|
|
|
# clang twice: assemble the IR, then link. A windowed build adds the macOS
|
|
# platform layer and the Cocoa framework.
|
|
# -Wno-override-module: the emitted IR carries no target triple, so clang
|
|
# substitutes the host's and warns about it on every single build. There is
|
|
# nothing to act on — the host default is exactly what we want — so it is off.
|
|
# $LUDIC_OPT=1 is a developer's faster build (never a bundle's: ludic bundle sets 2)
|
|
let opt = getenv_or("LUDIC_OPT", "2")
|
|
let objs = split_compile(ll, out, opt) # on every core when it can (split_build.ludic)
|
|
var cmd = `{cc} -O{opt} -Wno-override-module {ll}`
|
|
if objs != null { cmd = `{cc} -O{opt} -Wno-override-module{objs}` }
|
|
if g_target_win {
|
|
# The Windows window: win32.ll (user32, gdi32 for the software present, xinput
|
|
# for pads), and audio_win.ll when the program uses Audio.*, as on macOS.
|
|
if g_windowed {
|
|
let win32 = join_path(home, "runtime/native/win32.ll")
|
|
# xinput.lib carries an import named DllMain, which lld skips with a warning on every
|
|
# link; it is the SDK's, not a mistake in the program, so it is silenced
|
|
# ole32 for WIC, which decodes the splash and the window icon
|
|
cmd = `{cmd} {win32} -luser32 -lgdi32 -lxinput -lole32 -Wl,/ignore:importeddllmain`
|
|
if g_uses_audio {
|
|
let audiow = join_path(home, "runtime/native/audio_win.ll")
|
|
cmd = `{cmd} {audiow} -lxaudio2 -lole32`
|
|
}
|
|
}
|
|
}
|
|
else { if g_windowed {
|
|
let cocoa = join_path(home, "runtime/native/cocoa.ll")
|
|
# GameController holds no symbol cocoa.ll references directly (its classes are
|
|
# reached by name through objc_getClass), so a plain -framework link gets
|
|
# dead-stripped; -needed_framework forces the load command so the class is
|
|
# registered and #51's gamepad polling can see it.
|
|
cmd = `{cmd} {cocoa} -framework Cocoa -Wl,-needed_framework,GameController -Wl,-rpath,@loader_path`
|
|
# Audio.* (#22) pulls in the AVAudioPlayer backend and AVFoundation, but only
|
|
# when the program actually uses it — the snd_* calls are is_windowed()-guarded
|
|
# yet still live in a windowed build, so the backend must link.
|
|
if g_uses_audio {
|
|
let audio = join_path(home, "runtime/native/audio.ll")
|
|
cmd = `{cmd} {audio} -Wl,-needed_framework,AVFoundation`
|
|
}
|
|
} }
|
|
# Http.* (#6) links the native transport and Foundation (NSURLConnection etc.,
|
|
# reached by name). Works headless too, so it is outside the windowed block —
|
|
# macOS-only for now, which is where the toolchain runs.
|
|
# On Windows the transport is http_win.ll, over WinHTTP.
|
|
# Job.* / Promise.* / Sync.* link the OS threads behind Job.parallel_for and Sync.*:
|
|
# threads.ll (pthreads) or threads_win.ll (Win32).
|
|
if g_uses_jobs {
|
|
if g_target_win { cmd = `{cmd} {join_path(home, "runtime/native/threads_win.ll")}` }
|
|
else { cmd = `{cmd} {join_path(home, "runtime/native/threads.ll")}` }
|
|
}
|
|
# Udp.* links the socket layer: BSD sockets from libSystem on macOS, Winsock (ws2_32) on
|
|
# Windows.
|
|
if g_uses_udp {
|
|
if g_target_win { cmd = `{cmd} {join_path(home, "runtime/native/udp_win.ll")} -lws2_32` }
|
|
else { cmd = `{cmd} {join_path(home, "runtime/native/udp.ll")}` }
|
|
}
|
|
# Process.* links the child-process layer: posix_spawn from libSystem on macOS,
|
|
# CreateProcessW from kernel32 on Windows.
|
|
# Crypto.random_* / Uuid.* read RtlGenRandom on Windows, which advapi32 exports
|
|
if g_target_win and g_uses_cryptort { cmd = `{cmd} -ladvapi32` }
|
|
if g_uses_process {
|
|
if g_target_win { cmd = `{cmd} {join_path(home, "runtime/native/process_win.ll")}` }
|
|
else { cmd = `{cmd} {join_path(home, "runtime/native/process.ll")}` }
|
|
}
|
|
if g_uses_http {
|
|
if g_target_win {
|
|
let httpw = join_path(home, "runtime/native/http_win.ll")
|
|
cmd = `{cmd} {httpw} -lwinhttp`
|
|
} else {
|
|
let http = join_path(home, "runtime/native/http.ll")
|
|
cmd = `{cmd} {http} -Wl,-needed_framework,Foundation`
|
|
}
|
|
}
|
|
# Gl.* links the OpenGL backend: gl.ll (offscreen contexts, float helpers), the
|
|
# generated per-entry-point ABI thunks, and OpenGL.framework. Windowed or not.
|
|
# On Windows the same pair is gl_win.ll (a WGL context) and gl_thunks_win.ll (the
|
|
# thunks through a table wglGetProcAddress fills), against opengl32/gdi32/user32,
|
|
# with the window half from win32_gl.ll - or, headless, gl_win_nowin.ll's stubs.
|
|
if g_uses_gl {
|
|
if g_target_win {
|
|
let glw = join_path(home, "runtime/native/gl_win.ll")
|
|
let gltw = join_path(home, "runtime/native/gl_thunks_win.ll")
|
|
var glhalf = join_path(home, "runtime/native/gl_win_nowin.ll")
|
|
if g_windowed { glhalf = join_path(home, "runtime/native/win32_gl.ll") }
|
|
cmd = `{cmd} {glw} {gltw} {glhalf} -luser32 -lgdi32 -lopengl32`
|
|
} else {
|
|
let gl = join_path(home, "runtime/native/gl.ll")
|
|
let glt = join_path(home, "runtime/native/gl_thunks.ll")
|
|
cmd = `{cmd} {gl} {glt} -framework OpenGL`
|
|
}
|
|
}
|
|
# Vk.* links the generated thunks and the loader that fills them at run time:
|
|
# vk_win.ll (vulkan-1.dll) on Windows, vk_mac.ll (libvulkan.1.dylib, MoltenVK) on
|
|
# macOS. Neither links a Vulkan library, so the program starts without one.
|
|
if g_uses_vk {
|
|
let vkt = join_path(home, "runtime/native/vk_thunks.ll")
|
|
var vkl = join_path(home, "runtime/native/vk_mac.ll")
|
|
if g_target_win { vkl = join_path(home, "runtime/native/vk_win.ll") }
|
|
cmd = `{cmd} {vkt} {vkl}`
|
|
# the CAMetalLayer a macOS window presents through, found by name in cocoa.ll
|
|
if not g_target_win { cmd = `{cmd} -Wl,-needed_framework,QuartzCore` }
|
|
}
|
|
# A shipped Windows game is a GUI-subsystem program: started from Explorer, a
|
|
# console-subsystem one opens a console window behind the game. mainCRTStartup keeps
|
|
# the C runtime's ordinary main() entry rather than WinMain.
|
|
if g_target_win and gui { cmd = `{cmd} -Wl,/subsystem:windows -Wl,/entry:mainCRTStartup` }
|
|
# a package's native libraries (natives.ludic)
|
|
cmd = cmd + native_link_args(out)
|
|
var li = 0
|
|
while li < len(links) { cmd = `{cmd} "{links[li]}"`; li += 1 }
|
|
cmd = `{cmd} -o {out}`
|
|
|
|
# cmd.exe takes the first and last quote off a line that starts with one and holds more
|
|
# than two - which a quoted clang path plus a quoted --link file is - so on Windows the
|
|
# whole line wears one more pair for it to remove
|
|
var line = cmd
|
|
if host_is_windows() { line = `"{cmd}"` }
|
|
let rc = run(line)
|
|
if objs != null { split_clean(out) }
|
|
if not save { remove_file(ll) }
|
|
if rc != 0 { die("ludicc: link failed\n") }
|
|
if natives_out != null {
|
|
var nl = ""
|
|
var ni = 0
|
|
while ni < len(g_native_libs) { nl = nl + g_native_libs[ni] + "\n"; ni += 1 }
|
|
let nf = file_open(natives_out, "wb")
|
|
if nf != null { file_write(nf, nl, len(nl)); file_close(nf) }
|
|
}
|
|
|
|
# run mode: execute the binary we just built and forward its exit code.
|
|
# system() hands back a wait status on POSIX and the exit code itself on Windows.
|
|
if run {
|
|
if host_is_windows() { exit(run(`"{win_path(out)}"`)) }
|
|
let st = run(out)
|
|
exit(((st >> 8) & 255))
|
|
}
|
|
}
|