stage0
This commit is contained in:
417
build.py
Normal file
417
build.py
Normal file
@@ -0,0 +1,417 @@
|
||||
#!/usr/bin/env python3
|
||||
"""SPL build system — .c → .o → exe, .spl → .sir, deps auto-resolved."""
|
||||
|
||||
import argparse
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parent
|
||||
BUILD_DIR = ROOT / "build"
|
||||
CACHE_FILE = BUILD_DIR / ".build_cache.json"
|
||||
DESC_FILE = ROOT / "project_desc.py"
|
||||
EXE_EXT = ".exe" if os.name == "nt" else ""
|
||||
|
||||
CC = os.environ.get("CC", "gcc")
|
||||
CFLAGS = os.environ.get("CFLAGS", "-Wall -Wextra -O0 -g").split()
|
||||
|
||||
def load_desc():
|
||||
ns = {"__builtins__": __builtins__}
|
||||
exec(DESC_FILE.read_text(), ns)
|
||||
return {
|
||||
"exe": ns.get("exe", {}),
|
||||
"spl": ns.get("spl", {}),
|
||||
"pipeline": ns.get("pipeline", {}),
|
||||
}
|
||||
|
||||
# ── Helpers ─────────────────────────────────────────────────────────────
|
||||
|
||||
def obj_key(src):
|
||||
return src.rsplit(".", 1)[0].replace("/", "_").replace("\\", "_")
|
||||
|
||||
def obj_path(src):
|
||||
return BUILD_DIR / (obj_key(src) + ".o")
|
||||
|
||||
def exe_path(name):
|
||||
return BUILD_DIR / (name + EXE_EXT)
|
||||
|
||||
def sir_path(name):
|
||||
return BUILD_DIR / (name + ".sir")
|
||||
|
||||
# ── Cache ───────────────────────────────────────────────────────────────
|
||||
|
||||
def load_cache():
|
||||
if CACHE_FILE.is_file():
|
||||
try:
|
||||
return json.loads(CACHE_FILE.read_text())
|
||||
except (json.JSONDecodeError, OSError):
|
||||
pass
|
||||
return {}
|
||||
|
||||
def save_cache(cache):
|
||||
BUILD_DIR.mkdir(parents=True, exist_ok=True)
|
||||
CACHE_FILE.write_text(json.dumps(cache, indent=2))
|
||||
|
||||
def hash_file(p):
|
||||
h = hashlib.sha256()
|
||||
with p.open("rb") as f:
|
||||
while chunk := f.read(65536):
|
||||
h.update(chunk)
|
||||
return h.hexdigest()
|
||||
|
||||
# ── C compilation ───────────────────────────────────────────────────────
|
||||
|
||||
_built_objs = set()
|
||||
|
||||
def compile_c(src, cache, force):
|
||||
key = f"obj:{src}"
|
||||
dst = obj_path(src)
|
||||
src_path = ROOT / src
|
||||
|
||||
if not src_path.is_file():
|
||||
print(f" ERR {src} not found"); return False
|
||||
|
||||
h = hashlib.sha256()
|
||||
h.update(hash_file(src_path).encode())
|
||||
h.update(" ".join(CFLAGS).encode())
|
||||
ch = h.hexdigest()
|
||||
|
||||
cached = cache.get(key)
|
||||
if not force and cached and cached["h"] == ch and dst.is_file():
|
||||
_built_objs.add(src); return True
|
||||
|
||||
BUILD_DIR.mkdir(parents=True, exist_ok=True)
|
||||
cmd = [CC] + CFLAGS + ["-c", str(src_path), "-o", str(dst)]
|
||||
print(f" CC {src}")
|
||||
if subprocess.run(cmd).returncode: return False
|
||||
cache[key] = {"h": ch}
|
||||
_built_objs.add(src)
|
||||
return True
|
||||
|
||||
def link_exe(name, sources, cache, force):
|
||||
key = f"exe:{name}"
|
||||
dst = exe_path(name)
|
||||
|
||||
# hash = concat of all input obj hashes + name
|
||||
h = hashlib.sha256(name.encode())
|
||||
for src in sources:
|
||||
cached = cache.get(f"obj:{src}", {})
|
||||
h.update(cached.get("h", "?").encode())
|
||||
ch = h.hexdigest()
|
||||
|
||||
cached = cache.get(key)
|
||||
if not force and cached and cached["h"] == ch and dst.is_file():
|
||||
return True
|
||||
|
||||
cmd = [CC] + CFLAGS + [str(obj_path(s)) for s in sources] + ["-o", str(dst)]
|
||||
print(f" LINK {name}")
|
||||
if subprocess.run(cmd).returncode: return False
|
||||
cache[key] = {"h": ch}
|
||||
return True
|
||||
|
||||
# ── SPL compilation ─────────────────────────────────────────────────────
|
||||
|
||||
def find_imports(src_path):
|
||||
"""Scan source for @import("path") directives, return resolved paths."""
|
||||
deps = []
|
||||
try:
|
||||
text = src_path.read_text(errors="replace")
|
||||
except OSError:
|
||||
return deps
|
||||
idx = 0
|
||||
while True:
|
||||
idx = text.find('@import("', idx)
|
||||
if idx < 0:
|
||||
break
|
||||
start = idx + 9
|
||||
end = text.find('")', start)
|
||||
if end < 0:
|
||||
break
|
||||
imp_path = text[start:end]
|
||||
imp_file = (src_path.parent / imp_path).resolve()
|
||||
if imp_file.is_file():
|
||||
deps.append(imp_file)
|
||||
idx = end + 2
|
||||
return deps
|
||||
|
||||
def collect_deps(src_path):
|
||||
"""Collect all transitive @import dependencies."""
|
||||
seen = set()
|
||||
result = []
|
||||
def walk(p):
|
||||
p = p.resolve()
|
||||
if p in seen:
|
||||
return
|
||||
seen.add(p)
|
||||
for dep in find_imports(p):
|
||||
walk(dep)
|
||||
result.append(dep)
|
||||
walk(src_path)
|
||||
return result
|
||||
|
||||
def compile_spl(name, src, compiler, desc, cache, force):
|
||||
key = f"spl:{name}"
|
||||
dst = sir_path(name)
|
||||
src_path = ROOT / src
|
||||
|
||||
if not src_path.is_file():
|
||||
print(f" ERR {src} not found"); return False
|
||||
|
||||
h = hashlib.sha256()
|
||||
h.update(hash_file(src_path).encode())
|
||||
|
||||
# Hash @import dependencies (transitive)
|
||||
for dep in collect_deps(src_path):
|
||||
h.update(hash_file(dep).encode())
|
||||
|
||||
# Determine how to run the compiler
|
||||
if compiler in desc.get("spl", {}):
|
||||
# SPL-based compiler: run via VM runner
|
||||
cinfo = desc["spl"][compiler]
|
||||
pl = desc.get("pipeline", {}).get(cinfo.get("pipeline", ""), {})
|
||||
runner = pl.get("runner") or cinfo.get("runner", "spl_cli")
|
||||
runner_exe = exe_path(runner)
|
||||
sir = sir_path(compiler)
|
||||
if runner_exe.is_file():
|
||||
h.update(hash_file(runner_exe).encode())
|
||||
if os.path.isfile(sir):
|
||||
h.update(hash_file(Path(sir)).encode())
|
||||
ch = h.hexdigest()
|
||||
cached = cache.get(key)
|
||||
if not force and cached and cached["h"] == ch and dst.is_file():
|
||||
return True
|
||||
BUILD_DIR.mkdir(parents=True, exist_ok=True)
|
||||
cmd = [str(runner_exe), str(sir), str(src_path), str(dst)]
|
||||
print(f" SPL {name} ({compiler} via {runner})")
|
||||
else:
|
||||
# Native exe compiler
|
||||
ce = exe_path(compiler)
|
||||
if ce.is_file():
|
||||
h.update(hash_file(ce).encode())
|
||||
ch = h.hexdigest()
|
||||
cached = cache.get(key)
|
||||
if not force and cached and cached["h"] == ch and dst.is_file():
|
||||
return True
|
||||
BUILD_DIR.mkdir(parents=True, exist_ok=True)
|
||||
cmd = [str(ce), str(src_path), str(dst)]
|
||||
print(f" SPL {name} ({compiler})")
|
||||
|
||||
if subprocess.run(cmd).returncode: return False
|
||||
cache[key] = {"h": ch}
|
||||
return True
|
||||
|
||||
# ── Dependency-aware build ──────────────────────────────────────────────
|
||||
|
||||
_built = set()
|
||||
|
||||
def build(name, desc, cache, force):
|
||||
"""Build target + all deps (auto-resolved DAG traversal)."""
|
||||
if name in _built:
|
||||
return True
|
||||
|
||||
if name in desc.get("exe", {}):
|
||||
sources = desc["exe"][name]
|
||||
for src in sources:
|
||||
if not compile_c(src, cache, force):
|
||||
return False
|
||||
if not link_exe(name, sources, cache, force):
|
||||
return False
|
||||
|
||||
elif name in desc.get("spl", {}):
|
||||
info = desc["spl"][name]
|
||||
pl = desc.get("pipeline", {}).get(info.get("pipeline", ""), {})
|
||||
compiler = pl.get("compiler") or info.get("compiler")
|
||||
if not compiler:
|
||||
print(f" ERR '{name}': no compiler in pipeline '{info.get('pipeline')}'")
|
||||
return False
|
||||
if not build(compiler, desc, cache, force):
|
||||
return False
|
||||
if not compile_spl(name, info["src"], compiler, desc, cache, force):
|
||||
return False
|
||||
|
||||
else:
|
||||
print(f" ERR unknown target '{name}'")
|
||||
return False
|
||||
|
||||
_built.add(name)
|
||||
return True
|
||||
|
||||
def build_all(desc, cache, force):
|
||||
targets = list(desc.get("exe", {})) + list(desc.get("spl", {}))
|
||||
for t in targets:
|
||||
if not build(t, desc, cache, force):
|
||||
return False
|
||||
return True
|
||||
|
||||
# ── Run ─────────────────────────────────────────────────────────────────
|
||||
|
||||
def run_target(name, desc, cache, force, extra_args):
|
||||
if name in desc.get("exe", {}):
|
||||
if not build(name, desc, cache, force):
|
||||
return 1
|
||||
exe = exe_path(name)
|
||||
print(f" RUN {name}")
|
||||
return subprocess.run([str(exe)] + extra_args).returncode
|
||||
|
||||
if name in desc.get("spl", {}):
|
||||
info = desc["spl"][name]
|
||||
pl = desc.get("pipeline", {}).get(info.get("pipeline", ""), {})
|
||||
runner = pl.get("runner") or info.get("runner", "spl_cli")
|
||||
if not runner:
|
||||
print(f" ERR '{name}': no runner"); return 1
|
||||
if not build(name, desc, cache, force):
|
||||
return 1
|
||||
if not build(runner, desc, cache, force):
|
||||
return 1
|
||||
print(f" RUN {name} (via {runner})")
|
||||
return subprocess.run(
|
||||
[str(exe_path(runner)), str(sir_path(name))] + extra_args
|
||||
).returncode
|
||||
|
||||
if name in desc.get("pipeline", {}):
|
||||
pl = desc["pipeline"][name]
|
||||
compiler = pl.get("compiler")
|
||||
runner = pl.get("runner")
|
||||
if not compiler or not runner:
|
||||
print(f" ERR pipeline '{name}' missing compiler or runner"); return 1
|
||||
if not extra_args:
|
||||
print(" ERR usage: run <pipeline> <src> [args]"); return 1
|
||||
src = extra_args[0]
|
||||
|
||||
if not build(compiler, desc, cache, force): return 1
|
||||
if not build(runner, desc, cache, force): return 1
|
||||
|
||||
sir_name = "pipeline_" + hashlib.sha256(str(ROOT / src).encode()).hexdigest()[:8]
|
||||
if not compile_spl(sir_name, src, compiler, desc, cache, force):
|
||||
return 1
|
||||
|
||||
print(f" RUN pipeline {name} ({src})")
|
||||
return subprocess.run(
|
||||
[str(exe_path(runner)), str(sir_path(sir_name))] + extra_args[1:]
|
||||
).returncode
|
||||
|
||||
print(f" ERR unknown target '{name}'"); return 1
|
||||
|
||||
# ── Clean / List ────────────────────────────────────────────────────────
|
||||
|
||||
def clean():
|
||||
if BUILD_DIR.is_dir():
|
||||
shutil.rmtree(BUILD_DIR)
|
||||
print(f" CLEAN {BUILD_DIR}")
|
||||
|
||||
def list_targets(desc):
|
||||
print("Executables (.c → .o → exe):")
|
||||
for name, sources in desc.get("exe", {}).items():
|
||||
print(f" {name}")
|
||||
for s in sources:
|
||||
print(f" {s}")
|
||||
if desc.get("spl"):
|
||||
print("\nSPL programs (.spl → .sir via pipeline):")
|
||||
for name, info in desc["spl"].items():
|
||||
pl_name = info.get("pipeline", "-")
|
||||
print(f" {name} pipeline={pl_name} src={info['src']}")
|
||||
if desc.get("pipeline"):
|
||||
print("\nPipelines:")
|
||||
for name, pl in desc["pipeline"].items():
|
||||
print(f" {name} compiler={pl['compiler']} runner={pl.get('runner', '-')}")
|
||||
|
||||
# ── CLI ─────────────────────────────────────────────────────────────────
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description="SPL build system")
|
||||
sub = parser.add_subparsers(dest="command")
|
||||
|
||||
bp = sub.add_parser("build", help="build targets (default: all)")
|
||||
bp.add_argument("targets", nargs="*")
|
||||
bp.add_argument("-f", "--force", action="store_true")
|
||||
|
||||
rp = sub.add_parser("run", help="build and run a target, or run pipeline <name> <src> [args]")
|
||||
rp.add_argument("target")
|
||||
rp.add_argument("extra", nargs="*")
|
||||
|
||||
sub.add_parser("test", help="build and run VM unit tests")
|
||||
sub.add_parser("clean", help="remove build artifacts")
|
||||
sub.add_parser("list", help="list all targets")
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
if not DESC_FILE.is_file():
|
||||
print(f"ERR {DESC_FILE} not found"); return 1
|
||||
|
||||
# Default: build all
|
||||
if args.command is None:
|
||||
desc = load_desc(); cache = load_cache()
|
||||
ok = build_all(desc, cache, False)
|
||||
save_cache(cache)
|
||||
return 0 if ok else 1
|
||||
|
||||
# Build
|
||||
if args.command == "build":
|
||||
desc = load_desc(); cache = load_cache()
|
||||
if args.targets:
|
||||
ok = all(build(t, desc, cache, args.force) for t in args.targets)
|
||||
else:
|
||||
ok = build_all(desc, cache, args.force)
|
||||
save_cache(cache)
|
||||
return 0 if ok else 1
|
||||
|
||||
# Run
|
||||
if args.command == "run":
|
||||
desc = load_desc(); cache = load_cache()
|
||||
rc = run_target(args.target, desc, cache, False, args.extra)
|
||||
save_cache(cache)
|
||||
return rc
|
||||
|
||||
# Pipeline: build compiler → compile .spl → run via runner
|
||||
if args.command == "pipeline":
|
||||
desc = load_desc(); cache = load_cache()
|
||||
pl = desc.get("pipeline", {}).get(args.name)
|
||||
if not pl:
|
||||
print(f" ERR unknown pipeline '{args.name}'"); return 1
|
||||
compiler = pl.get("compiler")
|
||||
runner = pl.get("runner")
|
||||
if not compiler or not runner:
|
||||
print(f" ERR pipeline '{args.name}' missing compiler or runner"); return 1
|
||||
src_path = ROOT / args.src
|
||||
if not src_path.is_file():
|
||||
print(f" ERR source not found: {args.src}"); return 1
|
||||
|
||||
# Build compiler + runner
|
||||
if not build(compiler, desc, cache, False): return 1
|
||||
if not build(runner, desc, cache, False): return 1
|
||||
|
||||
# Compile .spl → .sir (temp name = src path hash)
|
||||
sir_name = "pipeline_" + hashlib.sha256(str(src_path).encode()).hexdigest()[:8]
|
||||
if not compile_spl(sir_name, args.src, compiler, desc, cache, False):
|
||||
return 1
|
||||
|
||||
# Run .sir via runner
|
||||
print(f" PIPELINE {args.name} ({args.src})")
|
||||
rc = subprocess.run(
|
||||
[str(exe_path(runner)), str(sir_path(sir_name))] + args.extra
|
||||
).returncode
|
||||
save_cache(cache)
|
||||
return rc
|
||||
|
||||
# Test
|
||||
if args.command == "test":
|
||||
desc = load_desc(); cache = load_cache()
|
||||
ok = build("test", desc, cache, False)
|
||||
save_cache(cache)
|
||||
if not ok: return 1
|
||||
return subprocess.run([str(exe_path("test"))]).returncode
|
||||
|
||||
# Clean / List
|
||||
if args.command == "clean":
|
||||
clean(); return 0
|
||||
if args.command == "list":
|
||||
list_targets(load_desc()); return 0
|
||||
|
||||
return 0
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
Reference in New Issue
Block a user