spl/build.py

#!/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())