self.build_dir = os.path.join(os.getcwd(), "build")
self.clean = False
self.config_toml = ''
- self.rust_root = os.path.abspath(os.path.join(__file__, '../../..'))
+ self.rust_root = ''
self.use_locked_deps = ''
self.use_vendored_sources = ''
self.verbose = False
parser = argparse.ArgumentParser(description='Build rust')
parser.add_argument('--config')
parser.add_argument('--build')
+ parser.add_argument('--src')
parser.add_argument('--clean', action='store_true')
parser.add_argument('-v', '--verbose', action='count', default=0)
# Configure initial bootstrap
build = RustBuild()
+ build.rust_root = args.src or os.path.abspath(os.path.join(__file__, '../../..'))
build.verbose = args.verbose
build.clean = args.clean
env["SRC"] = build.rust_root
env["BOOTSTRAP_PARENT_ID"] = str(os.getpid())
env["BOOTSTRAP_PYTHON"] = sys.executable
+ env["BUILD_DIR"] = build.build_dir
run(args, env=env, verbose=build.verbose)
// These are either the stage0 downloaded binaries or the locally installed ones.
pub initial_cargo: PathBuf,
pub initial_rustc: PathBuf,
+ pub out: PathBuf,
}
/// Per-target configuration stored in the global configuration structure.
config.rustc_error_format = flags.rustc_error_format;
config.on_fail = flags.on_fail;
config.stage = flags.stage;
- config.src = flags.src;
+ // set by bootstrap.py
+ config.src = env::var_os("SRC").map(PathBuf::from).expect("'SRC' to be set");
config.jobs = flags.jobs;
config.cmd = flags.cmd;
config.incremental = flags.incremental;
}).unwrap_or_else(|| TomlConfig::default());
let build = toml.build.clone().unwrap_or(Build::default());
- set(&mut config.build, build.build.clone().map(|x| INTERNER.intern_string(x)));
- set(&mut config.build, flags.build);
- if config.build.is_empty() {
- // set by bootstrap.py
- config.build = INTERNER.intern_str(&env::var("BUILD").unwrap());
- }
+ // set by bootstrap.py
+ config.build = INTERNER.intern_str(&env::var("BUILD").unwrap());
config.hosts.push(config.build.clone());
for host in build.host.iter() {
let host = INTERNER.intern_str(host);
let mut target = Target::default();
if let Some(ref s) = cfg.llvm_config {
- target.llvm_config = Some(env::current_dir().unwrap().join(s));
+ target.llvm_config = Some(config.src.join(s));
}
if let Some(ref s) = cfg.jemalloc {
- target.jemalloc = Some(env::current_dir().unwrap().join(s));
+ target.jemalloc = Some(config.src.join(s));
}
if let Some(ref s) = cfg.android_ndk {
- target.ndk = Some(env::current_dir().unwrap().join(s));
+ target.ndk = Some(config.src.join(s));
}
target.cc = cfg.cc.clone().map(PathBuf::from);
target.cxx = cfg.cxx.clone().map(PathBuf::from);
set(&mut config.rust_dist_src, t.src_tarball);
}
- let cwd = t!(env::current_dir());
- let out = cwd.join("build");
+ let out = env::var_os("BUILD_DIR").map(PathBuf::from).expect("'BUILD_DIR' set");
+ config.out = out.clone();
let stage0_root = out.join(&config.build).join("stage0/bin");
config.initial_rustc = match build.rustc {
pub on_fail: Option<String>,
pub stage: Option<u32>,
pub keep_stage: Option<u32>,
- pub build: Option<Interned<String>>,
pub host: Vec<Interned<String>>,
pub target: Vec<Interned<String>>,
pub config: Option<PathBuf>,
- pub src: PathBuf,
pub jobs: Option<u32>,
pub cmd: Subcommand,
pub incremental: bool,
_ => { }
};
// Get any optional paths which occur after the subcommand
- let cwd = t!(env::current_dir());
- let src = matches.opt_str("src").map(PathBuf::from)
- .or_else(|| env::var_os("SRC").map(PathBuf::from))
- .unwrap_or(cwd.clone());
let paths = matches.free[1..].iter().map(|p| p.into()).collect::<Vec<PathBuf>>();
let cfg_file = matches.opt_str("config").map(PathBuf::from).or_else(|| {
on_fail: matches.opt_str("on-fail"),
rustc_error_format: matches.opt_str("error-format"),
keep_stage: matches.opt_str("keep-stage").map(|j| j.parse().unwrap()),
- build: matches.opt_str("build").map(|s| INTERNER.intern_string(s)),
host: split(matches.opt_strs("host"))
.into_iter().map(|x| INTERNER.intern_string(x)).collect::<Vec<_>>(),
target: split(matches.opt_strs("target"))
incremental: matches.opt_present("incremental"),
exclude: split(matches.opt_strs("exclude"))
.into_iter().map(|p| p.into()).collect::<Vec<_>>(),
- src,
}
}
}
///
/// By default all build output will be placed in the current directory.
pub fn new(config: Config) -> Build {
- let cwd = t!(env::current_dir());
let src = config.src.clone();
- let out = cwd.join("build");
+ let out = config.out.clone();
let is_sudo = match env::var_os("SUDO_USER") {
Some(sudo_user) => {