bac 0.1.0

Rust bindings for the BAC compiler backend
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use std::{
    env,
    path::{Path, PathBuf},
    process::Command,
};

fn run(command: &mut Command) {
    let status = command
        .status()
        .unwrap_or_else(|error| panic!("{command:?}: {error}"));
    assert!(status.success(), "{command:?} failed: {status}");
}

fn watch(path: &Path) {
    if path.is_dir() {
        for entry in path.read_dir().unwrap() {
            let path = entry.unwrap().path();
            if path
                .file_name()
                .is_some_and(|name| name == "rust" || name == "c")
            {
                continue;
            }
            watch(&path);
        }
    } else {
        println!("cargo:rerun-if-changed={}", path.display());
    }
}

fn main() {
    for key in ["BAC_LIB_PATH", "ODIN"] {
        println!("cargo:rerun-if-env-changed={key}");
    }
    let manifest = PathBuf::from(env::var_os("CARGO_MANIFEST_DIR").unwrap());
    let root = manifest.join("../../..").canonicalize().unwrap();
    let out = PathBuf::from(env::var_os("OUT_DIR").unwrap());
    let library = if env::var_os("CARGO_FEATURE_BUILD_FROM_SOURCE").is_some() {
        assert_eq!(
            env::var("HOST").unwrap(),
            env::var("TARGET").unwrap(),
            "build-from-source currently builds for the host; supply a target BAC_LIB_PATH for cross compilation"
        );
        watch(&root.join("bac"));
        watch(&root.join("utils"));
        let object = out.join("bac.o");
        run(
            Command::new(env::var_os("ODIN").unwrap_or_else(|| "odin".into()))
                .current_dir(&root)
                .args([
                    "build",
                    "bac/bindgen/lib",
                    "-build-mode:obj",
                    "-no-entry-point",
                    "-use-single-module",
                    "-o:size",
                    "-source-code-locations:none",
                    "-disable-assert",
                    "-no-bounds-check",
                    "-no-type-assert",
                    "-define:NO_FMT=true",
                    "-default-to-nil-allocator",
                    "-define:ARNA_DISABLE_VIRTUAL=true",
                    "-define:ARNA_DISABLE_THREAD_LOCAL=true",
                    "-disable-init-fini",
                    "-define:INIT_FINI=false",
                ])
                .arg(format!("-out:{}", object.display())),
        );
        object
    } else {
        env::var_os("BAC_LIB_PATH")
            .map(PathBuf::from)
            .unwrap_or_else(|| root.join("bac/bindgen/lib/lib.o"))
    };
    assert!(
        library.is_file(),
        "BAC library not found at {}. Set BAC_LIB_PATH to a BAC object/static archive, run build-bac, or enable --features build-from-source (requires Odin).",
        library.display()
    );
    if env::var_os("CARGO_FEATURE_BUILD_FROM_SOURCE").is_none() {
        println!("cargo:rerun-if-changed={}", library.display());
    }
    let library = library.canonicalize().unwrap();
    let modifiers = if library.extension().is_some_and(|ext| ext == "a") {
        "+verbatim"
    } else {
        "-bundle,+verbatim"
    };
    println!(
        "cargo:rustc-link-search=native={}",
        library.parent().unwrap().display()
    );
    println!(
        "cargo:rustc-link-lib=static:{modifiers}={}",
        library.file_name().unwrap().to_str().unwrap()
    );
}