From ab3c2a935b1ba655de2f3fec35da2c14b69966dc Mon Sep 17 00:00:00 2001 From: Daniel Mueller Date: Sat, 16 Sep 2017 08:37:31 -0700 Subject: Update gcc crate to 0.3.54 Import subrepo gcc/:gcc at dc329205d54b53a45ab66368aed265b68fe7f261 --- gcc/.travis.yml | 2 +- gcc/Cargo.toml | 6 +- gcc/README.md | 14 +- gcc/appveyor.yml | 20 + gcc/gcc-test/build.rs | 32 +- gcc/src/lib.rs | 891 +++++++++++++++++++++++++++++++++----------- gcc/src/winapi.rs | 4 +- gcc/src/windows_registry.rs | 21 +- gcc/tests/support/mod.rs | 6 +- gcc/tests/test.rs | 128 +++++-- 10 files changed, 863 insertions(+), 261 deletions(-) (limited to 'gcc') diff --git a/gcc/.travis.yml b/gcc/.travis.yml index ff57da5..0f0a094 100644 --- a/gcc/.travis.yml +++ b/gcc/.travis.yml @@ -6,7 +6,7 @@ rust: matrix: include: # Minimum version supported - - rust: 1.6.0 + - rust: 1.13.0 install: script: cargo build diff --git a/gcc/Cargo.toml b/gcc/Cargo.toml index 45acf07..81b8007 100644 --- a/gcc/Cargo.toml +++ b/gcc/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "gcc" -version = "0.3.48" +version = "0.3.54" authors = ["Alex Crichton "] license = "MIT/Apache-2.0" repository = "https://github.com/alexcrichton/gcc-rs" @@ -12,13 +12,15 @@ C compiler to compile native C code into a static archive to be linked into Rust code. """ keywords = ["build-dependencies"] +readme = "README.md" +categories = ["development-tools"] [badges] travis-ci = { repository = "alexcrichton/gcc-rs" } appveyor = { repository = "alexcrichton/gcc-rs" } [dependencies] -rayon = { version = "0.7", optional = true } +rayon = { version = "0.8", optional = true } [features] parallel = ["rayon"] diff --git a/gcc/README.md b/gcc/README.md index 2d3e5ed..06bfa27 100644 --- a/gcc/README.md +++ b/gcc/README.md @@ -35,13 +35,17 @@ Next up, you'll want to write a build script like so: extern crate gcc; fn main() { - gcc::compile_library("libfoo.a", &["foo.c", "bar.c"]); + gcc::Build::new() + .file("foo.c") + .file("bar.c") + .compile("foo"); } ``` And that's it! Running `cargo build` should take care of the rest and your Rust -application will now have the C files `foo.c` and `bar.c` compiled into it. You -can call the functions in Rust by declaring functions in your Rust code like so: +application will now have the C files `foo.c` and `bar.c` compiled into a file +named libfoo.a. You can call the functions in Rust by declaring functions in +your Rust code like so: ``` extern { @@ -137,13 +141,13 @@ required varies per platform, but there are three broad categories: ## C++ support `gcc-rs` supports C++ libraries compilation by using the `cpp` method on -`Config`: +`Build`: ```rust,no_run extern crate gcc; fn main() { - gcc::Config::new() + gcc::Build::new() .cpp(true) // Switch to C++ library compilation. .file("foo.cpp") .compile("libfoo.a"); diff --git a/gcc/appveyor.yml b/gcc/appveyor.yml index f6108c6..aa1edb5 100644 --- a/gcc/appveyor.yml +++ b/gcc/appveyor.yml @@ -1,4 +1,24 @@ environment: + + # At the time this was added AppVeyor was having troubles with checking + # revocation of SSL certificates of sites like static.rust-lang.org and what + # we think is crates.io. The libcurl HTTP client by default checks for + # revocation on Windows and according to a mailing list [1] this can be + # disabled. + # + # The `CARGO_HTTP_CHECK_REVOKE` env var here tells cargo to disable SSL + # revocation checking on Windows in libcurl. Note, though, that rustup, which + # we're using to download Rust here, also uses libcurl as the default backend. + # Unlike Cargo, however, rustup doesn't have a mechanism to disable revocation + # checking. To get rustup working we set `RUSTUP_USE_HYPER` which forces it to + # use the Hyper instead of libcurl backend. Both Hyper and libcurl use + # schannel on Windows but it appears that Hyper configures it slightly + # differently such that revocation checking isn't turned on by default. + # + # [1]: https://curl.haxx.se/mail/lib-2016-03/0202.html + RUSTUP_USE_HYPER: 1 + CARGO_HTTP_CHECK_REVOKE: false + matrix: - TARGET: x86_64-pc-windows-msvc ARCH: amd64 diff --git a/gcc/gcc-test/build.rs b/gcc/gcc-test/build.rs index f81833b..e6308ed 100644 --- a/gcc/gcc-test/build.rs +++ b/gcc/gcc-test/build.rs @@ -9,36 +9,38 @@ fn main() { fs::remove_dir_all(&out).unwrap(); fs::create_dir(&out).unwrap(); - gcc::Config::new() + gcc::Build::new() .file("src/foo.c") + .flag_if_supported("-Wall") + .flag_if_supported("-Wfoo-bar-this-flag-does-not-exist") .define("FOO", None) - .define("BAR", Some("1")) - .compile("libfoo.a"); + .define("BAR", "1") + .compile("foo"); - gcc::Config::new() + gcc::Build::new() .file("src/bar1.c") .file("src/bar2.c") .include("src/include") - .compile("libbar.a"); + .compile("bar"); let target = std::env::var("TARGET").unwrap(); let file = target.split("-").next().unwrap(); let file = format!("src/{}.{}", file, if target.contains("msvc") { "asm" } else { "S" }); - gcc::Config::new() + gcc::Build::new() .file(file) - .compile("libasm.a"); + .compile("asm"); - gcc::Config::new() + gcc::Build::new() .file("src/baz.cpp") .cpp(true) - .compile("libbaz.a"); + .compile("baz"); if target.contains("windows") { - gcc::Config::new() + gcc::Build::new() .file("src/windows.c") - .compile("libwindows.a"); + .compile("windows"); } // Test that the `windows_registry` module will set PATH by looking for @@ -50,6 +52,7 @@ fn main() { println!("nmake 1"); let status = gcc::windows_registry::find(&target, "nmake.exe") .unwrap() + .env_remove("MAKEFLAGS") .arg("/fsrc/NMakefile") .env("OUT_DIR", &out) .status() @@ -66,6 +69,7 @@ fn main() { println!("nmake 2"); let status = gcc::windows_registry::find(&target, "nmake.exe") .unwrap() + .env_remove("MAKEFLAGS") .arg("/fsrc/NMakefile") .env("OUT_DIR", &out) .status() @@ -77,12 +81,12 @@ fn main() { // This tests whether we can build a library but not link it to the main // crate. The test module will do its own linking. - gcc::Config::new() + gcc::Build::new() .cargo_metadata(false) .file("src/opt_linkage.c") - .compile("libOptLinkage.a"); + .compile("OptLinkage"); - let out = gcc::Config::new() + let out = gcc::Build::new() .file("src/expand.c") .expand(); let out = String::from_utf8(out).unwrap(); diff --git a/gcc/src/lib.rs b/gcc/src/lib.rs index 7d19e13..4c5e724 100644 --- a/gcc/src/lib.rs +++ b/gcc/src/lib.rs @@ -10,35 +10,30 @@ //! //! The purpose of this crate is to provide the utility functions necessary to //! compile C code into a static archive which is then linked into a Rust crate. -//! The top-level `compile_library` function serves as a convenience and more -//! advanced configuration is available through the `Config` builder. +//! Configuration is available through the `Build` struct. //! //! This crate will automatically detect situations such as cross compilation or //! other environment variables set by Cargo and will build code appropriately. //! -//! # Examples -//! -//! Use the default configuration: +//! The crate is not limited to C code, it can accept any source code that can +//! be passed to a C or C++ compiler. As such, assembly files with extensions +//! `.s` (gcc/clang) and `.asm` (MSVC) can also be compiled. //! -//! ```no_run -//! extern crate gcc; +//! [`Build`]: struct.Build.html //! -//! fn main() { -//! gcc::compile_library("libfoo.a", &["src/foo.c"]); -//! } -//! ``` +//! # Examples //! -//! Use more advanced configuration: +//! Use the `Build` struct to compile `src/foo.c`: //! //! ```no_run //! extern crate gcc; //! //! fn main() { -//! gcc::Config::new() -//! .file("src/foo.c") -//! .define("FOO", Some("bar")) -//! .include("src") -//! .compile("libfoo.a"); +//! gcc::Build::new() +//! .file("src/foo.c") +//! .define("FOO", Some("bar")) +//! .include("src") +//! .compile("foo"); //! } //! ``` @@ -57,6 +52,13 @@ use std::process::{Command, Stdio, Child}; use std::io::{self, BufReader, BufRead, Read, Write}; use std::thread::{self, JoinHandle}; +#[doc(hidden)] +#[deprecated(since="0.3.51", note="gcc::Config has been renamed to gcc::Build")] +pub type Config = Build; + +#[cfg(feature = "parallel")] +use std::sync::Mutex; + // These modules are all glue to support reading the MSVC version from // the registry and from COM interfaces #[cfg(windows)] @@ -72,11 +74,13 @@ mod setup_config; pub mod windows_registry; /// Extra configuration to pass to gcc. -pub struct Config { +#[derive(Clone, Debug)] +pub struct Build { include_directories: Vec, definitions: Vec<(String, Option)>, objects: Vec, flags: Vec, + flags_supported: Vec, files: Vec, cpp: bool, cpp_link_stdlib: Option>, @@ -92,6 +96,46 @@ pub struct Config { cargo_metadata: bool, pic: Option, static_crt: Option, + shared_flag: Option, + static_flag: Option, + warnings_into_errors: bool, + warnings: bool, +} + +/// Represents the types of errors that may occur while using gcc-rs. +#[derive(Clone, Debug)] +enum ErrorKind { + /// Error occurred while performing I/O. + IOError, + /// Invalid architecture supplied. + ArchitectureInvalid, + /// Environment variable not found, with the var in question as extra info. + EnvVarNotFound, + /// Error occurred while using external tools (ie: invocation of compiler). + ToolExecError, + /// Error occurred due to missing external tools. + ToolNotFound, +} + +/// Represents an internal error that occurred, with an explaination. +#[derive(Clone, Debug)] +pub struct Error { + /// Describes the kind of error that occurred. + kind: ErrorKind, + /// More explaination of error that occurred. + message: String, +} + +impl Error { + fn new(kind: ErrorKind, message: &str) -> Error { + Error { kind: kind, message: message.to_owned() } + } +} + +impl From for Error { + fn from(e: io::Error) -> Error { + Error::new(ErrorKind::IOError, &format!("{}", e)) + } } /// Configuration used to represent an invocation of a C compiler. @@ -101,6 +145,7 @@ pub struct Config { /// This can be used to further configure other build systems (e.g. forward /// along CC and/or CFLAGS) or the `to_command` method can be used to run the /// compiler itself. +#[derive(Clone, Debug)] pub struct Tool { path: PathBuf, args: Vec, @@ -113,7 +158,7 @@ pub struct Tool { /// Each family of tools differs in how and what arguments they accept. /// /// Detection of a family is done on best-effort basis and may not accurately reflect the tool. -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Debug, PartialEq)] enum ToolFamily { /// Tool is GNU Compiler Collection-like. Gnu, @@ -151,6 +196,27 @@ impl ToolFamily { ToolFamily::Clang => "-E", } } + + /// What the flags to enable all warnings + fn warnings_flags(&self) -> &'static [&'static str] { + static MSVC_FLAGS: &'static [&'static str] = &["/W4"]; + static GNU_CLANG_FLAGS: &'static [&'static str] = &["-Wall", "-Wextra"]; + + match *self { + ToolFamily::Msvc => &MSVC_FLAGS, + ToolFamily::Gnu | + ToolFamily::Clang => &GNU_CLANG_FLAGS, + } + } + + /// What the flag to turn warning into errors + fn warnings_to_errors_flag(&self) -> &'static str { + match *self { + ToolFamily::Msvc => "/WX", + ToolFamily::Gnu | + ToolFamily::Clang => "-Werror" + } + } } /// Compile a library from the given set of input C files. @@ -164,27 +230,34 @@ impl ToolFamily { /// # Example /// /// ```no_run -/// gcc::compile_library("libfoo.a", &["foo.c", "bar.c"]); +/// gcc::compile_library("foo", &["foo.c", "bar.c"]); /// ``` +#[deprecated] +#[doc(hidden)] pub fn compile_library(output: &str, files: &[&str]) { - let mut c = Config::new(); + let mut c = Build::new(); for f in files.iter() { c.file(*f); } c.compile(output); } -impl Config { +impl Build { /// Construct a new instance of a blank set of configuration. /// - /// This builder is finished with the `compile` function. - pub fn new() -> Config { - Config { + /// This builder is finished with the [`compile`] function. + /// + /// [`compile`]: struct.Build.html#method.compile + pub fn new() -> Build { + Build { include_directories: Vec::new(), definitions: Vec::new(), objects: Vec::new(), flags: Vec::new(), + flags_supported: Vec::new(), files: Vec::new(), + shared_flag: None, + static_flag: None, cpp: false, cpp_link_stdlib: None, cpp_set_stdlib: None, @@ -199,48 +272,229 @@ impl Config { cargo_metadata: true, pic: None, static_crt: None, + warnings: true, + warnings_into_errors: false, } } /// Add a directory to the `-I` or include path for headers - pub fn include>(&mut self, dir: P) -> &mut Config { + /// + /// # Example + /// + /// ```no_run + /// use std::path::Path; + /// + /// let library_path = Path::new("/path/to/library"); + /// + /// gcc::Build::new() + /// .file("src/foo.c") + /// .include(library_path) + /// .include("src") + /// .compile("foo"); + /// ``` + pub fn include>(&mut self, dir: P) -> &mut Build { self.include_directories.push(dir.as_ref().to_path_buf()); self } /// Specify a `-D` variable with an optional value. - pub fn define(&mut self, var: &str, val: Option<&str>) -> &mut Config { - self.definitions.push((var.to_string(), val.map(|s| s.to_string()))); + /// + /// # Example + /// + /// ```no_run + /// gcc::Build::new() + /// .file("src/foo.c") + /// .define("FOO", "BAR") + /// .define("BAZ", None) + /// .compile("foo"); + /// ``` + pub fn define<'a, V: Into>>(&mut self, var: &str, val: V) -> &mut Build { + self.definitions.push((var.to_string(), val.into().map(|s| s.to_string()))); self } /// Add an arbitrary object file to link in - pub fn object>(&mut self, obj: P) -> &mut Config { + pub fn object>(&mut self, obj: P) -> &mut Build { self.objects.push(obj.as_ref().to_path_buf()); self } /// Add an arbitrary flag to the invocation of the compiler - pub fn flag(&mut self, flag: &str) -> &mut Config { + /// + /// # Example + /// + /// ```no_run + /// gcc::Build::new() + /// .file("src/foo.c") + /// .flag("-ffunction-sections") + /// .compile("foo"); + /// ``` + pub fn flag(&mut self, flag: &str) -> &mut Build { self.flags.push(flag.to_string()); self } + fn ensure_check_file(&self) -> Result { + let out_dir = self.get_out_dir()?; + let src = if self.cpp { + out_dir.join("flag_check.cpp") + } else { + out_dir.join("flag_check.c") + }; + + if !src.exists() { + let mut f = fs::File::create(&src)?; + write!(f, "int main(void) {{ return 0; }}")?; + } + + Ok(src) + } + + fn is_flag_supported(&self, flag: &str) -> Result { + let out_dir = self.get_out_dir()?; + let src = self.ensure_check_file()?; + let obj = out_dir.join("flag_check"); + let target = self.get_target()?; + let mut cfg = Build::new(); + cfg.flag(flag) + .target(&target) + .opt_level(0) + .host(&target) + .debug(false) + .cpp(self.cpp); + let compiler = cfg.try_get_compiler()?; + let mut cmd = compiler.to_command(); + command_add_output_file(&mut cmd, &obj, target.contains("msvc"), false); + cmd.arg(&src); + + let output = cmd.output()?; + Ok(output.stderr.is_empty()) + } + + /// Add an arbitrary flag to the invocation of the compiler if it supports it + /// + /// # Example + /// + /// ```no_run + /// gcc::Build::new() + /// .file("src/foo.c") + /// .flag_if_supported("-Wlogical-op") // only supported by GCC + /// .flag_if_supported("-Wunreachable-code") // only supported by clang + /// .compile("foo"); + /// ``` + pub fn flag_if_supported(&mut self, flag: &str) -> &mut Build { + self.flags_supported.push(flag.to_string()); + self + } + + /// Set the `-shared` flag. + /// + /// When enabled, the compiler will produce a shared object which can + /// then be linked with other objects to form an executable. + /// + /// # Example + /// + /// ```no_run + /// gcc::Build::new() + /// .file("src/foo.c") + /// .shared_flag(true) + /// .compile("libfoo.so"); + /// ``` + + pub fn shared_flag(&mut self, shared_flag: bool) -> &mut Build { + self.shared_flag = Some(shared_flag); + self + } + + /// Set the `-static` flag. + /// + /// When enabled on systems that support dynamic linking, this prevents + /// linking with the shared libraries. + /// + /// # Example + /// + /// ```no_run + /// gcc::Build::new() + /// .file("src/foo.c") + /// .shared_flag(true) + /// .static_flag(true) + /// .compile("foo"); + /// ``` + pub fn static_flag(&mut self, static_flag: bool) -> &mut Build { + self.static_flag = Some(static_flag); + self + } + /// Add a file which will be compiled - pub fn file>(&mut self, p: P) -> &mut Config { + pub fn file>(&mut self, p: P) -> &mut Build { self.files.push(p.as_ref().to_path_buf()); self } + /// Add files which will be compiled + pub fn files

(&mut self, p: P) -> &mut Build + where P: IntoIterator, + P::Item: AsRef { + for file in p.into_iter() { + self.file(file); + } + self + } + /// Set C++ support. /// /// The other `cpp_*` options will only become active if this is set to /// `true`. - pub fn cpp(&mut self, cpp: bool) -> &mut Config { + pub fn cpp(&mut self, cpp: bool) -> &mut Build { self.cpp = cpp; self } + /// Set warnings into errors flag. + /// + /// Disabled by default. + /// + /// Warning: turning warnings into errors only make sense + /// if you are a developer of the crate using gcc-rs. + /// Some warnings only appear on some architecture or + /// specific version of the compiler. Any user of this crate, + /// or any other crate depending on it, could fail during + /// compile time. + /// + /// # Example + /// + /// ```no_run + /// gcc::Build::new() + /// .file("src/foo.c") + /// .warnings_into_errors(true) + /// .compile("libfoo.a"); + /// ``` + pub fn warnings_into_errors(&mut self, warnings_into_errors: bool) -> &mut Build { + self.warnings_into_errors = warnings_into_errors; + self + } + + /// Set warnings flags. + /// + /// Adds some flags: + /// - "/Wall" for MSVC. + /// - "-Wall", "-Wextra" for GNU and Clang. + /// + /// Enabled by default. + /// + /// # Example + /// + /// ```no_run + /// gcc::Build::new() + /// .file("src/foo.c") + /// .warnings(false) + /// .compile("libfoo.a"); + /// ``` + pub fn warnings(&mut self, warnings: bool) -> &mut Build { + self.warnings = warnings; + self + } + /// Set the standard library to link against when compiling with C++ /// support. /// @@ -252,8 +506,22 @@ impl Config { /// otherwise cargo will link against the specified library. /// /// The given library name must not contain the `lib` prefix. - pub fn cpp_link_stdlib(&mut self, cpp_link_stdlib: Option<&str>) -> &mut Config { - self.cpp_link_stdlib = Some(cpp_link_stdlib.map(|s| s.into())); + /// + /// Common values: + /// - `stdc++` for GNU + /// - `c++` for Clang + /// + /// # Example + /// + /// ```no_run + /// gcc::Build::new() + /// .file("src/foo.c") + /// .shared_flag(true) + /// .cpp_link_stdlib("stdc++") + /// .compile("libfoo.so"); + /// ``` + pub fn cpp_link_stdlib<'a, V: Into>>(&mut self, cpp_link_stdlib: V) -> &mut Build { + self.cpp_link_stdlib = Some(cpp_link_stdlib.into().map(|s| s.into())); self } @@ -277,7 +545,21 @@ impl Config { /// be used, otherwise `-stdlib` is added to the compile invocation. /// /// The given library name must not contain the `lib` prefix. - pub fn cpp_set_stdlib(&mut self, cpp_set_stdlib: Option<&str>) -> &mut Config { + /// + /// Common values: + /// - `stdc++` for GNU + /// - `c++` for Clang + /// + /// # Example + /// + /// ```no_run + /// gcc::Build::new() + /// .file("src/foo.c") + /// .cpp_set_stdlib("c++") + /// .compile("libfoo.a"); + /// ``` + pub fn cpp_set_stdlib<'a, V: Into>>(&mut self, cpp_set_stdlib: V) -> &mut Build { + let cpp_set_stdlib = cpp_set_stdlib.into(); self.cpp_set_stdlib = cpp_set_stdlib.map(|s| s.into()); self.cpp_link_stdlib(cpp_set_stdlib); self @@ -287,7 +569,16 @@ impl Config { /// /// This option is automatically scraped from the `TARGET` environment /// variable by build scripts, so it's not required to call this function. - pub fn target(&mut self, target: &str) -> &mut Config { + /// + /// # Example + /// + /// ```no_run + /// gcc::Build::new() + /// .file("src/foo.c") + /// .target("aarch64-linux-android") + /// .compile("foo"); + /// ``` + pub fn target(&mut self, target: &str) -> &mut Build { self.target = Some(target.to_string()); self } @@ -296,7 +587,16 @@ impl Config { /// /// This option is automatically scraped from the `HOST` environment /// variable by build scripts, so it's not required to call this function. - pub fn host(&mut self, host: &str) -> &mut Config { + /// + /// # Example + /// + /// ```no_run + /// gcc::Build::new() + /// .file("src/foo.c") + /// .host("arm-linux-gnueabihf") + /// .compile("foo"); + /// ``` + pub fn host(&mut self, host: &str) -> &mut Build { self.host = Some(host.to_string()); self } @@ -305,7 +605,7 @@ impl Config { /// /// This option is automatically scraped from the `OPT_LEVEL` environment /// variable by build scripts, so it's not required to call this function. - pub fn opt_level(&mut self, opt_level: u32) -> &mut Config { + pub fn opt_level(&mut self, opt_level: u32) -> &mut Build { self.opt_level = Some(opt_level.to_string()); self } @@ -314,7 +614,7 @@ impl Config { /// /// This option is automatically scraped from the `OPT_LEVEL` environment /// variable by build scripts, so it's not required to call this function. - pub fn opt_level_str(&mut self, opt_level: &str) -> &mut Config { + pub fn opt_level_str(&mut self, opt_level: &str) -> &mut Build { self.opt_level = Some(opt_level.to_string()); self } @@ -325,7 +625,7 @@ impl Config { /// This option is automatically scraped from the `PROFILE` environment /// variable by build scripts (only enabled when the profile is "debug"), so /// it's not required to call this function. - pub fn debug(&mut self, debug: bool) -> &mut Config { + pub fn debug(&mut self, debug: bool) -> &mut Build { self.debug = Some(debug); self } @@ -335,7 +635,7 @@ impl Config { /// /// This option is automatically scraped from the `OUT_DIR` environment /// variable by build scripts, so it's not required to call this function. - pub fn out_dir>(&mut self, out_dir: P) -> &mut Config { + pub fn out_dir>(&mut self, out_dir: P) -> &mut Build { self.out_dir = Some(out_dir.as_ref().to_owned()); self } @@ -345,7 +645,7 @@ impl Config { /// This option is automatically determined from the target platform or a /// number of environment variables, so it's not required to call this /// function. - pub fn compiler>(&mut self, compiler: P) -> &mut Config { + pub fn compiler>(&mut self, compiler: P) -> &mut Build { self.compiler = Some(compiler.as_ref().to_owned()); self } @@ -355,13 +655,21 @@ impl Config { /// This option is automatically determined from the target platform or a /// number of environment variables, so it's not required to call this /// function. - pub fn archiver>(&mut self, archiver: P) -> &mut Config { + pub fn archiver>(&mut self, archiver: P) -> &mut Build { self.archiver = Some(archiver.as_ref().to_owned()); self } /// Define whether metadata should be emitted for cargo allowing it to /// automatically link the binary. Defaults to `true`. - pub fn cargo_metadata(&mut self, cargo_metadata: bool) -> &mut Config { + /// + /// The emitted metadata is: + /// + /// - `rustc-link-lib=static=`*compiled lib* + /// - `rustc-link-search=native=`*target folder* + /// - When target is MSVC, the ATL-MFC libs are added via `rustc-link-search=native=` + /// - When C++ is enabled, the C++ stdlib is added via `rustc-link-lib` + /// + pub fn cargo_metadata(&mut self, cargo_metadata: bool) -> &mut Build { self.cargo_metadata = cargo_metadata; self } @@ -370,7 +678,7 @@ impl Config { /// /// This option defaults to `false` for `windows-gnu` targets and /// to `true` for all other targets. - pub fn pic(&mut self, pic: bool) -> &mut Config { + pub fn pic(&mut self, pic: bool) -> &mut Build { self.pic = Some(pic); self } @@ -378,14 +686,13 @@ impl Config { /// Configures whether the /MT flag or the /MD flag will be passed to msvc build tools. /// /// This option defaults to `false`, and affect only msvc targets. - pub fn static_crt(&mut self, static_crt: bool) -> &mut Config { + pub fn static_crt(&mut self, static_crt: bool) -> &mut Build { self.static_crt = Some(static_crt); self } - #[doc(hidden)] - pub fn __set_env(&mut self, a: A, b: B) -> &mut Config + pub fn __set_env(&mut self, a: A, b: B) -> &mut Build where A: AsRef, B: AsRef { @@ -395,31 +702,42 @@ impl Config { /// Run the compiler, generating the file `output` /// - /// The name `output` must begin with `lib` and end with `.a` - pub fn compile(&self, output: &str) { - assert!(output.starts_with("lib")); - assert!(output.ends_with(".a")); - let lib_name = &output[3..output.len() - 2]; - let dst = self.get_out_dir(); + /// This will return a result instead of panicing; see compile() for the complete description. + pub fn try_compile(&self, output: &str) -> Result<(), Error> { + let (lib_name, gnu_lib_name) = if output.starts_with("lib") && output.ends_with(".a") { + (&output[3..output.len() - 2], output.to_owned()) + } else { + let mut gnu = String::with_capacity(5 + output.len()); + gnu.push_str("lib"); + gnu.push_str(&output); + gnu.push_str(".a"); + (output, gnu) + }; + let dst = self.get_out_dir()?; let mut objects = Vec::new(); let mut src_dst = Vec::new(); for file in self.files.iter() { let obj = dst.join(file).with_extension("o"); let obj = if !obj.starts_with(&dst) { - dst.join(obj.file_name().unwrap()) + dst.join(obj.file_name().ok_or_else(|| Error::new(ErrorKind::IOError, "Getting object file details failed."))?) } else { obj }; - fs::create_dir_all(&obj.parent().unwrap()).unwrap(); + + match obj.parent() { + Some(s) => fs::create_dir_all(s)?, + None => return Err(Error::new(ErrorKind::IOError, "Getting object file details failed.")), + }; + src_dst.push((file.to_path_buf(), obj.clone())); objects.push(obj); } - self.compile_objects(&src_dst); - self.assemble(lib_name, &dst.join(output), &objects); + self.compile_objects(&src_dst)?; + self.assemble(lib_name, &dst.join(gnu_lib_name), &objects)?; - if self.get_target().contains("msvc") { - let compiler = self.get_base_compiler(); + if self.get_target()?.contains("msvc") { + let compiler = self.get_base_compiler()?; let atlmfc_lib = compiler.env() .iter() .find(|&&(ref var, _)| var.as_os_str() == OsStr::new("LIB")) @@ -435,20 +753,39 @@ impl Config { } } - self.print(&format!("cargo:rustc-link-lib=static={}", - &output[3..output.len() - 2])); + self.print(&format!("cargo:rustc-link-lib=static={}", lib_name)); self.print(&format!("cargo:rustc-link-search=native={}", dst.display())); // Add specific C++ libraries, if enabled. if self.cpp { - if let Some(stdlib) = self.get_cpp_link_stdlib() { + if let Some(stdlib) = self.get_cpp_link_stdlib()? { self.print(&format!("cargo:rustc-link-lib={}", stdlib)); } } + + Ok(()) + } + + /// Run the compiler, generating the file `output` + /// + /// The name `output` should be the name of the library. For backwards compatibility, + /// the `output` may start with `lib` and end with `.a`. The Rust compilier will create + /// the assembly with the lib prefix and .a extension. MSVC will create a file without prefix, + /// ending with `.lib`. + /// + /// # Panics + /// + /// Panics if `output` is not formatted correctly or if one of the underlying + /// compiler commands fails. It can also panic if it fails reading file names + /// or creating directories. + pub fn compile(&self, output: &str) { + if let Err(e) = self.try_compile(output) { + fail(&e.message); + } } #[cfg(feature = "parallel")] - fn compile_objects(&self, objs: &[(PathBuf, PathBuf)]) { + fn compile_objects(&self, objs: &[(PathBuf, PathBuf)]) -> Result<(), Error> { use self::rayon::prelude::*; let mut cfg = rayon::Configuration::new(); @@ -459,24 +796,36 @@ impl Config { } drop(rayon::initialize(cfg)); + let results: Mutex>> = Mutex::new(Vec::new()); + objs.par_iter().with_max_len(1) - .for_each(|&(ref src, ref dst)| self.compile_object(src, dst)); + .for_each(|&(ref src, ref dst)| results.lock().unwrap().push(self.compile_object(src, dst))); + + // Check for any errors and return the first one found. + for result in results.into_inner().unwrap().iter() { + if result.is_err() { + return result.clone(); + } + } + + Ok(()) } #[cfg(not(feature = "parallel"))] - fn compile_objects(&self, objs: &[(PathBuf, PathBuf)]) { + fn compile_objects(&self, objs: &[(PathBuf, PathBuf)]) -> Result<(), Error> { for &(ref src, ref dst) in objs { - self.compile_object(src, dst); + self.compile_object(src, dst)?; } + Ok(()) } - fn compile_object(&self, file: &Path, dst: &Path) { + fn compile_object(&self, file: &Path, dst: &Path) -> Result<(), Error> { let is_asm = file.extension().and_then(|s| s.to_str()) == Some("asm"); - let msvc = self.get_target().contains("msvc"); + let msvc = self.get_target()?.contains("msvc"); let (mut cmd, name) = if msvc && is_asm { - self.msvc_macro_assembler() + self.msvc_macro_assembler()? } else { - let compiler = self.get_compiler(); + let compiler = self.try_get_compiler()?; let mut cmd = compiler.to_command(); for &(ref a, ref b) in self.env.iter() { cmd.env(a, b); @@ -484,46 +833,62 @@ impl Config { (cmd, compiler.path .file_name() - .unwrap() + .ok_or_else(|| Error::new(ErrorKind::IOError, "Failed to get compiler path."))? .to_string_lossy() .into_owned()) }; - if msvc && is_asm { - cmd.arg("/Fo").arg(dst); - } else if msvc { - let mut s = OsString::from("/Fo"); - s.push(&dst); - cmd.arg(s); - } else { - cmd.arg("-o").arg(&dst); - } + command_add_output_file(&mut cmd, dst, msvc, is_asm); cmd.arg(if msvc { "/c" } else { "-c" }); cmd.arg(file); - run(&mut cmd, &name); + run(&mut cmd, &name)?; + Ok(()) } - /// Run the compiler, returning the macro-expanded version of the input files. - /// - /// This is only relevant for C and C++ files. - pub fn expand(&self) -> Vec { - let compiler = self.get_compiler(); + /// This will return a result instead of panicing; see expand() for the complete description. + pub fn try_expand(&self) -> Result, Error> { + let compiler = self.try_get_compiler()?; let mut cmd = compiler.to_command(); for &(ref a, ref b) in self.env.iter() { cmd.env(a, b); } cmd.arg(compiler.family.expand_flag()); + + assert!(self.files.len() <= 1, + "Expand may only be called for a single file"); + for file in self.files.iter() { cmd.arg(file); } let name = compiler.path .file_name() - .unwrap() + .ok_or_else(|| Error::new(ErrorKind::IOError, "Failed to get compiler path."))? .to_string_lossy() .into_owned(); - run_output(&mut cmd, &name) + Ok(run_output(&mut cmd, &name)?) + } + + /// Run the compiler, returning the macro-expanded version of the input files. + /// + /// This is only relevant for C and C++ files. + /// + /// # Panics + /// Panics if more than one file is present in the config, or if compiler + /// path has an invalid file name. + /// + /// # Example + /// ```no_run + /// let out = gcc::Build::new() + /// .file("src/foo.c") + /// .expand(); + /// ``` + pub fn expand(&self) -> Vec { + match self.try_expand() { + Err(e) => fail(&e.message), + Ok(v) => v, + } } /// Get the compiler that's in use for this configuration. @@ -540,11 +905,25 @@ impl Config { /// conventions for this path, e.g. looking at the explicitly set compiler, /// environment variables (a number of which are inspected here), and then /// falling back to the default configuration. + /// + /// # Panics + /// + /// Panics if an error occurred while determining the architecture. pub fn get_compiler(&self) -> Tool { - let opt_level = self.get_opt_level(); - let target = self.get_target(); + match self.try_get_compiler() { + Ok(tool) => tool, + Err(e) => fail(&e.message), + } + } - let mut cmd = self.get_base_compiler(); + /// Get the compiler that's in use for this configuration. + /// + /// This will return a result instead of panicing; see get_compiler() for the complete description. + pub fn try_get_compiler(&self) -> Result { + let opt_level = self.get_opt_level()?; + let target = self.get_target()?; + + let mut cmd = self.get_base_compiler()?; let nvcc = cmd.path.file_name() .and_then(|p| p.to_str()).map(|p| p.contains("nvcc")) .unwrap_or(false); @@ -580,7 +959,14 @@ impl Config { } ToolFamily::Gnu | ToolFamily::Clang => { - cmd.args.push(format!("-O{}", opt_level).into()); + // arm-linux-androideabi-gcc 4.8 shipped with Android NDK does + // not support '-Oz' + if opt_level == "z" && cmd.family != ToolFamily::Clang { + cmd.args.push("-Os".into()); + } else { + cmd.args.push(format!("-O{}", opt_level).into()); + } + if !nvcc { cmd.args.push("-ffunction-sections".into()); cmd.args.push("-fdata-sections".into()); @@ -618,7 +1004,7 @@ impl Config { cmd.args.push("-m64".into()); } - if target.contains("musl") { + if self.static_flag.is_none() && target.contains("musl") { cmd.args.push("-static".into()); } @@ -695,7 +1081,14 @@ impl Config { if target.contains("-ios") { // FIXME: potential bug. iOS is always compiled with Clang, but Gcc compiler may be // detected instead. - self.ios_flags(&mut cmd); + self.ios_flags(&mut cmd)?; + } + + if self.static_flag.unwrap_or(false) { + cmd.args.push("-static".into()); + } + if self.shared_flag.unwrap_or(false) { + cmd.args.push("-shared".into()); } if self.cpp { @@ -721,6 +1114,12 @@ impl Config { cmd.args.push(flag.into()); } + for flag in self.flags_supported.iter() { + if self.is_flag_supported(flag).unwrap_or(false) { + cmd.args.push(flag.into()); + } + } + for &(ref key, ref value) in self.definitions.iter() { let lead = if let ToolFamily::Msvc = cmd.family {"/"} else {"-"}; if let Some(ref value) = *value { @@ -729,11 +1128,22 @@ impl Config { cmd.args.push(format!("{}D{}", lead, key).into()); } } - cmd + + if self.warnings { + for flag in cmd.family.warnings_flags().iter() { + cmd.args.push(flag.into()); + } + } + + if self.warnings_into_errors { + cmd.args.push(cmd.family.warnings_to_errors_flag().into()); + } + + Ok(cmd) } - fn msvc_macro_assembler(&self) -> (Command, String) { - let target = self.get_target(); + fn msvc_macro_assembler(&self) -> Result<(Command, String), Error> { + let target = self.get_target()?; let tool = if target.contains("x86_64") { "ml64.exe" } else { @@ -758,15 +1168,15 @@ impl Config { cmd.arg(flag); } - (cmd, tool.to_string()) + Ok((cmd, tool.to_string())) } - fn assemble(&self, lib_name: &str, dst: &Path, objects: &[PathBuf]) { + fn assemble(&self, lib_name: &str, dst: &Path, objects: &[PathBuf]) -> Result<(), Error> { // Delete the destination if it exists as the `ar` tool at least on Unix // appends to it, which we don't want. let _ = fs::remove_file(&dst); - let target = self.get_target(); + let target = self.get_target()?; if target.contains("msvc") { let mut cmd = match self.archiver { Some(ref s) => self.cmd(s), @@ -778,46 +1188,52 @@ impl Config { .arg("/nologo") .args(objects) .args(&self.objects), - "lib.exe"); + "lib.exe")?; // The Rust compiler will look for libfoo.a and foo.lib, but the // MSVC linker will also be passed foo.lib, so be sure that both // exist for now. let lib_dst = dst.with_file_name(format!("{}.lib", lib_name)); let _ = fs::remove_file(&lib_dst); - fs::hard_link(&dst, &lib_dst) + match fs::hard_link(&dst, &lib_dst) .or_else(|_| { // if hard-link fails, just copy (ignoring the number of bytes written) fs::copy(&dst, &lib_dst).map(|_| ()) - }) - .expect("Copying from {:?} to {:?} failed.");; + }) { + Ok(_) => (), + Err(_) => return Err(Error::new(ErrorKind::IOError, "Could not copy or create a hard-link to the generated lib file.")), + }; } else { - let ar = self.get_ar(); - let cmd = ar.file_name().unwrap().to_string_lossy(); + let ar = self.get_ar()?; + let cmd = ar.file_name() + .ok_or_else(|| Error::new(ErrorKind::IOError, "Failed to get archiver (ar) path."))? + .to_string_lossy(); run(self.cmd(&ar) .arg("crs") .arg(dst) .args(objects) .args(&self.objects), - &cmd); + &cmd)?; } + + Ok(()) } - fn ios_flags(&self, cmd: &mut Tool) { + fn ios_flags(&self, cmd: &mut Tool) -> Result<(), Error> { enum ArchSpec { Device(&'static str), Simulator(&'static str), } - let target = self.get_target(); - let arch = target.split('-').nth(0).unwrap(); + let target = self.get_target()?; + let arch = target.split('-').nth(0).ok_or_else(|| Error::new(ErrorKind::ArchitectureInvalid, "Unknown architecture for iOS target."))?; let arch = match arch { "arm" | "armv7" | "thumbv7" => ArchSpec::Device("armv7"), "armv7s" | "thumbv7s" => ArchSpec::Device("armv7s"), "arm64" | "aarch64" => ArchSpec::Device("arm64"), "i386" | "i686" => ArchSpec::Simulator("-m32"), "x86_64" => ArchSpec::Simulator("-m64"), - _ => fail("Unknown arch for iOS target"), + _ => return Err(Error::new(ErrorKind::ArchitectureInvalid, "Unknown architecture for iOS target.")), }; let sdk = match arch { @@ -840,14 +1256,18 @@ impl Config { .arg("--sdk") .arg(sdk) .stderr(Stdio::inherit()) - .output() - .unwrap() + .output()? .stdout; - let sdk_path = String::from_utf8(sdk_path).unwrap(); + let sdk_path = match String::from_utf8(sdk_path) { + Ok(p) => p, + Err(_) => return Err(Error::new(ErrorKind::IOError, "Unable to determine iOS SDK path.")), + }; cmd.args.push("-isysroot".into()); cmd.args.push(sdk_path.trim().into()); + + Ok(()) } fn cmd>(&self, prog: P) -> Command { @@ -858,12 +1278,12 @@ impl Config { cmd } - fn get_base_compiler(&self) -> Tool { + fn get_base_compiler(&self) -> Result { if let Some(ref c) = self.compiler { - return Tool::new(c.clone()); + return Ok(Tool::new(c.clone())); } - let host = self.get_host(); - let target = self.get_target(); + let host = self.get_host()?; + let target = self.get_target()?; let (env, msvc, gnu) = if self.cpp { ("CXX", "cl.exe", "g++") } else { @@ -879,7 +1299,7 @@ impl Config { "cc" }; - self.env_tool(env) + let tool_opt: Option = self.env_tool(env) .map(|(tool, args)| { let mut t = Tool::new(PathBuf::from(tool)); for arg in args { @@ -889,28 +1309,29 @@ impl Config { }) .or_else(|| { if target.contains("emscripten") { - //Windows uses bat file so we have to be a bit more specific let tool = if self.cpp { - if cfg!(windows) { - "em++.bat" - } else { - "em++" - } + "em++" } else { - if cfg!(windows) { - "emcc.bat" - } else { - "emcc" - } + "emcc" }; - - Some(Tool::new(PathBuf::from(tool))) + // Windows uses bat file so we have to be a bit more specific + if cfg!(windows) { + let mut t = Tool::new(PathBuf::from("cmd")); + t.args.push("/c".into()); + t.args.push(format!("{}.bat", tool).into()); + Some(t) + } else { + Some(Tool::new(PathBuf::from(tool))) + } } else { None } }) - .or_else(|| windows_registry::find_tool(&target, "cl.exe")) - .unwrap_or_else(|| { + .or_else(|| windows_registry::find_tool(&target, "cl.exe")); + + let tool = match tool_opt { + Some(t) => t, + None => { let compiler = if host.contains("windows") && target.contains("windows") { if target.contains("msvc") { msvc.to_string() @@ -919,7 +1340,7 @@ impl Config { } } else if target.contains("android") { format!("{}-{}", target.replace("armv7", "arm"), gnu) - } else if self.get_host() != target { + } else if self.get_host()? != target { // CROSS_COMPILE is of the form: "arm-linux-gnueabi-" let cc_env = self.getenv("CROSS_COMPILE"); let cross_compile = cc_env.as_ref().map(|s| s.trim_right_matches('-')); @@ -930,14 +1351,14 @@ impl Config { "arm-unknown-linux-gnueabihf" => Some("arm-linux-gnueabihf"), "arm-unknown-linux-musleabi" => Some("arm-linux-musleabi"), "arm-unknown-linux-musleabihf" => Some("arm-linux-musleabihf"), - "arm-unknown-netbsdelf-eabi" => Some("arm--netbsdelf-eabi"), - "armv6-unknown-netbsdelf-eabihf" => Some("armv6--netbsdelf-eabihf"), + "arm-unknown-netbsd-eabi" => Some("arm--netbsdelf-eabi"), + "armv6-unknown-netbsd-eabihf" => Some("armv6--netbsdelf-eabihf"), "armv7-unknown-linux-gnueabihf" => Some("arm-linux-gnueabihf"), "armv7-unknown-linux-musleabihf" => Some("arm-linux-musleabihf"), - "armv7-unknown-netbsdelf-eabihf" => Some("armv7--netbsdelf-eabihf"), + "armv7-unknown-netbsd-eabihf" => Some("armv7--netbsdelf-eabihf"), "i686-pc-windows-gnu" => Some("i686-w64-mingw32"), "i686-unknown-linux-musl" => Some("musl"), - "i686-unknown-netbsdelf" => Some("i486--netbsdelf"), + "i686-unknown-netbsd" => Some("i486--netbsdelf"), "mips-unknown-linux-gnu" => Some("mips-linux-gnu"), "mipsel-unknown-linux-gnu" => Some("mipsel-linux-gnu"), "mips64-unknown-linux-gnuabi64" => Some("mips64-linux-gnuabi64"), @@ -967,12 +1388,15 @@ impl Config { default.to_string() }; Tool::new(PathBuf::from(compiler)) - }) + } + }; + + Ok(tool) } - fn get_var(&self, var_base: &str) -> Result { - let target = self.get_target(); - let host = self.get_host(); + fn get_var(&self, var_base: &str) -> Result { + let target = self.get_target()?; + let host = self.get_host()?; let kind = if host == target { "HOST" } else { "TARGET" }; let target_u = target.replace("-", "_"); let res = self.getenv(&format!("{}_{}", var_base, target)) @@ -982,7 +1406,7 @@ impl Config { match res { Some(res) => Ok(res), - None => Err("could not get environment variable".to_string()), + None => Err(Error::new(ErrorKind::EnvVarNotFound, &format!("Could not find environment variable {}.", var_base))), } } @@ -997,7 +1421,7 @@ impl Config { fn env_tool(&self, name: &str) -> Option<(String, Vec)> { self.get_var(name).ok().map(|tool| { - let whitelist = ["ccache", "distcc"]; + let whitelist = ["ccache", "distcc", "sccache"]; for t in whitelist.iter() { if tool.starts_with(t) && tool[t.len()..].starts_with(' ') { return (t.to_string(), vec![tool[t.len()..].trim_left().to_string()]); @@ -1009,61 +1433,85 @@ impl Config { /// Returns the default C++ standard library for the current target: `libc++` /// for OS X and `libstdc++` for anything else. - fn get_cpp_link_stdlib(&self) -> Option { - self.cpp_link_stdlib.clone().unwrap_or_else(|| { - let target = self.get_target(); - if target.contains("msvc") { - None - } else if target.contains("darwin") { - Some("c++".to_string()) - } else if target.contains("freebsd") { - Some("c++".to_string()) - } else { - Some("stdc++".to_string()) - } - }) + fn get_cpp_link_stdlib(&self) -> Result, Error> { + match self.cpp_link_stdlib.clone() { + Some(s) => Ok(s), + None => { + let target = self.get_target()?; + if target.contains("msvc") { + Ok(None) + } else if target.contains("darwin") { + Ok(Some("c++".to_string())) + } else if target.contains("freebsd") { + Ok(Some("c++".to_string())) + } else { + Ok(Some("stdc++".to_string())) + } + }, + } } - fn get_ar(&self) -> PathBuf { - self.archiver + fn get_ar(&self) -> Result { + match self.archiver .clone() - .or_else(|| self.get_var("AR").map(PathBuf::from).ok()) - .unwrap_or_else(|| { - if self.get_target().contains("android") { - PathBuf::from(format!("{}-ar", self.get_target().replace("armv7", "arm"))) - } else if self.get_target().contains("emscripten") { - //Windows use bat files so we have to be a bit more specific - let tool = if cfg!(windows) { - "emar.bat" - } else { - "emar" - }; + .or_else(|| self.get_var("AR").map(PathBuf::from).ok()) { + Some(p) => Ok(p), + None => { + if self.get_target()?.contains("android") { + Ok(PathBuf::from(format!("{}-ar", self.get_target()?.replace("armv7", "arm")))) + } else if self.get_target()?.contains("emscripten") { + //Windows use bat files so we have to be a bit more specific + let tool = if cfg!(windows) { + "emar.bat" + } else { + "emar" + }; - PathBuf::from(tool) - } else { - PathBuf::from("ar") + Ok(PathBuf::from(tool)) + } else { + Ok(PathBuf::from("ar")) + } } - }) + } } - fn get_target(&self) -> String { - self.target.clone().unwrap_or_else(|| self.getenv_unwrap("TARGET")) + fn get_target(&self) -> Result { + match self.target.clone() { + Some(t) => Ok(t), + None => Ok(self.getenv_unwrap("TARGET")?), + } } - fn get_host(&self) -> String { - self.host.clone().unwrap_or_else(|| self.getenv_unwrap("HOST")) + fn get_host(&self) -> Result { + match self.host.clone() { + Some(h) => Ok(h), + None => Ok(self.getenv_unwrap("HOST")?), + } } - fn get_opt_level(&self) -> String { - self.opt_level.as_ref().cloned().unwrap_or_else(|| self.getenv_unwrap("OPT_LEVEL")) + fn get_opt_level(&self) -> Result { + match self.opt_level.as_ref().cloned() { + Some(ol) => Ok(ol), + None => Ok(self.getenv_unwrap("OPT_LEVEL")?), + } } fn get_debug(&self) -> bool { - self.debug.unwrap_or_else(|| self.getenv_unwrap("PROFILE") == "debug") + self.debug.unwrap_or_else(|| { + match self.getenv("DEBUG") { + Some(s) => s != "false", + None => false, + } + }) } - fn get_out_dir(&self) -> PathBuf { - self.out_dir.clone().unwrap_or_else(|| env::var_os("OUT_DIR").map(PathBuf::from).unwrap()) + fn get_out_dir(&self) -> Result { + match self.out_dir.clone() { + Some(p) => Ok(p), + None => Ok(env::var_os("OUT_DIR") + .map(PathBuf::from) + .ok_or_else(|| Error::new(ErrorKind::EnvVarNotFound, "Environment variable OUT_DIR not defined."))?), + } } fn getenv(&self, v: &str) -> Option { @@ -1072,10 +1520,10 @@ impl Config { r } - fn getenv_unwrap(&self, v: &str) -> String { + fn getenv_unwrap(&self, v: &str) -> Result { match self.getenv(v) { - Some(s) => s, - None => fail(&format!("environment variable `{}` not defined", v)), + Some(s) => Ok(s), + None => Err(Error::new(ErrorKind::EnvVarNotFound, &format!("Environment variable {} not defined.", v.to_string()))), } } @@ -1086,6 +1534,12 @@ impl Config { } } +impl Default for Build { + fn default() -> Build { + Build::new() + } +} + impl Tool { fn new(path: PathBuf) -> Tool { // Try to detect family of the tool from its name, falling back to Gnu. @@ -1145,31 +1599,42 @@ impl Tool { } } -fn run(cmd: &mut Command, program: &str) { - let (mut child, print) = spawn(cmd, program); - let status = child.wait().expect("failed to wait on child process"); +fn run(cmd: &mut Command, program: &str) -> Result<(), Error> { + let (mut child, print) = spawn(cmd, program)?; + let status = match child.wait() { + Ok(s) => s, + Err(_) => return Err(Error::new(ErrorKind::ToolExecError, &format!("Failed to wait on spawned child process, command {:?} with args {:?}.", cmd, program))), + }; print.join().unwrap(); println!("{}", status); - if !status.success() { - fail(&format!("command did not execute successfully, got: {}", status)); + + if status.success() { + Ok(()) + } else { + Err(Error::new(ErrorKind::ToolExecError, &format!("Command {:?} with args {:?} did not execute successfully (status code {}).", cmd, program, status))) } } -fn run_output(cmd: &mut Command, program: &str) -> Vec { +fn run_output(cmd: &mut Command, program: &str) -> Result, Error> { cmd.stdout(Stdio::piped()); - let (mut child, print) = spawn(cmd, program); + let (mut child, print) = spawn(cmd, program)?; let mut stdout = vec![]; child.stdout.take().unwrap().read_to_end(&mut stdout).unwrap(); - let status = child.wait().expect("failed to wait on child process"); + let status = match child.wait() { + Ok(s) => s, + Err(_) => return Err(Error::new(ErrorKind::ToolExecError, &format!("Failed to wait on spawned child process, command {:?} with args {:?}.", cmd, program))), + }; print.join().unwrap(); println!("{}", status); - if !status.success() { - fail(&format!("command did not execute successfully, got: {}", status)); + + if status.success() { + Ok(stdout) + } else { + Err(Error::new(ErrorKind::ToolExecError, &format!("Command {:?} with args {:?} did not execute successfully (status code {}).", cmd, program, status))) } - stdout } -fn spawn(cmd: &mut Command, program: &str) -> (Child, JoinHandle<()>) { +fn spawn(cmd: &mut Command, program: &str) -> Result<(Child, JoinHandle<()>), Error> { println!("running: {:?}", cmd); // Capture the standard error coming from these programs, and write it out @@ -1186,7 +1651,7 @@ fn spawn(cmd: &mut Command, program: &str) -> (Child, JoinHandle<()>) { println!(""); } }); - (child, print) + Ok((child, print)) } Err(ref e) if e.kind() == io::ErrorKind::NotFound => { let extra = if cfg!(windows) { @@ -1195,17 +1660,25 @@ fn spawn(cmd: &mut Command, program: &str) -> (Child, JoinHandle<()>) { } else { "" }; - fail(&format!("failed to execute command: {}\nIs `{}` \ - not installed?{}", - e, - program, - extra)); + Err(Error::new(ErrorKind::ToolNotFound, &format!("Failed to find tool. Is `{}` installed?{}", program, extra))) } - Err(e) => fail(&format!("failed to execute command: {}", e)), + Err(_) => Err(Error::new(ErrorKind::ToolExecError, &format!("Command {:?} with args {:?} failed to start.", cmd, program))), } } fn fail(s: &str) -> ! { - println!("\n\n{}\n\n", s); - panic!() + panic!("\n\nInternal error occurred: {}\n\n", s) +} + + +fn command_add_output_file(cmd: &mut Command, dst: &Path, msvc: bool, is_asm: bool) { + if msvc && is_asm { + cmd.arg("/Fo").arg(dst); + } else if msvc { + let mut s = OsString::from("/Fo"); + s.push(&dst); + cmd.arg(s); + } else { + cmd.arg("-o").arg(&dst); + } } diff --git a/gcc/src/winapi.rs b/gcc/src/winapi.rs index 010d165..3fb0408 100644 --- a/gcc/src/winapi.rs +++ b/gcc/src/winapi.rs @@ -67,8 +67,8 @@ pub trait Interface { fn uuidof() -> GUID; } -#[link(name = "Ole32")] -#[link(name = "OleAut32")] +#[link(name = "ole32")] +#[link(name = "oleaut32")] extern { } extern "system" { diff --git a/gcc/src/windows_registry.rs b/gcc/src/windows_registry.rs index d05fc1d..9099e0f 100644 --- a/gcc/src/windows_registry.rs +++ b/gcc/src/windows_registry.rs @@ -87,6 +87,7 @@ pub fn find_tool(target: &str, tool: &str) -> Option { } /// A version of Visual Studio +#[derive(Debug, PartialEq, Eq, Copy, Clone)] pub enum VsVers { /// Visual Studio 12 (2013) Vs12, @@ -99,6 +100,7 @@ pub enum VsVers { /// handle an enumeration of `VsVers` instances should always have a default /// case meaning that it's a VS version they don't understand. #[doc(hidden)] + #[allow(bad_style)] __Nonexhaustive_do_not_match_this_or_your_code_will_break, } @@ -195,6 +197,10 @@ mod impl_ { // In MSVC 15 (2017) MS once again changed the scheme for locating // the tooling. Now we must go through some COM interfaces, which // is super fun for Rust. + // + // Note that much of this logic can be found [online] wrt paths, COM, etc. + // + // [online]: https://blogs.msdn.microsoft.com/vcblog/2017/03/06/finding-the-visual-c-compiler-tools-in-visual-studio-2017/ pub fn find_msvc_15(tool: &str, target: &str) -> Option { otry!(com::initialize().ok()); @@ -213,12 +219,12 @@ mod impl_ { fn tool_from_vs15_instance(tool: &str, target: &str, instance: &SetupInstance) -> Option { - let (bin_path, lib_path, include_path) = otry!(vs15_vc_paths(target, instance)); + let (bin_path, host_dylib_path, lib_path, include_path) = otry!(vs15_vc_paths(target, instance)); let tool_path = bin_path.join(tool); if !tool_path.exists() { return None }; let mut tool = MsvcTool::new(tool_path); - tool.path.push(bin_path.clone()); + tool.path.push(host_dylib_path); tool.libs.push(lib_path); tool.include.push(include_path); @@ -232,7 +238,7 @@ mod impl_ { Some(tool.into_tool()) } - fn vs15_vc_paths(target: &str, instance: &SetupInstance) -> Option<(PathBuf, PathBuf, PathBuf)> { + fn vs15_vc_paths(target: &str, instance: &SetupInstance) -> Option<(PathBuf, PathBuf, PathBuf, PathBuf)> { let instance_path: PathBuf = otry!(instance.installation_path().ok()).into(); let version_path = instance_path.join(r"VC\Auxiliary\Build\Microsoft.VCToolsVersion.default.txt"); let mut version_file = otry!(File::open(version_path).ok()); @@ -245,11 +251,18 @@ mod impl_ { _ => return None, }; let target = otry!(lib_subdir(target)); + // The directory layout here is MSVC/bin/Host$host/$target/ let path = instance_path.join(r"VC\Tools\MSVC").join(version); + // This is the path to the toolchain for a particular target, running + // on a given host let bin_path = path.join("bin").join(&format!("Host{}", host)).join(&target); + // But! we also need PATH to contain the target directory for the host + // architecture, because it contains dlls like mspdb140.dll compiled for + // the host architecture. + let host_dylib_path = path.join("bin").join(&format!("Host{}", host)).join(&host.to_lowercase()); let lib_path = path.join("lib").join(&target); let include_path = path.join("include"); - Some((bin_path, lib_path, include_path)) + Some((bin_path, host_dylib_path, lib_path, include_path)) } fn atl_paths(target: &str, path: &Path) -> Option<(PathBuf, PathBuf)> { diff --git a/gcc/tests/support/mod.rs b/gcc/tests/support/mod.rs index 135a663..2f3e44c 100644 --- a/gcc/tests/support/mod.rs +++ b/gcc/tests/support/mod.rs @@ -36,7 +36,7 @@ impl Test { pub fn gnu() -> Test { let t = Test::new(); - t.shim("cc").shim("ar"); + t.shim("cc").shim("c++").shim("ar"); t } @@ -55,8 +55,8 @@ impl Test { self } - pub fn gcc(&self) -> gcc::Config { - let mut cfg = gcc::Config::new(); + pub fn gcc(&self) -> gcc::Build { + let mut cfg = gcc::Build::new(); let mut path = env::split_paths(&env::var_os("PATH").unwrap()).collect::>(); path.insert(0, self.td.path().to_owned()); let target = if self.msvc { diff --git a/gcc/tests/test.rs b/gcc/tests/test.rs index 8fda3ed..dd60f94 100644 --- a/gcc/tests/test.rs +++ b/gcc/tests/test.rs @@ -10,7 +10,7 @@ fn gnu_smoke() { let test = Test::gnu(); test.gcc() .file("foo.c") - .compile("libfoo.a"); + .compile("foo"); test.cmd(0) .must_have("-O2") @@ -28,7 +28,7 @@ fn gnu_opt_level_1() { test.gcc() .opt_level(1) .file("foo.c") - .compile("libfoo.a"); + .compile("foo"); test.cmd(0) .must_have("-O1") @@ -41,7 +41,7 @@ fn gnu_opt_level_s() { test.gcc() .opt_level_str("s") .file("foo.c") - .compile("libfoo.a"); + .compile("foo"); test.cmd(0) .must_have("-Os") @@ -57,10 +57,33 @@ fn gnu_debug() { test.gcc() .debug(true) .file("foo.c") - .compile("libfoo.a"); + .compile("foo"); test.cmd(0).must_have("-g"); } +#[test] +fn gnu_warnings_into_errors() { + let test = Test::gnu(); + test.gcc() + .warnings_into_errors(true) + .file("foo.c") + .compile("foo"); + + test.cmd(0).must_have("-Werror"); +} + +#[test] +fn gnu_warnings() { + let test = Test::gnu(); + test.gcc() + .warnings(true) + .file("foo.c") + .compile("foo"); + + test.cmd(0).must_have("-Wall") + .must_have("-Wextra"); +} + #[test] fn gnu_x86_64() { for vendor in &["unknown-linux-gnu", "apple-darwin"] { @@ -70,7 +93,7 @@ fn gnu_x86_64() { .target(&target) .host(&target) .file("foo.c") - .compile("libfoo.a"); + .compile("foo"); test.cmd(0) .must_have("-fPIC") @@ -88,7 +111,7 @@ fn gnu_x86_64_no_pic() { .target(&target) .host(&target) .file("foo.c") - .compile("libfoo.a"); + .compile("foo"); test.cmd(0).must_not_have("-fPIC"); } @@ -103,7 +126,7 @@ fn gnu_i686() { .target(&target) .host(&target) .file("foo.c") - .compile("libfoo.a"); + .compile("foo"); test.cmd(0) .must_have("-m32"); @@ -120,7 +143,7 @@ fn gnu_i686_pic() { .target(&target) .host(&target) .file("foo.c") - .compile("libfoo.a"); + .compile("foo"); test.cmd(0).must_have("-fPIC"); } @@ -132,7 +155,7 @@ fn gnu_set_stdlib() { test.gcc() .cpp_set_stdlib(Some("foo")) .file("foo.c") - .compile("libfoo.a"); + .compile("foo"); test.cmd(0).must_not_have("-stdlib=foo"); } @@ -143,7 +166,7 @@ fn gnu_include() { test.gcc() .include("foo/bar") .file("foo.c") - .compile("libfoo.a"); + .compile("foo"); test.cmd(0).must_have("-I").must_have("foo/bar"); } @@ -152,10 +175,10 @@ fn gnu_include() { fn gnu_define() { let test = Test::gnu(); test.gcc() - .define("FOO", Some("bar")) + .define("FOO", "bar") .define("BAR", None) .file("foo.c") - .compile("libfoo.a"); + .compile("foo"); test.cmd(0).must_have("-DFOO=bar").must_have("-DBAR"); } @@ -165,16 +188,79 @@ fn gnu_compile_assembly() { let test = Test::gnu(); test.gcc() .file("foo.S") - .compile("libfoo.a"); + .compile("foo"); test.cmd(0).must_have("foo.S"); } +#[test] +fn gnu_shared() { + let test = Test::gnu(); + test.gcc() + .file("foo.c") + .shared_flag(true) + .static_flag(false) + .compile("foo"); + + test.cmd(0) + .must_have("-shared") + .must_not_have("-static"); +} + +#[test] +fn gnu_flag_if_supported() { + if cfg!(windows) { + return + } + let test = Test::gnu(); + test.gcc() + .file("foo.c") + .flag_if_supported("-Wall") + .flag_if_supported("-Wflag-does-not-exist") + .flag_if_supported("-std=c++11") + .compile("foo"); + + test.cmd(0) + .must_have("-Wall") + .must_not_have("-Wflag-does-not-exist") + .must_not_have("-std=c++11"); +} + +#[test] +fn gnu_flag_if_supported_cpp() { + if cfg!(windows) { + return + } + let test = Test::gnu(); + test.gcc() + .cpp(true) + .file("foo.cpp") + .flag_if_supported("-std=c++11") + .compile("foo"); + + test.cmd(0) + .must_have("-std=c++11"); +} + +#[test] +fn gnu_static() { + let test = Test::gnu(); + test.gcc() + .file("foo.c") + .shared_flag(false) + .static_flag(true) + .compile("foo"); + + test.cmd(0) + .must_have("-static") + .must_not_have("-shared"); +} + #[test] fn msvc_smoke() { let test = Test::msvc(); test.gcc() .file("foo.c") - .compile("libfoo.a"); + .compile("foo"); test.cmd(0) .must_have("/O2") @@ -191,7 +277,7 @@ fn msvc_opt_level_0() { test.gcc() .opt_level(0) .file("foo.c") - .compile("libfoo.a"); + .compile("foo"); test.cmd(0).must_not_have("/O2"); } @@ -202,7 +288,7 @@ fn msvc_debug() { test.gcc() .debug(true) .file("foo.c") - .compile("libfoo.a"); + .compile("foo"); test.cmd(0).must_have("/Z7"); } @@ -212,7 +298,7 @@ fn msvc_include() { test.gcc() .include("foo/bar") .file("foo.c") - .compile("libfoo.a"); + .compile("foo"); test.cmd(0).must_have("/I").must_have("foo/bar"); } @@ -221,10 +307,10 @@ fn msvc_include() { fn msvc_define() { let test = Test::msvc(); test.gcc() - .define("FOO", Some("bar")) + .define("FOO", "bar") .define("BAR", None) .file("foo.c") - .compile("libfoo.a"); + .compile("foo"); test.cmd(0).must_have("/DFOO=bar").must_have("/DBAR"); } @@ -235,7 +321,7 @@ fn msvc_static_crt() { test.gcc() .static_crt(true) .file("foo.c") - .compile("libfoo.a"); + .compile("foo"); test.cmd(0).must_have("/MT"); } @@ -246,7 +332,7 @@ fn msvc_no_static_crt() { test.gcc() .static_crt(false) .file("foo.c") - .compile("libfoo.a"); + .compile("foo"); test.cmd(0).must_have("/MD"); } -- cgit v1.2.1