use std::path::{Component, Path, PathBuf};
use std::process::Command;
-use build_helper::t;
+use crate::util::t;
-use crate::dist::{self, pkgname, sanitize_sh, tmpdir};
+use crate::dist;
+use crate::tarball::GeneratedTarball;
use crate::Compiler;
use crate::builder::{Builder, RunConfig, ShouldRun, Step};
-use crate::cache::Interned;
-use crate::config::Config;
+use crate::config::{Config, TargetSelection};
-pub fn install_docs(builder: &Builder<'_>, stage: u32, host: Interned<String>) {
- install_sh(builder, "docs", "rust-docs", stage, Some(host));
-}
-
-pub fn install_std(builder: &Builder<'_>, stage: u32, target: Interned<String>) {
- install_sh(builder, "std", "rust-std", stage, Some(target));
-}
-
-pub fn install_cargo(builder: &Builder<'_>, stage: u32, host: Interned<String>) {
- install_sh(builder, "cargo", "cargo", stage, Some(host));
-}
+#[cfg(target_os = "illumos")]
+const SHELL: &str = "bash";
+#[cfg(not(target_os = "illumos"))]
+const SHELL: &str = "sh";
-pub fn install_rls(builder: &Builder<'_>, stage: u32, host: Interned<String>) {
- install_sh(builder, "rls", "rls", stage, Some(host));
-}
-pub fn install_clippy(builder: &Builder<'_>, stage: u32, host: Interned<String>) {
- install_sh(builder, "clippy", "clippy", stage, Some(host));
-}
-pub fn install_miri(builder: &Builder<'_>, stage: u32, host: Interned<String>) {
- install_sh(builder, "miri", "miri", stage, Some(host));
-}
-
-pub fn install_rustfmt(builder: &Builder<'_>, stage: u32, host: Interned<String>) {
- install_sh(builder, "rustfmt", "rustfmt", stage, Some(host));
-}
+// We have to run a few shell scripts, which choke quite a bit on both `\`
+// characters and on `C:\` paths, so normalize both of them away.
+fn sanitize_sh(path: &Path) -> String {
+ let path = path.to_str().unwrap().replace("\\", "/");
+ return change_drive(unc_to_lfs(&path)).unwrap_or(path);
-pub fn install_analysis(builder: &Builder<'_>, stage: u32, host: Interned<String>) {
- install_sh(builder, "analysis", "rust-analysis", stage, Some(host));
-}
+ fn unc_to_lfs(s: &str) -> &str {
+ s.strip_prefix("//?/").unwrap_or(s)
+ }
-pub fn install_src(builder: &Builder<'_>, stage: u32) {
- install_sh(builder, "src", "rust-src", stage, None);
-}
-pub fn install_rustc(builder: &Builder<'_>, stage: u32, host: Interned<String>) {
- install_sh(builder, "rustc", "rustc", stage, Some(host));
+ fn change_drive(s: &str) -> Option<String> {
+ let mut ch = s.chars();
+ let drive = ch.next().unwrap_or('C');
+ if ch.next() != Some(':') {
+ return None;
+ }
+ if ch.next() != Some('/') {
+ return None;
+ }
+ Some(format!("/{}/{}", drive, &s[drive.len_utf8() + 2..]))
+ }
}
fn install_sh(
builder: &Builder<'_>,
package: &str,
- name: &str,
stage: u32,
- host: Option<Interned<String>>,
+ host: Option<TargetSelection>,
+ tarball: &GeneratedTarball,
) {
builder.info(&format!("Install {} stage{} ({:?})", package, stage, host));
- let prefix_default = PathBuf::from("/usr/local");
- let sysconfdir_default = PathBuf::from("/etc");
- let datadir_default = PathBuf::from("share");
- let docdir_default = datadir_default.join("doc/rust");
- let libdir_default = PathBuf::from("lib");
- let mandir_default = datadir_default.join("man");
- let prefix = builder.config.prefix.as_ref().map_or(prefix_default, |p| {
- fs::canonicalize(p).unwrap_or_else(|_| panic!("could not canonicalize {}", p.display()))
- });
- let sysconfdir = builder.config.sysconfdir.as_ref().unwrap_or(&sysconfdir_default);
- let datadir = builder.config.datadir.as_ref().unwrap_or(&datadir_default);
- let docdir = builder.config.docdir.as_ref().unwrap_or(&docdir_default);
- let bindir = &builder.config.bindir;
- let libdir = builder.config.libdir.as_ref().unwrap_or(&libdir_default);
- let mandir = builder.config.mandir.as_ref().unwrap_or(&mandir_default);
-
- let sysconfdir = prefix.join(sysconfdir);
- let datadir = prefix.join(datadir);
- let docdir = prefix.join(docdir);
- let bindir = prefix.join(bindir);
- let libdir = prefix.join(libdir);
- let mandir = prefix.join(mandir);
-
- let destdir = env::var_os("DESTDIR").map(PathBuf::from);
-
- let prefix = add_destdir(&prefix, &destdir);
- let sysconfdir = add_destdir(&sysconfdir, &destdir);
- let datadir = add_destdir(&datadir, &destdir);
- let docdir = add_destdir(&docdir, &destdir);
- let bindir = add_destdir(&bindir, &destdir);
- let libdir = add_destdir(&libdir, &destdir);
- let mandir = add_destdir(&mandir, &destdir);
+ let prefix = default_path(&builder.config.prefix, "/usr/local");
+ let sysconfdir = prefix.join(default_path(&builder.config.sysconfdir, "/etc"));
+ let datadir = prefix.join(default_path(&builder.config.datadir, "share"));
+ let docdir = prefix.join(default_path(&builder.config.docdir, "share/doc/rust"));
+ let mandir = prefix.join(default_path(&builder.config.mandir, "share/man"));
+ let libdir = prefix.join(default_path(&builder.config.libdir, "lib"));
+ let bindir = prefix.join(&builder.config.bindir); // Default in config.rs
let empty_dir = builder.out.join("tmp/empty_dir");
-
t!(fs::create_dir_all(&empty_dir));
- let package_name = if let Some(host) = host {
- format!("{}-{}", pkgname(builder, name), host)
- } else {
- pkgname(builder, name)
- };
- let mut cmd = Command::new("sh");
+ let mut cmd = Command::new(SHELL);
cmd.current_dir(&empty_dir)
- .arg(sanitize_sh(&tmpdir(builder).join(&package_name).join("install.sh")))
- .arg(format!("--prefix={}", sanitize_sh(&prefix)))
- .arg(format!("--sysconfdir={}", sanitize_sh(&sysconfdir)))
- .arg(format!("--datadir={}", sanitize_sh(&datadir)))
- .arg(format!("--docdir={}", sanitize_sh(&docdir)))
- .arg(format!("--bindir={}", sanitize_sh(&bindir)))
- .arg(format!("--libdir={}", sanitize_sh(&libdir)))
- .arg(format!("--mandir={}", sanitize_sh(&mandir)))
+ .arg(sanitize_sh(&tarball.decompressed_output().join("install.sh")))
+ .arg(format!("--prefix={}", prepare_dir(prefix)))
+ .arg(format!("--sysconfdir={}", prepare_dir(sysconfdir)))
+ .arg(format!("--datadir={}", prepare_dir(datadir)))
+ .arg(format!("--docdir={}", prepare_dir(docdir)))
+ .arg(format!("--bindir={}", prepare_dir(bindir)))
+ .arg(format!("--libdir={}", prepare_dir(libdir)))
+ .arg(format!("--mandir={}", prepare_dir(mandir)))
.arg("--disable-ldconfig");
builder.run(&mut cmd);
t!(fs::remove_dir_all(&empty_dir));
}
-fn add_destdir(path: &Path, destdir: &Option<PathBuf>) -> PathBuf {
- let mut ret = match *destdir {
- Some(ref dest) => dest.clone(),
- None => return path.to_path_buf(),
- };
- for part in path.components() {
- match part {
- Component::Normal(s) => ret.push(s),
- _ => {}
+fn default_path(config: &Option<PathBuf>, default: &str) -> PathBuf {
+ config.as_ref().cloned().unwrap_or_else(|| PathBuf::from(default))
+}
+
+fn prepare_dir(mut path: PathBuf) -> String {
+ // The DESTDIR environment variable is a standard way to install software in a subdirectory
+ // while keeping the original directory structure, even if the prefix or other directories
+ // contain absolute paths.
+ //
+ // More information on the environment variable is available here:
+ // https://www.gnu.org/prep/standards/html_node/DESTDIR.html
+ if let Some(destdir) = env::var_os("DESTDIR").map(PathBuf::from) {
+ let without_destdir = path.clone();
+ path = destdir;
+ // Custom .join() which ignores disk roots.
+ for part in without_destdir.components() {
+ if let Component::Normal(s) = part {
+ path.push(s)
+ }
}
}
- ret
+
+ // The installation command is not executed from the current directory, but from a temporary
+ // directory. To prevent relative paths from breaking this converts relative paths to absolute
+ // paths. std::fs::canonicalize is not used as that requires the path to actually be present.
+ if path.is_relative() {
+ path = std::env::current_dir().expect("failed to get the current directory").join(path);
+ assert!(path.is_absolute(), "could not make the path relative");
+ }
+
+ sanitize_sh(&path)
}
macro_rules! install {
(($sel:ident, $builder:ident, $_config:ident),
$($name:ident,
- $path:expr,
+ $condition_name: ident = $path_or_alias: literal,
$default_cond:expr,
only_hosts: $only_hosts:expr,
$run_item:block $(, $c:ident)*;)+) => {
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct $name {
pub compiler: Compiler,
- pub target: Interned<String>,
+ pub target: TargetSelection,
}
impl $name {
#[allow(dead_code)]
fn should_build(config: &Config) -> bool {
config.extended && config.tools.as_ref()
- .map_or(true, |t| t.contains($path))
- }
-
- #[allow(dead_code)]
- fn should_install(builder: &Builder<'_>) -> bool {
- builder.config.tools.as_ref().map_or(false, |t| t.contains($path))
+ .map_or(true, |t| t.contains($path_or_alias))
}
}
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
let $_config = &run.builder.config;
- run.path($path).default_condition($default_cond)
+ run.$condition_name($path_or_alias).default_condition($default_cond)
}
fn make_run(run: RunConfig<'_>) {
}
install!((self, builder, _config),
- Docs, "src/doc", _config.docs, only_hosts: false, {
- builder.ensure(dist::Docs { host: self.target });
- install_docs(builder, self.compiler.stage, self.target);
+ Docs, path = "src/doc", _config.docs, only_hosts: false, {
+ let tarball = builder.ensure(dist::Docs { host: self.target }).expect("missing docs");
+ install_sh(builder, "docs", self.compiler.stage, Some(self.target), &tarball);
};
- Std, "src/libstd", true, only_hosts: true, {
+ Std, path = "library/std", true, only_hosts: false, {
for target in &builder.targets {
- builder.ensure(dist::Std {
+ // `expect` should be safe, only None when host != build, but this
+ // only runs when host == build
+ let tarball = builder.ensure(dist::Std {
compiler: self.compiler,
target: *target
- });
- install_std(builder, self.compiler.stage, *target);
+ }).expect("missing std");
+ install_sh(builder, "std", self.compiler.stage, Some(*target), &tarball);
}
};
- Cargo, "cargo", Self::should_build(_config), only_hosts: true, {
- builder.ensure(dist::Cargo { compiler: self.compiler, target: self.target });
- install_cargo(builder, self.compiler.stage, self.target);
+ Cargo, alias = "cargo", Self::should_build(_config), only_hosts: true, {
+ let tarball = builder
+ .ensure(dist::Cargo { compiler: self.compiler, target: self.target })
+ .expect("missing cargo");
+ install_sh(builder, "cargo", self.compiler.stage, Some(self.target), &tarball);
};
- Rls, "rls", Self::should_build(_config), only_hosts: true, {
- if builder.ensure(dist::Rls { compiler: self.compiler, target: self.target }).is_some() ||
- Self::should_install(builder) {
- install_rls(builder, self.compiler.stage, self.target);
+ RustAnalyzer, alias = "rust-analyzer", Self::should_build(_config), only_hosts: true, {
+ if let Some(tarball) =
+ builder.ensure(dist::RustAnalyzer { compiler: self.compiler, target: self.target })
+ {
+ install_sh(builder, "rust-analyzer", self.compiler.stage, Some(self.target), &tarball);
} else {
builder.info(
- &format!("skipping Install RLS stage{} ({})", self.compiler.stage, self.target),
+ &format!("skipping Install rust-analyzer stage{} ({})", self.compiler.stage, self.target),
);
}
};
- Clippy, "clippy", Self::should_build(_config), only_hosts: true, {
- if builder.ensure(dist::Clippy {
- compiler: self.compiler,
- target: self.target,
- }).is_some() || Self::should_install(builder) {
- install_clippy(builder, self.compiler.stage, self.target);
+ Clippy, alias = "clippy", Self::should_build(_config), only_hosts: true, {
+ let tarball = builder
+ .ensure(dist::Clippy { compiler: self.compiler, target: self.target })
+ .expect("missing clippy");
+ install_sh(builder, "clippy", self.compiler.stage, Some(self.target), &tarball);
+ };
+ Miri, alias = "miri", Self::should_build(_config), only_hosts: true, {
+ if let Some(tarball) = builder.ensure(dist::Miri { compiler: self.compiler, target: self.target }) {
+ install_sh(builder, "miri", self.compiler.stage, Some(self.target), &tarball);
} else {
+ // Miri is only available on nightly
builder.info(
- &format!("skipping Install clippy stage{} ({})", self.compiler.stage, self.target),
+ &format!("skipping Install miri stage{} ({})", self.compiler.stage, self.target),
);
}
};
- Miri, "miri", Self::should_build(_config), only_hosts: true, {
- if builder.ensure(dist::Miri { compiler: self.compiler, target: self.target }).is_some() ||
- Self::should_install(builder) {
- install_miri(builder, self.compiler.stage, self.target);
+ Rustfmt, alias = "rustfmt", Self::should_build(_config), only_hosts: true, {
+ if let Some(tarball) = builder.ensure(dist::Rustfmt {
+ compiler: self.compiler,
+ target: self.target
+ }) {
+ install_sh(builder, "rustfmt", self.compiler.stage, Some(self.target), &tarball);
} else {
builder.info(
- &format!("skipping Install miri stage{} ({})", self.compiler.stage, self.target),
+ &format!("skipping Install Rustfmt stage{} ({})", self.compiler.stage, self.target),
);
}
};
- Rustfmt, "rustfmt", Self::should_build(_config), only_hosts: true, {
- if builder.ensure(dist::Rustfmt {
+ RustDemangler, alias = "rust-demangler", Self::should_build(_config), only_hosts: true, {
+ // Note: Even though `should_build` may return true for `extended` default tools,
+ // dist::RustDemangler may still return None, unless the target-dependent `profiler` config
+ // is also true, or the `tools` array explicitly includes "rust-demangler".
+ if let Some(tarball) = builder.ensure(dist::RustDemangler {
compiler: self.compiler,
target: self.target
- }).is_some() || Self::should_install(builder) {
- install_rustfmt(builder, self.compiler.stage, self.target);
+ }) {
+ install_sh(builder, "rust-demangler", self.compiler.stage, Some(self.target), &tarball);
} else {
builder.info(
- &format!("skipping Install Rustfmt stage{} ({})", self.compiler.stage, self.target),
+ &format!("skipping Install RustDemangler stage{} ({})",
+ self.compiler.stage, self.target),
);
}
};
- Analysis, "analysis", Self::should_build(_config), only_hosts: false, {
- builder.ensure(dist::Analysis {
+ Analysis, alias = "analysis", Self::should_build(_config), only_hosts: false, {
+ // `expect` should be safe, only None with host != build, but this
+ // only uses the `build` compiler
+ let tarball = builder.ensure(dist::Analysis {
// Find the actual compiler (handling the full bootstrap option) which
// produced the save-analysis data because that data isn't copied
// through the sysroot uplifting.
compiler: builder.compiler_for(builder.top_stage, builder.config.build, self.target),
target: self.target
- });
- install_analysis(builder, self.compiler.stage, self.target);
+ }).expect("missing analysis");
+ install_sh(builder, "analysis", self.compiler.stage, Some(self.target), &tarball);
};
- Rustc, "src/librustc", true, only_hosts: true, {
- builder.ensure(dist::Rustc {
+ Rustc, path = "compiler/rustc", true, only_hosts: true, {
+ let tarball = builder.ensure(dist::Rustc {
compiler: builder.compiler(builder.top_stage, self.target),
});
- install_rustc(builder, self.compiler.stage, self.target);
+ install_sh(builder, "rustc", self.compiler.stage, Some(self.target), &tarball);
};
);
}
fn run(self, builder: &Builder<'_>) {
- builder.ensure(dist::Src);
- install_src(builder, self.stage);
+ let tarball = builder.ensure(dist::Src);
+ install_sh(builder, "src", self.stage, None, &tarball);
}
}
projects / rustc.git / blobdiff