mirror of
https://github.com/denoland/deno.git
synced 2024-12-22 23:34:47 -05:00
139 lines
4.6 KiB
Rust
139 lines
4.6 KiB
Rust
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
|
|
// This is used in cli/build.rs and core/build.rs to interface with the GN build
|
|
// system (which defines the deno build).
|
|
|
|
use std::env;
|
|
use std::path::{self, Path, PathBuf};
|
|
use std::process::Command;
|
|
|
|
pub struct Build {
|
|
gn_mode: String,
|
|
root: PathBuf,
|
|
pub gn_out_dir: String,
|
|
pub gn_out_path: PathBuf,
|
|
pub check_only: bool,
|
|
}
|
|
|
|
impl Build {
|
|
pub fn setup() -> Build {
|
|
let gn_mode = if cfg!(target_os = "windows") {
|
|
// On Windows, we need to link with a release build of libdeno, because
|
|
// rust always uses the release CRT.
|
|
// TODO(piscisaureus): make linking with debug libdeno possible.
|
|
String::from("release")
|
|
} else {
|
|
// Cargo sets PROFILE to either "debug" or "release", which conveniently
|
|
// matches the build modes we support.
|
|
env::var("PROFILE").unwrap()
|
|
};
|
|
|
|
// cd into workspace root.
|
|
assert!(env::set_current_dir("..").is_ok());
|
|
|
|
let root = env::current_dir().unwrap();
|
|
// If not using host default target the output folder will change
|
|
// target/release will become target/$TARGET/release
|
|
// Gn should also be using this output directory as well
|
|
// most things will work with gn using the default
|
|
// output directory but some tests depend on artifacts
|
|
// being in a specific directory relative to the main build output
|
|
let gn_out_path = root.join(format!("target/{}", gn_mode.clone()));
|
|
let gn_out_dir = normalize_path(&gn_out_path);
|
|
|
|
// Tell Cargo when to re-run this file. We do this first, so these directives
|
|
// can take effect even if something goes wrong later in the build process.
|
|
println!("cargo:rerun-if-env-changed=DENO_BUILD_PATH");
|
|
// TODO: this is obviously not appropriate here.
|
|
println!("cargo:rerun-if-env-changed=APPVEYOR_REPO_COMMIT");
|
|
|
|
// This helps Rust source files locate the snapshot, source map etc.
|
|
println!("cargo:rustc-env=GN_OUT_DIR={}", gn_out_dir);
|
|
|
|
// Detect if we're being invoked by the rust language server (RLS).
|
|
// Unfortunately we can't detect whether we're being run by `cargo check`.
|
|
let check_only = env::var_os("CARGO")
|
|
.map(PathBuf::from)
|
|
.as_ref()
|
|
.and_then(|p| p.file_stem())
|
|
.and_then(|f| f.to_str())
|
|
.map(|s| s.starts_with("rls"))
|
|
.unwrap_or(false);
|
|
|
|
if check_only {
|
|
// Enable the 'check_only' feature, which enables some workarounds in the
|
|
// rust source code to compile successfully without a bundle and snapshot
|
|
println!("cargo:rustc-cfg=feature=\"check-only\"");
|
|
}
|
|
|
|
Build {
|
|
gn_out_dir,
|
|
gn_out_path,
|
|
check_only,
|
|
gn_mode,
|
|
root,
|
|
}
|
|
}
|
|
|
|
pub fn run(&self, gn_target: &str) {
|
|
if !self.gn_out_path.join("build.ninja").exists() {
|
|
let status = Command::new("python")
|
|
.env("DENO_BUILD_PATH", &self.gn_out_dir)
|
|
.env("DENO_BUILD_MODE", &self.gn_mode)
|
|
.env("DEPOT_TOOLS_WIN_TOOLCHAIN", "0")
|
|
.arg("./tools/setup.py")
|
|
.status()
|
|
.expect("setup.py failed");
|
|
assert!(status.success());
|
|
}
|
|
|
|
let mut ninja = Command::new("third_party/depot_tools/ninja");
|
|
let ninja = if !cfg!(target_os = "windows") {
|
|
&mut ninja
|
|
} else {
|
|
// Windows needs special configuration. This is similar to the function of
|
|
// python_env() in //tools/util.py.
|
|
let python_path: Vec<String> = vec![
|
|
"third_party/python_packages",
|
|
"third_party/python_packages/win32",
|
|
"third_party/python_packages/win32/lib",
|
|
"third_party/python_packages/Pythonwin",
|
|
]
|
|
.into_iter()
|
|
.map(|p| self.root.join(p).into_os_string().into_string().unwrap())
|
|
.collect();
|
|
let orig_path = String::from(";")
|
|
+ &env::var_os("PATH").unwrap().into_string().unwrap();
|
|
let path = self
|
|
.root
|
|
.join("third_party/python_packages/pywin32_system32")
|
|
.into_os_string()
|
|
.into_string()
|
|
.unwrap();
|
|
ninja
|
|
.env("PYTHONPATH", python_path.join(";"))
|
|
.env("PATH", path + &orig_path)
|
|
.env("DEPOT_TOOLS_WIN_TOOLCHAIN", "0")
|
|
};
|
|
|
|
let status = ninja
|
|
.arg(gn_target)
|
|
.arg("-C")
|
|
.arg(&self.gn_out_dir)
|
|
.status()
|
|
.expect("ninja failed");
|
|
assert!(status.success());
|
|
}
|
|
}
|
|
|
|
// Utility function to make a path absolute, normalizing it to use forward
|
|
// slashes only. The returned value is an owned String, otherwise panics.
|
|
fn normalize_path<T: AsRef<Path>>(path: T) -> String {
|
|
path
|
|
.as_ref()
|
|
.to_str()
|
|
.unwrap()
|
|
.to_owned()
|
|
.chars()
|
|
.map(|c| if path::is_separator(c) { '/' } else { c })
|
|
.collect()
|
|
}
|