use std::path::{Path, PathBuf};
pub mod winappsdk;
pub fn windows_kits_roots() -> Vec<PathBuf> {
let mut roots = Vec::new();
if let Ok(v) = std::env::var("DAY_WINDOWS_KITS_ROOT") {
roots.push(PathBuf::from(v));
}
if let Ok(v) = std::env::var("WindowsSdkDir") {
roots.push(PathBuf::from(v));
}
for pf in ["ProgramFiles(x86)", "ProgramFiles"] {
if let Ok(v) = std::env::var(pf) {
roots.push(PathBuf::from(v).join("Windows Kits").join("10"));
}
}
roots.dedup();
roots
}
pub fn cppwinrt_include() -> Option<PathBuf> {
if let Ok(v) = std::env::var("DAY_CPPWINRT") {
let p = PathBuf::from(v);
if p.join("winrt").join("base.h").exists() {
return Some(p);
}
return None;
}
let mut found: Vec<PathBuf> = Vec::new();
for root in windows_kits_roots() {
let Ok(rd) = std::fs::read_dir(root.join("Include")) else {
continue;
};
for entry in rd.flatten() {
let cppwinrt = entry.path().join("cppwinrt");
if cppwinrt.join("winrt").join("base.h").exists() {
found.push(cppwinrt);
}
}
}
found.sort(); found.pop()
}
pub fn cppwinrt_include_for_build_script() -> Option<PathBuf> {
for var in ["DAY_CPPWINRT", "DAY_WINDOWS_KITS_ROOT", "WindowsSdkDir"] {
println!("cargo:rerun-if-env-changed={var}");
}
cppwinrt_include()
}
pub fn windows_kit_tool(tool: &str) -> Option<PathBuf> {
if let Ok(root) = std::env::var("DAY_WINDOWS_KIT") {
let p = PathBuf::from(root).join(tool);
if p.exists() {
return Some(p);
}
}
if let Some(p) = on_path(tool) {
return Some(p);
}
let arch = if cfg!(target_arch = "aarch64") {
"arm64"
} else {
"x64"
};
for root in windows_kits_roots() {
let Ok(rd) = std::fs::read_dir(root.join("bin")) else {
continue;
};
let mut versions: Vec<PathBuf> = rd
.flatten()
.map(|e| e.path())
.filter(|p| {
p.file_name()
.is_some_and(|n| n.to_string_lossy().starts_with("10."))
})
.collect();
versions.sort();
while let Some(v) = versions.pop() {
let candidate = v.join(arch).join(tool);
if candidate.exists() {
return Some(candidate);
}
}
}
None
}
pub fn makensis() -> Option<PathBuf> {
if let Ok(v) = std::env::var("DAY_MAKENSIS") {
let p = PathBuf::from(v);
if p.is_file() {
return Some(p);
}
return None; }
if let Some(p) = on_path("makensis").or_else(|| on_path("makensis.exe")) {
return Some(p);
}
for pf in ["ProgramFiles(x86)", "ProgramFiles"] {
if let Ok(v) = std::env::var(pf) {
let p = PathBuf::from(v).join("NSIS").join("makensis.exe");
if p.exists() {
return Some(p);
}
}
}
let choco = std::env::var("ChocolateyInstall")
.map(PathBuf::from)
.unwrap_or_else(|_| PathBuf::from(r"C:\ProgramData\chocolatey"));
let shim = choco.join("bin").join("makensis.exe");
if shim.is_file() {
return Some(shim);
}
let tools = choco.join("lib").join("nsis").join("tools");
if let Ok(entries) = std::fs::read_dir(&tools) {
for entry in entries.flatten() {
for candidate in [
entry.path().join("makensis.exe"),
entry.path().join("Bin").join("makensis.exe"),
] {
if candidate.is_file() {
return Some(candidate);
}
}
}
}
None
}
pub fn android_sdk_dir() -> PathBuf {
if let Ok(v) = std::env::var("ANDROID_HOME").or_else(|_| std::env::var("ANDROID_SDK_ROOT")) {
return PathBuf::from(v);
}
let default = default_android_sdk_dir();
if default.is_dir() {
return default;
}
android_studio_sdk_setting()
.filter(|p| p.is_dir())
.unwrap_or(default)
}
fn default_android_sdk_dir() -> PathBuf {
if cfg!(target_os = "windows")
&& let Ok(v) = std::env::var("LOCALAPPDATA")
{
return PathBuf::from(v).join("Android").join("Sdk");
}
let home = home_dir();
if cfg!(target_os = "macos") {
home.join("Library/Android/sdk")
} else {
home.join("Android/Sdk")
}
}
fn home_dir() -> PathBuf {
PathBuf::from(
std::env::var("HOME")
.or_else(|_| std::env::var("USERPROFILE"))
.unwrap_or_default(),
)
}
pub fn android_studio_homes() -> Vec<PathBuf> {
let home = home_dir();
let mut candidates: Vec<PathBuf> = Vec::new();
if let Ok(v) = std::env::var("ANDROID_STUDIO_HOME") {
candidates.push(PathBuf::from(v));
}
if cfg!(target_os = "macos") {
for apps in [PathBuf::from("/Applications"), home.join("Applications")] {
for name in ["Android Studio.app", "Android Studio Preview.app"] {
candidates.push(apps.join(name).join("Contents"));
}
}
} else if cfg!(target_os = "windows") {
for var in ["ProgramFiles", "ProgramFiles(x86)"] {
if let Ok(v) = std::env::var(var) {
candidates.push(PathBuf::from(v).join("Android").join("Android Studio"));
}
}
if let Ok(v) = std::env::var("LOCALAPPDATA") {
candidates.push(PathBuf::from(&v).join("Programs").join("Android Studio"));
candidates.push(PathBuf::from(v).join("JetBrains/Toolbox/apps/android-studio"));
}
} else {
candidates.extend([
PathBuf::from("/snap/android-studio/current"),
PathBuf::from("/opt/android-studio"),
PathBuf::from("/usr/local/android-studio"),
home.join("android-studio"),
home.join(".local/share/JetBrains/Toolbox/apps/android-studio"),
PathBuf::from(
"/var/lib/flatpak/app/com.google.AndroidStudio/current/active/files/extra/android-studio",
),
home.join(
".local/share/flatpak/app/com.google.AndroidStudio/current/active/files/extra/android-studio",
),
]);
}
candidates.dedup();
candidates.retain(|p| p.join("bin").is_dir() || p.join("MacOS").is_dir());
candidates
}
pub fn android_studio_jbr() -> Option<PathBuf> {
let java = if cfg!(windows) { "java.exe" } else { "java" };
android_studio_homes().into_iter().find_map(|studio| {
[studio.join("jbr/Contents/Home"), studio.join("jbr")]
.into_iter()
.find(|jdk| jdk.join("bin").join(java).is_file())
})
}
pub fn android_studio_sdk_setting() -> Option<PathBuf> {
let home = home_dir();
let config = if cfg!(target_os = "macos") {
home.join("Library/Application Support/Google")
} else if cfg!(target_os = "windows") {
PathBuf::from(std::env::var("APPDATA").ok()?).join("Google")
} else {
std::env::var("XDG_CONFIG_HOME")
.map(PathBuf::from)
.unwrap_or_else(|_| home.join(".config"))
.join("Google")
};
let mut dirs: Vec<PathBuf> = std::fs::read_dir(&config)
.ok()?
.filter_map(|e| e.ok().map(|e| e.path()))
.filter(|p| {
p.file_name()
.and_then(|n| n.to_str())
.is_some_and(|n| n.starts_with("AndroidStudio"))
})
.collect();
dirs.sort();
dirs.iter().rev().find_map(|dir| {
let xml = std::fs::read_to_string(dir.join("options/android.sdk.path.xml")).ok()?;
parse_studio_sdk_path(&xml, &home)
})
}
fn parse_studio_sdk_path(xml: &str, home: &Path) -> Option<PathBuf> {
let at = xml.find("androidSdkAbsolutePath")?;
let rest = &xml[at..];
let start = rest.find("value=\"")? + "value=\"".len();
let end = rest[start..].find('"')?;
let raw = &rest[start..start + end];
let expanded = match raw.strip_prefix("$USER_HOME$") {
Some(tail) => format!("{}{tail}", home.display()),
None => raw.to_string(),
};
(!expanded.is_empty()).then(|| PathBuf::from(expanded))
}
pub fn android_sdkmanager() -> Option<PathBuf> {
let name = if cfg!(windows) {
"sdkmanager.bat"
} else {
"sdkmanager"
};
let tools = android_sdk_dir().join("cmdline-tools");
let latest = tools.join("latest/bin").join(name);
if latest.is_file() {
return Some(latest);
}
let mut versions: Vec<PathBuf> = std::fs::read_dir(&tools)
.ok()?
.filter_map(|e| e.ok().map(|e| e.path().join("bin").join(name)))
.filter(|p| p.is_file())
.collect();
versions.sort();
versions.pop()
}
pub fn adb_bin() -> String {
let exe = if cfg!(windows) { "adb.exe" } else { "adb" };
let in_sdk = android_sdk_dir().join("platform-tools").join(exe);
if in_sdk.is_file() {
return in_sdk.display().to_string();
}
exe.to_string()
}
pub fn jdk_home() -> Option<PathBuf> {
if let Ok(v) = std::env::var("JAVA_HOME") {
return Some(PathBuf::from(v));
}
if let Some(jbr) = android_studio_jbr() {
return Some(jbr);
}
if cfg!(target_os = "macos") {
if let Ok(out) = std::process::Command::new("/usr/libexec/java_home")
.args(["-v", "17+"])
.output()
&& out.status.success()
{
let p = PathBuf::from(String::from_utf8_lossy(&out.stdout).trim());
if p.join("bin/java").exists() {
return Some(p);
}
}
for keg in ["openjdk", "openjdk@21", "openjdk@17"] {
for prefix in ["/opt/homebrew", "/usr/local"] {
let p = PathBuf::from(prefix).join("opt").join(keg);
if p.join("bin/java").exists() {
return Some(p);
}
}
}
}
None
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum WasmCc {
Env(String),
PathClang,
Fallback(PathBuf),
Missing,
}
pub fn wasm_cc() -> WasmCc {
for var in [
"CC_wasm32-unknown-unknown",
"CC_wasm32_unknown_unknown",
"TARGET_CC",
"CC",
] {
if let Ok(v) = std::env::var(var)
&& let Some(program) = v.split_whitespace().next()
{
return WasmCc::Env(program.to_string());
}
}
if emits_wasm32(Path::new("clang")) {
return WasmCc::PathClang;
}
let mut candidates: Vec<PathBuf> = ["/opt/homebrew", "/usr/local"]
.iter()
.map(|prefix| PathBuf::from(prefix).join("opt/llvm/bin/clang"))
.collect();
let per_user = std::env::var("HOME")
.ok()
.map(|h| PathBuf::from(h).join("Library/Developer/Toolchains"));
let system = Some(PathBuf::from("/Library/Developer/Toolchains"));
for base in [per_user, system].into_iter().flatten() {
candidates.push(base.join("swift-latest.xctoolchain/usr/bin/clang"));
if let Ok(entries) = std::fs::read_dir(&base) {
let mut toolchains: Vec<PathBuf> = entries
.flatten()
.map(|e| e.path())
.filter(|p| p.extension().is_some_and(|e| e == "xctoolchain"))
.collect();
toolchains.sort();
toolchains.reverse();
candidates.extend(toolchains.into_iter().map(|p| p.join("usr/bin/clang")));
}
}
candidates
.into_iter()
.find(|c| c.is_file() && emits_wasm32(c))
.map(WasmCc::Fallback)
.unwrap_or(WasmCc::Missing)
}
pub fn emits_wasm32(cc: &Path) -> bool {
std::process::Command::new(cc)
.arg("--print-targets")
.output()
.ok()
.filter(|o| o.status.success())
.is_some_and(|o| {
String::from_utf8_lossy(&o.stdout)
.lines()
.any(|l| l.trim().starts_with("wasm32 "))
})
}
pub fn rustup_cargo() -> Result<(PathBuf, PathBuf), String> {
let rustup_home = std::env::var("RUSTUP_HOME")
.map(PathBuf::from)
.or_else(|_| {
std::env::var("HOME")
.map(|h| PathBuf::from(h).join(".rustup"))
.map_err(|e| e.to_string())
})?;
let toolchains = rustup_home.join("toolchains");
let mut entries: Vec<PathBuf> = std::fs::read_dir(&toolchains)
.map_err(|_| "no rustup toolchains (cross-std needs rustup, not Homebrew rust)")?
.flatten()
.map(|e| e.path())
.collect();
entries.sort();
let chosen = entries
.iter()
.find(|p| {
p.file_name()
.is_some_and(|n| n.to_string_lossy().starts_with("stable-"))
})
.or_else(|| entries.first())
.ok_or("empty rustup toolchains dir")?;
let bin = chosen.join("bin");
Ok((bin.join("cargo"), bin))
}
fn on_path(tool: &str) -> Option<PathBuf> {
let path = std::env::var_os("PATH")?;
std::env::split_paths(&path)
.map(|d| d.join(tool))
.find(|p| p.is_file())
}
pub fn is_dir(dir: &Path) -> bool {
dir.is_dir()
}
#[cfg(test)]
mod tests {
#[test]
fn studio_sdk_path_expands_user_home() {
use std::path::{Path, PathBuf};
let xml = r#"<application>
<component name="AndroidSdkPathStore">
<option name="androidSdkAbsolutePath" value="$USER_HOME$/Android/Sdk" />
</component>
</application>"#;
assert_eq!(
super::parse_studio_sdk_path(xml, Path::new("/home/ada")),
Some(PathBuf::from("/home/ada/Android/Sdk"))
);
let abs = r#"<option name="androidSdkAbsolutePath" value="/data/sdk" />"#;
assert_eq!(
super::parse_studio_sdk_path(abs, Path::new("/home/ada")),
Some(PathBuf::from("/data/sdk"))
);
assert_eq!(
super::parse_studio_sdk_path("<application/>", Path::new("/")),
None
);
}
use super::*;
#[test]
fn kits_roots_honor_override_first() {
unsafe { std::env::set_var("DAY_WINDOWS_KITS_ROOT", "/custom/kits/10") };
let roots = windows_kits_roots();
assert_eq!(roots[0], PathBuf::from("/custom/kits/10"));
unsafe { std::env::remove_var("DAY_WINDOWS_KITS_ROOT") };
}
#[test]
fn android_sdk_honors_android_home() {
unsafe { std::env::set_var("ANDROID_HOME", "/custom/android") };
assert_eq!(android_sdk_dir(), PathBuf::from("/custom/android"));
unsafe { std::env::remove_var("ANDROID_HOME") };
}
#[test]
fn wasm_cc_honors_cc_variables_unprobed() {
unsafe { std::env::set_var("CC_wasm32-unknown-unknown", "/custom/clang --sysroot=/x") };
assert_eq!(wasm_cc(), WasmCc::Env("/custom/clang".to_string()));
unsafe { std::env::remove_var("CC_wasm32-unknown-unknown") };
}
#[test]
fn explicit_cppwinrt_override_must_validate() {
unsafe { std::env::set_var("DAY_CPPWINRT", "/does/not/exist") };
assert_eq!(cppwinrt_include(), None); unsafe { std::env::remove_var("DAY_CPPWINRT") };
}
#[test]
fn explicit_makensis_override_must_validate() {
unsafe { std::env::set_var("DAY_MAKENSIS", "/does/not/exist/makensis.exe") };
assert_eq!(makensis(), None); unsafe { std::env::remove_var("DAY_MAKENSIS") };
}
#[test]
fn makensis_found_in_chocolatey_layouts() {
let base = std::env::temp_dir().join(format!("day-choco-probe-{}", std::process::id()));
let shimmed = base.join("shim");
let unpacked = base.join("unpacked");
let nested = base.join("nested");
let _ = std::fs::remove_dir_all(&base);
let shim_exe = shimmed.join("bin").join("makensis.exe");
std::fs::create_dir_all(shim_exe.parent().unwrap()).unwrap();
std::fs::write(&shim_exe, b"").unwrap();
let flat = unpacked
.join("lib/nsis/tools")
.join("nsis-3.10")
.join("makensis.exe");
std::fs::create_dir_all(flat.parent().unwrap()).unwrap();
std::fs::write(&flat, b"").unwrap();
let deep = nested
.join("lib/nsis/tools")
.join("nsis-3.10")
.join("Bin")
.join("makensis.exe");
std::fs::create_dir_all(deep.parent().unwrap()).unwrap();
std::fs::write(&deep, b"").unwrap();
let (path, pf, pf86) = (
std::env::var_os("PATH"),
std::env::var_os("ProgramFiles"),
std::env::var_os("ProgramFiles(x86)"),
);
unsafe {
std::env::remove_var("DAY_MAKENSIS");
std::env::set_var("PATH", "");
std::env::set_var("ProgramFiles", base.join("no-such-pf"));
std::env::set_var("ProgramFiles(x86)", base.join("no-such-pf86"));
}
let found: Vec<_> = [(&shimmed, &shim_exe), (&unpacked, &flat), (&nested, &deep)]
.iter()
.map(|(root, want)| {
unsafe { std::env::set_var("ChocolateyInstall", root) };
(makensis(), (*want).clone())
})
.collect();
unsafe {
std::env::remove_var("ChocolateyInstall");
match path {
Some(v) => std::env::set_var("PATH", v),
None => std::env::remove_var("PATH"),
}
match pf {
Some(v) => std::env::set_var("ProgramFiles", v),
None => std::env::remove_var("ProgramFiles"),
}
match pf86 {
Some(v) => std::env::set_var("ProgramFiles(x86)", v),
None => std::env::remove_var("ProgramFiles(x86)"),
}
}
let _ = std::fs::remove_dir_all(&base);
for (got, want) in found {
assert_eq!(got.as_ref(), Some(&want), "chocolatey layout {want:?}");
}
}
}