Add luajit

crates/luajit/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "luajit"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+path = "lib.rs"
+
+[features]
+default = ["enable-jit", "enable-ffi"]
+runtime = []
+enable-jit = []
+enable-ffi = []
+
+[dependencies]
+bitflags = { version = "2.9.1", features = ["std"] }
+bstr = "1.12.0"
+luaffi = { version = "0.1.0", path = "../luaffi" }
+thiserror = "2.0.12"
+
+[build-dependencies]
+bindgen = "0.71.1"
+cc = "1.2.26"
+which = "8.0.0"

crates/luajit/build.rs

@@ -0,0 +1,217 @@
+use std::{
+    env,
+    fs::{copy, create_dir_all, read_dir, write},
+    io, mem,
+    path::{Path, PathBuf},
+    process::Command,
+};
+use which::which;
+
+macro_rules! panic_err {
+    ($value:expr)                => { $value.unwrap_or_else(|err| panic!("{err}")) };
+    ($value:expr, $($arg:expr)+) => { $value.unwrap_or_else(|err| panic!("{}: {err}", format_args!($($arg),+))) };
+}
+
+macro_rules! env_name {
+    ($($arg:expr),+) => { format!($($arg),+).replace("-", "_").to_uppercase() };
+}
+
+macro_rules! env {
+    ($($arg:expr),+) => { panic_err!(env::var(env_name!($($arg),+))) };
+}
+
+macro_rules! cfg {
+    ($($arg:expr),+) => { env!("CARGO_CFG_{}", format_args!($($arg),+)) };
+}
+
+macro_rules! feature {
+    ($($arg:expr),+) => { env::var_os(env_name!("CARGO_FEATURE_{}", format_args!($($arg),+))).is_some() };
+}
+
+fn main() {
+    let src_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("src");
+    let out_path = PathBuf::from(env!("OUT_DIR"));
+
+    panic_err!(
+        copy_recursive(&src_path, &out_path),
+        "failed to copy luajit source (is the Git submodule initialised?)"
+    );
+
+    panic_err!(write(out_path.join(".relver"), get_relver()));
+    println!("cargo::rerun-if-changed={}", src_path.display());
+
+    build_runtime(&out_path.join("src"));
+    build_bindings(&out_path.join("src"));
+}
+
+fn get_relver() -> String {
+    let out = panic_err!(
+        Command::new("git")
+            .args(["show", "-s", "--format=%ct"])
+            .output(),
+        "failed to obtain release version (is the Git command available?)"
+    );
+
+    String::from_utf8_lossy(&out.stdout).into()
+}
+
+fn copy_recursive(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> io::Result<()> {
+    create_dir_all(dst.as_ref())?;
+
+    for entry in read_dir(src)? {
+        let entry = entry?;
+        if entry.file_name().to_str() == Some(".git") {
+            continue;
+        }
+
+        let path = dst.as_ref().join(entry.file_name());
+        if entry.file_type()?.is_dir() {
+            copy_recursive(entry.path(), path)?;
+        } else {
+            copy(entry.path(), path)?;
+        }
+    }
+
+    Ok(())
+}
+
+fn find_make() -> Command {
+    let name = match parse_target(&env!("HOST")) {
+        (_, _, "freebsd" | "openbsd" | "netbsd" | "dragonfly", _) => "gmake",
+        _ => "make",
+    };
+
+    Command::new(panic_err!(which(name), "failed to find make"))
+}
+
+fn find_cc(target: impl AsRef<str>) -> PathBuf {
+    let cc = cc::Build::new().target(target.as_ref()).get_compiler();
+    let path = panic_err!(which(cc.path()), "failed to find cc");
+    path.to_str().unwrap().into()
+}
+
+fn parse_target(target: &str) -> (&str, &str, &str, Option<&str>) {
+    let mut i = target.splitn(4, "-");
+    let arch = i.next().unwrap();
+    let vendor = i.next().unwrap();
+    let os = i.next().unwrap();
+    let env = i.next();
+    (arch, vendor, os, env)
+}
+
+fn build_runtime(src_path: &Path) {
+    let mut make = find_make();
+    let opt_level = env!("OPT_LEVEL");
+    let debug = opt_level == "0";
+
+    let host = env!("HOST");
+    let host_cc = find_cc(&host).to_str().unwrap().to_owned();
+    let host_ptr_width = 8 * mem::size_of::<usize>();
+
+    let target = env!("TARGET");
+    let target_cc = find_cc(&target).to_str().unwrap().to_owned();
+    // let target_features: HashSet<&str> = HashSet::from_iter(cfg!("target_feature").split(","));
+    let target_ptr_width: usize = cfg!("target_pointer_width").parse().unwrap();
+
+    if target == host {
+        println!("--- begin compile for {target}:");
+    } else {
+        println!("--- begin cross-compile on {host} for {target}:");
+    }
+
+    make.current_dir(&src_path)
+        .env_clear()
+        .arg("-e")
+        .env("PATH", env!("PATH"))
+        .env("MAKEFLAGS", env!("CARGO_MAKEFLAGS"))
+        .env("BUILDMODE", "static");
+
+    let ccopt = vec![format!("-O{opt_level} -fomit-frame-pointer")];
+
+    let mut xcflags = vec![
+        "-DLUAJIT_ENABLE_LUA52COMPAT",              // lua 5.2 compatibility
+        "-DLUAJIT_USE_SYSMALLOC",                   // disable bundled allocator
+        "-DLUAJIT_UNWIND_EXTERNAL -funwind-tables", // use external frame unwinding
+    ];
+
+    if debug {
+        make.env("CCDEBUG", "-g"); // generate debug information
+        xcflags.push("-DLUAJIT_USE_GDBJIT"); // gdb support
+        xcflags.push("-DLUA_USE_APICHECK -DLUA_USE_ASSERT"); // enable assertions
+    }
+
+    if !feature!("enable-jit") {
+        xcflags.push("-DLUAJIT_DISABLE_JIT");
+    }
+
+    if !feature!("enable-ffi") {
+        xcflags.push("-DLUAJIT_DISABLE_FFI");
+    }
+
+    match (host_ptr_width, target_ptr_width) {
+        (64, 64) | (32, 32) => make.env("HOST_CC", &host_cc),
+        (64, 32) => make.env("HOST_CC", format!("{} -m32", host_cc)),
+        (n, m) if n != m => panic!("cannot cross-compile on {n}-bit host for {m}-bit target"),
+        (n, _) => panic!("unsupported {n}-bit architecture"),
+    };
+
+    match cfg!("target_os").as_str() {
+        "linux" | "android" => make.env("TARGET_SYS", "Linux"),
+        "windows" => make.env("TARGET_SYS", "Windows"),
+        "macos" => make.env("TARGET_SYS", "Darwin").env(
+            "MACOSX_DEPLOYMENT_TARGET",
+            env::var("MACOSX_DEPLOYMENT_TARGET").as_deref().unwrap_or(
+                match cfg!("target_arch").as_str() {
+                    "x86_64" | "x86_64h" => "10.12",
+                    "aarch64" | "arm64" | "arm64e" => "11.0",
+                    arch => panic!("unsupported MacOS target architecture '{arch}'"),
+                },
+            ),
+        ),
+        "ios" => make.env("TARGET_SYS", "iOS"),
+        "solaris" => make.env("TARGET_SYS", "SunOS"),
+        _ => make.env("TARGET_SYS", "Other"),
+    };
+
+    if let Some(cross) = target_cc.strip_suffix("gcc") {
+        make.env("CC", "gcc").env("CROSS", cross);
+    } else if let Some(cross) = target_cc.strip_suffix("clang") {
+        make.env("CC", "clang").env("CROSS", cross);
+    } else {
+        let path = Path::new(&target_cc);
+        make.env("CC", path.file_name().unwrap())
+            .env("CROSS", format!("{}/", path.parent().unwrap().display()));
+    }
+
+    if let Some(path) = env::var("RUSTC_LINKER").ok() {
+        make.env("TARGET_LD", panic_err!(which(path), "failed to find ld"));
+    }
+
+    make.env("CCOPT", ccopt.join(" "))
+        .env("XCFLAGS", xcflags.join(" "));
+
+    let status = panic_err!(make.status(), "failed to execute make");
+    (!status.success()).then(|| panic!("failed to compile luajit: {status}: {make:?}"));
+
+    if feature!("runtime") {
+        println!("cargo::rustc-link-search=native={}", src_path.display());
+        println!("cargo::rustc-link-lib=static=luajit");
+    }
+}
+
+fn build_bindings(src_path: &Path) {
+    let mut bindgen = bindgen::builder()
+        .clang_arg(format!("--target={}", env!("TARGET")))
+        .allowlist_item(r"^(lua|LUA).*_.+$")
+        .formatter(bindgen::Formatter::None)
+        .default_macro_constant_type(bindgen::MacroTypeVariation::Signed)
+        .generate_cstr(true);
+
+    for header in ["lua.h", "lualib.h", "lauxlib.h", "luaconf.h", "luajit.h"] {
+        bindgen = bindgen.header(src_path.join(header).to_str().unwrap());
+    }
+
+    let path = src_path.join("bindgen.rs");
+    panic_err!(panic_err!(bindgen.generate(), "failed to generate bindings").write_to_file(&path));
+    println!("cargo::rustc-env=LJ_BINDINGS={}", path.display());
+}