aboutsummaryrefslogtreecommitdiff
path: root/cc/src
diff options
context:
space:
mode:
authorDaniel Mueller <deso@posteo.net>2020-04-04 14:39:19 -0700
committerDaniel Mueller <deso@posteo.net>2020-04-04 14:39:19 -0700
commitd0d9683df8398696147e7ee1fcffb2e4e957008c (patch)
tree4baa76712a76f4d072ee3936c07956580b230820 /cc/src
parent203e691f46d591a2cc8acdfd850fa9f5b0fb8a98 (diff)
downloadnitrocli-d0d9683df8398696147e7ee1fcffb2e4e957008c.tar.gz
nitrocli-d0d9683df8398696147e7ee1fcffb2e4e957008c.tar.bz2
Remove vendored dependencies
While it appears that by now we actually can get successful builds without Cargo insisting on Internet access by virtue of using the --frozen flag, maintaining vendored dependencies is somewhat of a pain point. This state will also get worse with upcoming changes that replace argparse in favor of structopt and pull in a slew of new dependencies by doing so. Then there is also the repository structure aspect, which is non-standard due to the way we vendor dependencies and a potential source of confusion. In order to fix these problems, this change removes all the vendored dependencies we have. Delete subrepo argparse/:argparse Delete subrepo base32/:base32 Delete subrepo cc/:cc Delete subrepo cfg-if/:cfg-if Delete subrepo getrandom/:getrandom Delete subrepo lazy-static/:lazy-static Delete subrepo libc/:libc Delete subrepo nitrokey-sys/:nitrokey-sys Delete subrepo nitrokey/:nitrokey Delete subrepo rand/:rand
Diffstat (limited to 'cc/src')
-rw-r--r--cc/src/bin/gcc-shim.rs48
-rw-r--r--cc/src/com.rs155
-rw-r--r--cc/src/lib.rs2666
-rw-r--r--cc/src/registry.rs204
-rw-r--r--cc/src/setup_config.rs283
-rw-r--r--cc/src/winapi.rs218
-rw-r--r--cc/src/windows_registry.rs754
7 files changed, 0 insertions, 4328 deletions
diff --git a/cc/src/bin/gcc-shim.rs b/cc/src/bin/gcc-shim.rs
deleted file mode 100644
index 1731df8..0000000
--- a/cc/src/bin/gcc-shim.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-#![cfg_attr(test, allow(dead_code))]
-
-use std::env;
-use std::fs::File;
-use std::io::prelude::*;
-use std::path::PathBuf;
-
-fn main() {
- let mut args = env::args();
- let program = args.next().expect("Unexpected empty args");
-
- let out_dir = PathBuf::from(
- env::var_os("GCCTEST_OUT_DIR").expect(&format!("{}: GCCTEST_OUT_DIR not found", program)),
- );
-
- // Find the first nonexistent candidate file to which the program's args can be written.
- for i in 0.. {
- let candidate = &out_dir.join(format!("out{}", i));
-
- // If the file exists, commands have already run. Try again.
- if candidate.exists() {
- continue;
- }
-
- // Create a file and record the args passed to the command.
- let mut f = File::create(candidate).expect(&format!(
- "{}: can't create candidate: {}",
- program,
- candidate.to_string_lossy()
- ));
- for arg in args {
- writeln!(f, "{}", arg).expect(&format!(
- "{}: can't write to candidate: {}",
- program,
- candidate.to_string_lossy()
- ));
- }
- break;
- }
-
- // Create a file used by some tests.
- let path = &out_dir.join("libfoo.a");
- File::create(path).expect(&format!(
- "{}: can't create libfoo.a: {}",
- program,
- path.to_string_lossy()
- ));
-}
diff --git a/cc/src/com.rs b/cc/src/com.rs
deleted file mode 100644
index a5f2afe..0000000
--- a/cc/src/com.rs
+++ /dev/null
@@ -1,155 +0,0 @@
-// Copyright © 2017 winapi-rs developers
-// Licensed under the Apache License, Version 2.0
-// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
-// All files in the project carrying such notice may not be copied, modified, or distributed
-// except according to those terms.
-
-#![allow(unused)]
-
-use crate::winapi::CoInitializeEx;
-use crate::winapi::IUnknown;
-use crate::winapi::Interface;
-use crate::winapi::BSTR;
-use crate::winapi::COINIT_MULTITHREADED;
-use crate::winapi::{SysFreeString, SysStringLen};
-use crate::winapi::{HRESULT, S_FALSE, S_OK};
-use std::ffi::{OsStr, OsString};
-use std::mem::forget;
-use std::ops::Deref;
-use std::os::windows::ffi::{OsStrExt, OsStringExt};
-use std::ptr::null_mut;
-use std::slice::from_raw_parts;
-
-pub fn initialize() -> Result<(), HRESULT> {
- let err = unsafe { CoInitializeEx(null_mut(), COINIT_MULTITHREADED) };
- if err != S_OK && err != S_FALSE {
- // S_FALSE just means COM is already initialized
- return Err(err);
- }
- Ok(())
-}
-
-pub struct ComPtr<T>(*mut T)
-where
- T: Interface;
-impl<T> ComPtr<T>
-where
- T: Interface,
-{
- /// Creates a `ComPtr` to wrap a raw pointer.
- /// It takes ownership over the pointer which means it does __not__ call `AddRef`.
- /// `T` __must__ be a COM interface that inherits from `IUnknown`.
- pub unsafe fn from_raw(ptr: *mut T) -> ComPtr<T> {
- assert!(!ptr.is_null());
- ComPtr(ptr)
- }
- /// Casts up the inheritance chain
- pub fn up<U>(self) -> ComPtr<U>
- where
- T: Deref<Target = U>,
- U: Interface,
- {
- ComPtr(self.into_raw() as *mut U)
- }
- /// Extracts the raw pointer.
- /// You are now responsible for releasing it yourself.
- pub fn into_raw(self) -> *mut T {
- let p = self.0;
- forget(self);
- p
- }
- /// For internal use only.
- fn as_unknown(&self) -> &IUnknown {
- unsafe { &*(self.0 as *mut IUnknown) }
- }
- /// Performs QueryInterface fun.
- pub fn cast<U>(&self) -> Result<ComPtr<U>, i32>
- where
- U: Interface,
- {
- let mut obj = null_mut();
- let err = unsafe { self.as_unknown().QueryInterface(&U::uuidof(), &mut obj) };
- if err < 0 {
- return Err(err);
- }
- Ok(unsafe { ComPtr::from_raw(obj as *mut U) })
- }
-}
-impl<T> Deref for ComPtr<T>
-where
- T: Interface,
-{
- type Target = T;
- fn deref(&self) -> &T {
- unsafe { &*self.0 }
- }
-}
-impl<T> Clone for ComPtr<T>
-where
- T: Interface,
-{
- fn clone(&self) -> Self {
- unsafe {
- self.as_unknown().AddRef();
- ComPtr::from_raw(self.0)
- }
- }
-}
-impl<T> Drop for ComPtr<T>
-where
- T: Interface,
-{
- fn drop(&mut self) {
- unsafe {
- self.as_unknown().Release();
- }
- }
-}
-pub struct BStr(BSTR);
-impl BStr {
- pub unsafe fn from_raw(s: BSTR) -> BStr {
- BStr(s)
- }
- pub fn to_osstring(&self) -> OsString {
- let len = unsafe { SysStringLen(self.0) };
- let slice = unsafe { from_raw_parts(self.0, len as usize) };
- OsStringExt::from_wide(slice)
- }
-}
-impl Drop for BStr {
- fn drop(&mut self) {
- unsafe { SysFreeString(self.0) };
- }
-}
-
-pub trait ToWide {
- fn to_wide(&self) -> Vec<u16>;
- fn to_wide_null(&self) -> Vec<u16>;
-}
-impl<T> ToWide for T
-where
- T: AsRef<OsStr>,
-{
- fn to_wide(&self) -> Vec<u16> {
- self.as_ref().encode_wide().collect()
- }
- fn to_wide_null(&self) -> Vec<u16> {
- self.as_ref().encode_wide().chain(Some(0)).collect()
- }
-}
-pub trait FromWide
-where
- Self: Sized,
-{
- fn from_wide(wide: &[u16]) -> Self;
- fn from_wide_null(wide: &[u16]) -> Self {
- let len = wide.iter().take_while(|&&c| c != 0).count();
- Self::from_wide(&wide[..len])
- }
-}
-impl FromWide for OsString {
- fn from_wide(wide: &[u16]) -> OsString {
- OsStringExt::from_wide(wide)
- }
-}
diff --git a/cc/src/lib.rs b/cc/src/lib.rs
deleted file mode 100644
index d795e5a..0000000
--- a/cc/src/lib.rs
+++ /dev/null
@@ -1,2666 +0,0 @@
-//! A library for build scripts to compile custom C code
-//!
-//! This library is intended to be used as a `build-dependencies` entry in
-//! `Cargo.toml`:
-//!
-//! ```toml
-//! [build-dependencies]
-//! cc = "1.0"
-//! ```
-//!
-//! 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.
-//! 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.
-//!
-//! 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.
-//!
-//! [`Build`]: struct.Build.html
-//!
-//! # Parallelism
-//!
-//! To parallelize computation, enable the `parallel` feature for the crate.
-//!
-//! ```toml
-//! [build-dependencies]
-//! cc = { version = "1.0", features = ["parallel"] }
-//! ```
-//! To specify the max number of concurrent compilation jobs, set the `NUM_JOBS`
-//! environment variable to the desired amount.
-//!
-//! Cargo will also set this environment variable when executed with the `-jN` flag.
-//!
-//! If `NUM_JOBS` is not set, the `RAYON_NUM_THREADS` environment variable can
-//! also specify the build parallelism.
-//!
-//! # Examples
-//!
-//! Use the `Build` struct to compile `src/foo.c`:
-//!
-//! ```no_run
-//! fn main() {
-//! cc::Build::new()
-//! .file("src/foo.c")
-//! .define("FOO", Some("bar"))
-//! .include("src")
-//! .compile("foo");
-//! }
-//! ```
-
-#![doc(html_root_url = "https://docs.rs/cc/1.0")]
-#![cfg_attr(test, deny(warnings))]
-#![allow(deprecated)]
-#![deny(missing_docs)]
-
-use std::collections::HashMap;
-use std::env;
-use std::ffi::{OsStr, OsString};
-use std::fmt::{self, Display};
-use std::fs;
-use std::io::{self, BufRead, BufReader, Read, Write};
-use std::path::{Path, PathBuf};
-use std::process::{Child, Command, Stdio};
-use std::sync::{Arc, Mutex};
-use std::thread::{self, JoinHandle};
-
-// These modules are all glue to support reading the MSVC version from
-// the registry and from COM interfaces
-#[cfg(windows)]
-mod registry;
-#[cfg(windows)]
-#[macro_use]
-mod winapi;
-#[cfg(windows)]
-mod com;
-#[cfg(windows)]
-mod setup_config;
-
-pub mod windows_registry;
-
-/// A builder for compilation of a native static library.
-///
-/// A `Build` is the main type of the `cc` crate and is used to control all the
-/// various configuration options and such of a compile. You'll find more
-/// documentation on each method itself.
-#[derive(Clone, Debug)]
-pub struct Build {
- include_directories: Vec<PathBuf>,
- definitions: Vec<(String, Option<String>)>,
- objects: Vec<PathBuf>,
- flags: Vec<String>,
- flags_supported: Vec<String>,
- known_flag_support_status: Arc<Mutex<HashMap<String, bool>>>,
- ar_flags: Vec<String>,
- no_default_flags: bool,
- files: Vec<PathBuf>,
- cpp: bool,
- cpp_link_stdlib: Option<Option<String>>,
- cpp_set_stdlib: Option<String>,
- cuda: bool,
- target: Option<String>,
- host: Option<String>,
- out_dir: Option<PathBuf>,
- opt_level: Option<String>,
- debug: Option<bool>,
- force_frame_pointer: Option<bool>,
- env: Vec<(OsString, OsString)>,
- compiler: Option<PathBuf>,
- archiver: Option<PathBuf>,
- cargo_metadata: bool,
- pic: Option<bool>,
- use_plt: Option<bool>,
- static_crt: Option<bool>,
- shared_flag: Option<bool>,
- static_flag: Option<bool>,
- warnings_into_errors: bool,
- warnings: Option<bool>,
- extra_warnings: Option<bool>,
- env_cache: Arc<Mutex<HashMap<String, Option<String>>>>,
-}
-
-/// Represents the types of errors that may occur while using cc-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 explanation.
-#[derive(Clone, Debug)]
-pub struct Error {
- /// Describes the kind of error that occurred.
- kind: ErrorKind,
- /// More explanation of error that occurred.
- message: String,
-}
-
-impl Error {
- fn new(kind: ErrorKind, message: &str) -> Error {
- Error {
- kind: kind,
- message: message.to_owned(),
- }
- }
-}
-
-impl From<io::Error> for Error {
- fn from(e: io::Error) -> Error {
- Error::new(ErrorKind::IOError, &format!("{}", e))
- }
-}
-
-impl Display for Error {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "{:?}: {}", self.kind, self.message)
- }
-}
-
-/// Configuration used to represent an invocation of a C compiler.
-///
-/// This can be used to figure out what compiler is in use, what the arguments
-/// to it are, and what the environment variables look like for the compiler.
-/// 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,
- cc_wrapper_path: Option<PathBuf>,
- cc_wrapper_args: Vec<OsString>,
- args: Vec<OsString>,
- env: Vec<(OsString, OsString)>,
- family: ToolFamily,
- cuda: bool,
- removed_args: Vec<OsString>,
-}
-
-/// Represents the family of tools this tool belongs to.
-///
-/// 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, PartialEq)]
-enum ToolFamily {
- /// Tool is GNU Compiler Collection-like.
- Gnu,
- /// Tool is Clang-like. It differs from the GCC in a sense that it accepts superset of flags
- /// and its cross-compilation approach is different.
- Clang,
- /// Tool is the MSVC cl.exe.
- Msvc { clang_cl: bool },
-}
-
-impl ToolFamily {
- /// What the flag to request debug info for this family of tools look like
- fn add_debug_flags(&self, cmd: &mut Tool) {
- match *self {
- ToolFamily::Msvc { .. } => {
- cmd.push_cc_arg("-Z7".into());
- }
- ToolFamily::Gnu | ToolFamily::Clang => {
- cmd.push_cc_arg("-g".into());
- }
- }
- }
-
- /// What the flag to force frame pointers.
- fn add_force_frame_pointer(&self, cmd: &mut Tool) {
- match *self {
- ToolFamily::Gnu | ToolFamily::Clang => {
- cmd.push_cc_arg("-fno-omit-frame-pointer".into());
- }
- _ => (),
- }
- }
-
- /// What the flags to enable all warnings
- fn warnings_flags(&self) -> &'static str {
- match *self {
- ToolFamily::Msvc { .. } => "-W4",
- ToolFamily::Gnu | ToolFamily::Clang => "-Wall",
- }
- }
-
- /// What the flags to enable extra warnings
- fn extra_warnings_flags(&self) -> Option<&'static str> {
- match *self {
- ToolFamily::Msvc { .. } => None,
- ToolFamily::Gnu | ToolFamily::Clang => Some("-Wextra"),
- }
- }
-
- /// 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",
- }
- }
-
- fn verbose_stderr(&self) -> bool {
- *self == ToolFamily::Clang
- }
-}
-
-/// Represents an object.
-///
-/// This is a source file -> object file pair.
-#[derive(Clone, Debug)]
-struct Object {
- src: PathBuf,
- dst: PathBuf,
-}
-
-impl Object {
- /// Create a new source file -> object file pair.
- fn new(src: PathBuf, dst: PathBuf) -> Object {
- Object { src: src, dst: dst }
- }
-}
-
-impl Build {
- /// Construct a new instance of a blank set of configuration.
- ///
- /// 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(),
- known_flag_support_status: Arc::new(Mutex::new(HashMap::new())),
- ar_flags: Vec::new(),
- no_default_flags: false,
- files: Vec::new(),
- shared_flag: None,
- static_flag: None,
- cpp: false,
- cpp_link_stdlib: None,
- cpp_set_stdlib: None,
- cuda: false,
- target: None,
- host: None,
- out_dir: None,
- opt_level: None,
- debug: None,
- force_frame_pointer: None,
- env: Vec::new(),
- compiler: None,
- archiver: None,
- cargo_metadata: true,
- pic: None,
- use_plt: None,
- static_crt: None,
- warnings: None,
- extra_warnings: None,
- warnings_into_errors: false,
- env_cache: Arc::new(Mutex::new(HashMap::new())),
- }
- }
-
- /// Add a directory to the `-I` or include path for headers
- ///
- /// # Example
- ///
- /// ```no_run
- /// use std::path::Path;
- ///
- /// let library_path = Path::new("/path/to/library");
- ///
- /// cc::Build::new()
- /// .file("src/foo.c")
- /// .include(library_path)
- /// .include("src")
- /// .compile("foo");
- /// ```
- pub fn include<P: AsRef<Path>>(&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.
- ///
- /// # Example
- ///
- /// ```no_run
- /// cc::Build::new()
- /// .file("src/foo.c")
- /// .define("FOO", "BAR")
- /// .define("BAZ", None)
- /// .compile("foo");
- /// ```
- pub fn define<'a, V: Into<Option<&'a str>>>(&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<P: AsRef<Path>>(&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
- ///
- /// # Example
- ///
- /// ```no_run
- /// cc::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
- }
-
- /// Add an arbitrary flag to the invocation of the compiler
- ///
- /// # Example
- ///
- /// ```no_run
- /// cc::Build::new()
- /// .file("src/foo.c")
- /// .file("src/bar.c")
- /// .ar_flag("/NODEFAULTLIB:libc.dll")
- /// .compile("foo");
- /// ```
-
- pub fn ar_flag(&mut self, flag: &str) -> &mut Build {
- self.ar_flags.push(flag.to_string());
- self
- }
-
- fn ensure_check_file(&self) -> Result<PathBuf, Error> {
- let out_dir = self.get_out_dir()?;
- let src = if self.cuda {
- assert!(self.cpp);
- out_dir.join("flag_check.cu")
- } else 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)
- }
-
- /// Run the compiler to test if it accepts the given flag.
- ///
- /// For a convenience method for setting flags conditionally,
- /// see `flag_if_supported()`.
- ///
- /// It may return error if it's unable to run the compilier with a test file
- /// (e.g. the compiler is missing or a write to the `out_dir` failed).
- ///
- /// Note: Once computed, the result of this call is stored in the
- /// `known_flag_support` field. If `is_flag_supported(flag)`
- /// is called again, the result will be read from the hash table.
- pub fn is_flag_supported(&self, flag: &str) -> Result<bool, Error> {
- let mut known_status = self.known_flag_support_status.lock().unwrap();
- if let Some(is_supported) = known_status.get(flag).cloned() {
- return Ok(is_supported);
- }
-
- 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 host = self.get_host()?;
- let mut cfg = Build::new();
- cfg.flag(flag)
- .target(&target)
- .opt_level(0)
- .host(&host)
- .debug(false)
- .cpp(self.cpp)
- .cuda(self.cuda);
- let mut compiler = cfg.try_get_compiler()?;
-
- // Clang uses stderr for verbose output, which yields a false positive
- // result if the CFLAGS/CXXFLAGS include -v to aid in debugging.
- if compiler.family.verbose_stderr() {
- compiler.remove_arg("-v".into());
- }
-
- let mut cmd = compiler.to_command();
- let is_arm = target.contains("aarch64") || target.contains("arm");
- command_add_output_file(
- &mut cmd,
- &obj,
- self.cuda,
- target.contains("msvc"),
- false,
- is_arm,
- );
-
- // We need to explicitly tell msvc not to link and create an exe
- // in the root directory of the crate
- if target.contains("msvc") && !self.cuda {
- cmd.arg("-c");
- }
-
- cmd.arg(&src);
-
- let output = cmd.output()?;
- let is_supported = output.stderr.is_empty();
-
- known_status.insert(flag.to_owned(), is_supported);
- Ok(is_supported)
- }
-
- /// Add an arbitrary flag to the invocation of the compiler if it supports it
- ///
- /// # Example
- ///
- /// ```no_run
- /// cc::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
- /// cc::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
- /// cc::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
- }
-
- /// Disables the generation of default compiler flags. The default compiler
- /// flags may cause conflicts in some cross compiling scenarios.
- ///
- /// Setting the `CRATE_CC_NO_DEFAULTS` environment variable has the same
- /// effect as setting this to `true`. The presence of the environment
- /// variable and the value of `no_default_flags` will be OR'd together.
- pub fn no_default_flags(&mut self, no_default_flags: bool) -> &mut Build {
- self.no_default_flags = no_default_flags;
- self
- }
-
- /// Add a file which will be compiled
- pub fn file<P: AsRef<Path>>(&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<P>(&mut self, p: P) -> &mut Build
- where
- P: IntoIterator,
- P::Item: AsRef<Path>,
- {
- 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 Build {
- self.cpp = cpp;
- self
- }
-
- /// Set CUDA C++ support.
- ///
- /// Enabling CUDA will pass the detected C/C++ toolchain as an argument to
- /// the CUDA compiler, NVCC. NVCC itself accepts some limited GNU-like args;
- /// any other arguments for the C/C++ toolchain will be redirected using
- /// "-Xcompiler" flags.
- ///
- /// If enabled, this also implicitly enables C++ support.
- pub fn cuda(&mut self, cuda: bool) -> &mut Build {
- self.cuda = cuda;
- if cuda {
- self.cpp = true;
- }
- 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 cc-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
- /// cc::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
- /// cc::Build::new()
- /// .file("src/foo.c")
- /// .warnings(false)
- /// .compile("libfoo.a");
- /// ```
- pub fn warnings(&mut self, warnings: bool) -> &mut Build {
- self.warnings = Some(warnings);
- self.extra_warnings = Some(warnings);
- self
- }
-
- /// Set extra warnings flags.
- ///
- /// Adds some flags:
- /// - nothing for MSVC.
- /// - "-Wextra" for GNU and Clang.
- ///
- /// Enabled by default.
- ///
- /// # Example
- ///
- /// ```no_run
- /// // Disables -Wextra, -Wall remains enabled:
- /// cc::Build::new()
- /// .file("src/foo.c")
- /// .extra_warnings(false)
- /// .compile("libfoo.a");
- /// ```
- pub fn extra_warnings(&mut self, warnings: bool) -> &mut Build {
- self.extra_warnings = Some(warnings);
- self
- }
-
- /// Set the standard library to link against when compiling with C++
- /// support.
- ///
- /// The default value of this property depends on the current target: On
- /// OS X `Some("c++")` is used, when compiling for a Visual Studio based
- /// target `None` is used and for other targets `Some("stdc++")` is used.
- /// If the `CXXSTDLIB` environment variable is set, its value will
- /// override the default value.
- ///
- /// A value of `None` indicates that no automatic linking should happen,
- /// otherwise cargo will link against the specified library.
- ///
- /// The given library name must not contain the `lib` prefix.
- ///
- /// Common values:
- /// - `stdc++` for GNU
- /// - `c++` for Clang
- ///
- /// # Example
- ///
- /// ```no_run
- /// cc::Build::new()
- /// .file("src/foo.c")
- /// .shared_flag(true)
- /// .cpp_link_stdlib("stdc++")
- /// .compile("libfoo.so");
- /// ```
- pub fn cpp_link_stdlib<'a, V: Into<Option<&'a str>>>(
- &mut self,
- cpp_link_stdlib: V,
- ) -> &mut Build {
- self.cpp_link_stdlib = Some(cpp_link_stdlib.into().map(|s| s.into()));
- self
- }
-
- /// Force the C++ compiler to use the specified standard library.
- ///
- /// Setting this option will automatically set `cpp_link_stdlib` to the same
- /// value.
- ///
- /// The default value of this option is always `None`.
- ///
- /// This option has no effect when compiling for a Visual Studio based
- /// target.
- ///
- /// This option sets the `-stdlib` flag, which is only supported by some
- /// compilers (clang, icc) but not by others (gcc). The library will not
- /// detect which compiler is used, as such it is the responsibility of the
- /// caller to ensure that this option is only used in conjuction with a
- /// compiler which supports the `-stdlib` flag.
- ///
- /// A value of `None` indicates that no specific C++ standard library should
- /// be used, otherwise `-stdlib` is added to the compile invocation.
- ///
- /// The given library name must not contain the `lib` prefix.
- ///
- /// Common values:
- /// - `stdc++` for GNU
- /// - `c++` for Clang
- ///
- /// # Example
- ///
- /// ```no_run
- /// cc::Build::new()
- /// .file("src/foo.c")
- /// .cpp_set_stdlib("c++")
- /// .compile("libfoo.a");
- /// ```
- pub fn cpp_set_stdlib<'a, V: Into<Option<&'a str>>>(
- &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
- }
-
- /// Configures the target this configuration will be compiling for.
- ///
- /// This option is automatically scraped from the `TARGET` environment
- /// variable by build scripts, so it's not required to call this function.
- ///
- /// # Example
- ///
- /// ```no_run
- /// cc::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
- }
-
- /// Configures the host assumed by this configuration.
- ///
- /// This option is automatically scraped from the `HOST` environment
- /// variable by build scripts, so it's not required to call this function.
- ///
- /// # Example
- ///
- /// ```no_run
- /// cc::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
- }
-
- /// Configures the optimization level of the generated object files.
- ///
- /// 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 Build {
- self.opt_level = Some(opt_level.to_string());
- self
- }
-
- /// Configures the optimization level of the generated object files.
- ///
- /// 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 Build {
- self.opt_level = Some(opt_level.to_string());
- self
- }
-
- /// Configures whether the compiler will emit debug information when
- /// generating object files.
- ///
- /// This option is automatically scraped from the `DEBUG` environment
- /// variable by build scripts, so it's not required to call this function.
- pub fn debug(&mut self, debug: bool) -> &mut Build {
- self.debug = Some(debug);
- self
- }
-
- /// Configures whether the compiler will emit instructions to store
- /// frame pointers during codegen.
- ///
- /// This option is automatically enabled when debug information is emitted.
- /// Otherwise the target platform compiler's default will be used.
- /// You can use this option to force a specific setting.
- pub fn force_frame_pointer(&mut self, force: bool) -> &mut Build {
- self.force_frame_pointer = Some(force);
- self
- }
-
- /// Configures the output directory where all object files and static
- /// libraries will be located.
- ///
- /// 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<P: AsRef<Path>>(&mut self, out_dir: P) -> &mut Build {
- self.out_dir = Some(out_dir.as_ref().to_owned());
- self
- }
-
- /// Configures the compiler to be used to produce output.
- ///
- /// 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<P: AsRef<Path>>(&mut self, compiler: P) -> &mut Build {
- self.compiler = Some(compiler.as_ref().to_owned());
- self
- }
-
- /// Configures the tool used to assemble archives.
- ///
- /// 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<P: AsRef<Path>>(&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`.
- ///
- /// 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
- }
-
- /// Configures whether the compiler will emit position independent code.
- ///
- /// This option defaults to `false` for `windows-gnu` and `riscv` targets and
- /// to `true` for all other targets.
- pub fn pic(&mut self, pic: bool) -> &mut Build {
- self.pic = Some(pic);
- self
- }
-
- /// Configures whether the Procedure Linkage Table is used for indirect
- /// calls into shared libraries.
- ///
- /// The PLT is used to provide features like lazy binding, but introduces
- /// a small performance loss due to extra pointer indirection. Setting
- /// `use_plt` to `false` can provide a small performance increase.
- ///
- /// Note that skipping the PLT requires a recent version of GCC/Clang.
- ///
- /// This only applies to ELF targets. It has no effect on other platforms.
- pub fn use_plt(&mut self, use_plt: bool) -> &mut Build {
- self.use_plt = Some(use_plt);
- self
- }
-
- /// 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 Build {
- self.static_crt = Some(static_crt);
- self
- }
-
- #[doc(hidden)]
- pub fn __set_env<A, B>(&mut self, a: A, b: B) -> &mut Build
- where
- A: AsRef<OsStr>,
- B: AsRef<OsStr>,
- {
- self.env
- .push((a.as_ref().to_owned(), b.as_ref().to_owned()));
- self
- }
-
- /// Run the compiler, generating the file `output`
- ///
- /// 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();
- 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().ok_or_else(|| {
- Error::new(ErrorKind::IOError, "Getting object file details failed.")
- })?)
- } else {
- obj
- };
-
- match obj.parent() {
- Some(s) => fs::create_dir_all(s)?,
- None => {
- return Err(Error::new(
- ErrorKind::IOError,
- "Getting object file details failed.",
- ));
- }
- };
-
- objects.push(Object::new(file.to_path_buf(), obj));
- }
- self.compile_objects(&objects)?;
- self.assemble(lib_name, &dst.join(gnu_lib_name), &objects)?;
-
- 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"))
- .and_then(|&(_, ref lib_paths)| {
- env::split_paths(lib_paths).find(|path| {
- let sub = Path::new("atlmfc/lib");
- path.ends_with(sub) || path.parent().map_or(false, |p| p.ends_with(sub))
- })
- });
-
- if let Some(atlmfc_lib) = atlmfc_lib {
- self.print(&format!(
- "cargo:rustc-link-search=native={}",
- atlmfc_lib.display()
- ));
- }
- }
-
- 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()? {
- 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<'me>(&'me self, objs: &[Object]) -> Result<(), Error> {
- use std::sync::atomic::{AtomicBool, Ordering::SeqCst};
- use std::sync::Once;
-
- // Limit our parallelism globally with a jobserver. Start off by
- // releasing our own token for this process so we can have a bit of an
- // easier to write loop below. If this fails, though, then we're likely
- // on Windows with the main implicit token, so we just have a bit extra
- // parallelism for a bit and don't reacquire later.
- let server = jobserver();
- let reacquire = server.release_raw().is_ok();
-
- // When compiling objects in parallel we do a few dirty tricks to speed
- // things up:
- //
- // * First is that we use the `jobserver` crate to limit the parallelism
- // of this build script. The `jobserver` crate will use a jobserver
- // configured by Cargo for build scripts to ensure that parallelism is
- // coordinated across C compilations and Rust compilations. Before we
- // compile anything we make sure to wait until we acquire a token.
- //
- // Note that this jobserver is cached globally so we only used one per
- // process and only worry about creating it once.
- //
- // * Next we use a raw `thread::spawn` per thread to actually compile
- // objects in parallel. We only actually spawn a thread after we've
- // acquired a token to perform some work
- //
- // * Finally though we want to keep the dependencies of this crate
- // pretty light, so we avoid using a safe abstraction like `rayon` and
- // instead rely on some bits of `unsafe` code. We know that this stack
- // frame persists while everything is compiling so we use all the
- // stack-allocated objects without cloning/reallocating. We use a
- // transmute to `State` with a `'static` lifetime to persist
- // everything we need across the boundary, and the join-on-drop
- // semantics of `JoinOnDrop` should ensure that our stack frame is
- // alive while threads are alive.
- //
- // With all that in mind we compile all objects in a loop here, after we
- // acquire the appropriate tokens, Once all objects have been compiled
- // we join on all the threads and propagate the results of compilation.
- //
- // Note that as a slight optimization we try to break out as soon as
- // possible as soon as any compilation fails to ensure that errors get
- // out to the user as fast as possible.
- let error = AtomicBool::new(false);
- let mut threads = Vec::new();
- for obj in objs {
- if error.load(SeqCst) {
- break;
- }
- let token = server.acquire()?;
- let state = State {
- build: self,
- obj,
- error: &error,
- };
- let state = unsafe { std::mem::transmute::<State, State<'static>>(state) };
- let thread = thread::spawn(|| {
- let state: State<'me> = state; // erase the `'static` lifetime
- let result = state.build.compile_object(state.obj);
- if result.is_err() {
- state.error.store(true, SeqCst);
- }
- drop(token); // make sure our jobserver token is released after the compile
- return result;
- });
- threads.push(JoinOnDrop(Some(thread)));
- }
-
- for mut thread in threads {
- if let Some(thread) = thread.0.take() {
- thread.join().expect("thread should not panic")?;
- }
- }
-
- // Reacquire our process's token before we proceed, which we released
- // before entering the loop above.
- if reacquire {
- server.acquire_raw()?;
- }
-
- return Ok(());
-
- /// Shared state from the parent thread to the child thread. This
- /// package of pointers is temporarily transmuted to a `'static`
- /// lifetime to cross the thread boundary and then once the thread is
- /// running we erase the `'static` to go back to an anonymous lifetime.
- struct State<'a> {
- build: &'a Build,
- obj: &'a Object,
- error: &'a AtomicBool,
- }
-
- /// Returns a suitable `jobserver::Client` used to coordinate
- /// parallelism between build scripts.
- fn jobserver() -> &'static jobserver::Client {
- static INIT: Once = Once::new();
- static mut JOBSERVER: Option<jobserver::Client> = None;
-
- fn _assert_sync<T: Sync>() {}
- _assert_sync::<jobserver::Client>();
-
- unsafe {
- INIT.call_once(|| {
- let server = default_jobserver();
- JOBSERVER = Some(server);
- });
- JOBSERVER.as_ref().unwrap()
- }
- }
-
- unsafe fn default_jobserver() -> jobserver::Client {
- // Try to use the environmental jobserver which Cargo typically
- // initializes for us...
- if let Some(client) = jobserver::Client::from_env() {
- return client;
- }
-
- // ... but if that fails for whatever reason fall back to the number
- // of cpus on the system or the `NUM_JOBS` env var.
- let mut parallelism = num_cpus::get();
- if let Ok(amt) = env::var("NUM_JOBS") {
- if let Ok(amt) = amt.parse() {
- parallelism = amt;
- }
- }
-
- // If we create our own jobserver then be sure to reserve one token
- // for ourselves.
- let client = jobserver::Client::new(parallelism).expect("failed to create jobserver");
- client.acquire_raw().expect("failed to acquire initial");
- return client;
- }
-
- struct JoinOnDrop(Option<thread::JoinHandle<Result<(), Error>>>);
-
- impl Drop for JoinOnDrop {
- fn drop(&mut self) {
- if let Some(thread) = self.0.take() {
- drop(thread.join());
- }
- }
- }
- }
-
- #[cfg(not(feature = "parallel"))]
- fn compile_objects(&self, objs: &[Object]) -> Result<(), Error> {
- for obj in objs {
- self.compile_object(obj)?;
- }
- Ok(())
- }
-
- fn compile_object(&self, obj: &Object) -> Result<(), Error> {
- let is_asm = obj.src.extension().and_then(|s| s.to_str()) == Some("asm");
- let target = self.get_target()?;
- let msvc = target.contains("msvc");
- let (mut cmd, name) = if msvc && is_asm {
- self.msvc_macro_assembler()?
- } else {
- 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,
- compiler
- .path
- .file_name()
- .ok_or_else(|| Error::new(ErrorKind::IOError, "Failed to get compiler path."))?
- .to_string_lossy()
- .into_owned(),
- )
- };
- let is_arm = target.contains("aarch64") || target.contains("arm");
- command_add_output_file(&mut cmd, &obj.dst, self.cuda, msvc, is_asm, is_arm);
- // armasm and armasm64 don't requrie -c option
- if !msvc || !is_asm || !is_arm {
- cmd.arg("-c");
- }
- cmd.arg(&obj.src);
-
- run(&mut cmd, &name)?;
- Ok(())
- }
-
- /// This will return a result instead of panicing; see expand() for the complete description.
- pub fn try_expand(&self) -> Result<Vec<u8>, 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("-E");
-
- 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()
- .ok_or_else(|| Error::new(ErrorKind::IOError, "Failed to get compiler path."))?
- .to_string_lossy()
- .into_owned();
-
- 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 = cc::Build::new().file("src/foo.c").expand();
- /// ```
- pub fn expand(&self) -> Vec<u8> {
- match self.try_expand() {
- Err(e) => fail(&e.message),
- Ok(v) => v,
- }
- }
-
- /// Get the compiler that's in use for this configuration.
- ///
- /// This function will return a `Tool` which represents the culmination
- /// of this configuration at a snapshot in time. The returned compiler can
- /// be inspected (e.g. the path, arguments, environment) to forward along to
- /// other tools, or the `to_command` method can be used to invoke the
- /// compiler itself.
- ///
- /// This method will take into account all configuration such as debug
- /// information, optimization level, include directories, defines, etc.
- /// Additionally, the compiler binary in use follows the standard
- /// 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 {
- match self.try_get_compiler() {
- Ok(tool) => tool,
- Err(e) => fail(&e.message),
- }
- }
-
- /// 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<Tool, Error> {
- let opt_level = self.get_opt_level()?;
- let target = self.get_target()?;
-
- let mut cmd = self.get_base_compiler()?;
- let envflags = self.envflags(if self.cpp { "CXXFLAGS" } else { "CFLAGS" });
-
- // Disable default flag generation via `no_default_flags` or environment variable
- let no_defaults = self.no_default_flags || self.getenv("CRATE_CC_NO_DEFAULTS").is_some();
-
- if !no_defaults {
- self.add_default_flags(&mut cmd, &target, &opt_level)?;
- } else {
- println!("Info: default compiler flags are disabled");
- }
-
- for arg in envflags {
- cmd.push_cc_arg(arg.into());
- }
-
- for directory in self.include_directories.iter() {
- cmd.args.push("-I".into());
- cmd.args.push(directory.into());
- }
-
- // If warnings and/or extra_warnings haven't been explicitly set,
- // then we set them only if the environment doesn't already have
- // CFLAGS/CXXFLAGS, since those variables presumably already contain
- // the desired set of warnings flags.
-
- if self
- .warnings
- .unwrap_or(if self.has_flags() { false } else { true })
- {
- let wflags = cmd.family.warnings_flags().into();
- cmd.push_cc_arg(wflags);
- }
-
- if self
- .extra_warnings
- .unwrap_or(if self.has_flags() { false } else { true })
- {
- if let Some(wflags) = cmd.family.extra_warnings_flags() {
- cmd.push_cc_arg(wflags.into());
- }
- }
-
- for flag in self.flags.iter() {
- cmd.args.push(flag.into());
- }
-
- for flag in self.flags_supported.iter() {
- if self.is_flag_supported(flag).unwrap_or(false) {
- cmd.push_cc_arg(flag.into());
- }
- }
-
- for &(ref key, ref value) in self.definitions.iter() {
- if let Some(ref value) = *value {
- cmd.args.push(format!("-D{}={}", key, value).into());
- } else {
- cmd.args.push(format!("-D{}", key).into());
- }
- }
-
- if self.warnings_into_errors {
- let warnings_to_errors_flag = cmd.family.warnings_to_errors_flag().into();
- cmd.push_cc_arg(warnings_to_errors_flag);
- }
-
- Ok(cmd)
- }
-
- fn add_default_flags(
- &self,
- cmd: &mut Tool,
- target: &str,
- opt_level: &str,
- ) -> Result<(), Error> {
- // Non-target flags
- // If the flag is not conditioned on target variable, it belongs here :)
- match cmd.family {
- ToolFamily::Msvc { .. } => {
- cmd.push_cc_arg("-nologo".into());
-
- let crt_flag = match self.static_crt {
- Some(true) => "-MT",
- Some(false) => "-MD",
- None => {
- let features = self
- .getenv("CARGO_CFG_TARGET_FEATURE")
- .unwrap_or(String::new());
- if features.contains("crt-static") {
- "-MT"
- } else {
- "-MD"
- }
- }
- };
- cmd.push_cc_arg(crt_flag.into());
-
- match &opt_level[..] {
- // Msvc uses /O1 to enable all optimizations that minimize code size.
- "z" | "s" | "1" => cmd.push_opt_unless_duplicate("-O1".into()),
- // -O3 is a valid value for gcc and clang compilers, but not msvc. Cap to /O2.
- "2" | "3" => cmd.push_opt_unless_duplicate("-O2".into()),
- _ => {}
- }
- }
- ToolFamily::Gnu | ToolFamily::Clang => {
- // arm-linux-androideabi-gcc 4.8 shipped with Android NDK does
- // not support '-Oz'
- if opt_level == "z" && cmd.family != ToolFamily::Clang {
- cmd.push_opt_unless_duplicate("-Os".into());
- } else {
- cmd.push_opt_unless_duplicate(format!("-O{}", opt_level).into());
- }
-
- if !target.contains("-ios") {
- cmd.push_cc_arg("-ffunction-sections".into());
- cmd.push_cc_arg("-fdata-sections".into());
- }
- // Disable generation of PIC on RISC-V for now: rust-lld doesn't support this yet
- if self
- .pic
- .unwrap_or(!target.contains("windows-gnu") && !target.contains("riscv"))
- {
- cmd.push_cc_arg("-fPIC".into());
- // PLT only applies if code is compiled with PIC support,
- // and only for ELF targets.
- if target.contains("linux") && !self.use_plt.unwrap_or(true) {
- cmd.push_cc_arg("-fno-plt".into());
- }
- }
- }
- }
-
- if self.get_debug() {
- if self.cuda {
- // NVCC debug flag
- cmd.args.push("-G".into());
- }
- let family = cmd.family;
- family.add_debug_flags(cmd);
- }
-
- if self.get_force_frame_pointer() {
- let family = cmd.family;
- family.add_force_frame_pointer(cmd);
- }
-
- // Target flags
- match cmd.family {
- ToolFamily::Clang => {
- cmd.args.push(format!("--target={}", target).into());
- }
- ToolFamily::Msvc { clang_cl } => {
- // This is an undocumented flag from MSVC but helps with making
- // builds more reproducible by avoiding putting timestamps into
- // files.
- cmd.args.push("-Brepro".into());
-
- if clang_cl {
- if target.contains("x86_64") {
- cmd.args.push("-m64".into());
- } else if target.contains("86") {
- cmd.args.push("-m32".into());
- cmd.push_cc_arg("-arch:IA32".into());
- } else {
- cmd.push_cc_arg(format!("--target={}", target).into());
- }
- } else {
- if target.contains("i586") {
- cmd.push_cc_arg("-arch:IA32".into());
- }
- }
-
- // There is a check in corecrt.h that will generate a
- // compilation error if
- // _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE is
- // not defined to 1. The check was added in Windows
- // 8 days because only store apps were allowed on ARM.
- // This changed with the release of Windows 10 IoT Core.
- // The check will be going away in future versions of
- // the SDK, but for all released versions of the
- // Windows SDK it is required.
- if target.contains("arm") || target.contains("thumb") {
- cmd.args
- .push("-D_ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE=1".into());
- }
- }
- ToolFamily::Gnu => {
- if target.contains("i686") || target.contains("i586") {
- cmd.args.push("-m32".into());
- } else if target == "x86_64-unknown-linux-gnux32" {
- cmd.args.push("-mx32".into());
- } else if target.contains("x86_64") || target.contains("powerpc64") {
- cmd.args.push("-m64".into());
- }
-
- if self.static_flag.is_none() {
- let features = self
- .getenv("CARGO_CFG_TARGET_FEATURE")
- .unwrap_or(String::new());
- if features.contains("crt-static") {
- cmd.args.push("-static".into());
- }
- }
-
- // armv7 targets get to use armv7 instructions
- if (target.starts_with("armv7") || target.starts_with("thumbv7"))
- && target.contains("-linux-")
- {
- cmd.args.push("-march=armv7-a".into());
- }
-
- // (x86 Android doesn't say "eabi")
- if target.contains("-androideabi") && target.contains("v7") {
- // -march=armv7-a handled above
- cmd.args.push("-mthumb".into());
- if !target.contains("neon") {
- // On android we can guarantee some extra float instructions
- // (specified in the android spec online)
- // NEON guarantees even more; see below.
- cmd.args.push("-mfpu=vfpv3-d16".into());
- }
- cmd.args.push("-mfloat-abi=softfp".into());
- }
-
- if target.contains("neon") {
- cmd.args.push("-mfpu=neon-vfpv4".into());
- }
-
- if target.starts_with("armv4t-unknown-linux-") {
- cmd.args.push("-march=armv4t".into());
- cmd.args.push("-marm".into());
- cmd.args.push("-mfloat-abi=soft".into());
- }
-
- if target.starts_with("armv5te-unknown-linux-") {
- cmd.args.push("-march=armv5te".into());
- cmd.args.push("-marm".into());
- cmd.args.push("-mfloat-abi=soft".into());
- }
-
- // For us arm == armv6 by default
- if target.starts_with("arm-unknown-linux-") {
- cmd.args.push("-march=armv6".into());
- cmd.args.push("-marm".into());
- if target.ends_with("hf") {
- cmd.args.push("-mfpu=vfp".into());
- } else {
- cmd.args.push("-mfloat-abi=soft".into());
- }
- }
-
- // We can guarantee some settings for FRC
- if target.starts_with("arm-frc-") {
- cmd.args.push("-march=armv7-a".into());
- cmd.args.push("-mcpu=cortex-a9".into());
- cmd.args.push("-mfpu=vfpv3".into());
- cmd.args.push("-mfloat-abi=softfp".into());
- cmd.args.push("-marm".into());
- }
-
- // Turn codegen down on i586 to avoid some instructions.
- if target.starts_with("i586-unknown-linux-") {
- cmd.args.push("-march=pentium".into());
- }
-
- // Set codegen level for i686 correctly
- if target.starts_with("i686-unknown-linux-") {
- cmd.args.push("-march=i686".into());
- }
-
- // Looks like `musl-gcc` makes is hard for `-m32` to make its way
- // all the way to the linker, so we need to actually instruct the
- // linker that we're generating 32-bit executables as well. This'll
- // typically only be used for build scripts which transitively use
- // these flags that try to compile executables.
- if target == "i686-unknown-linux-musl" || target == "i586-unknown-linux-musl" {
- cmd.args.push("-Wl,-melf_i386".into());
- }
-
- if target.starts_with("thumb") {
- cmd.args.push("-mthumb".into());
-
- if target.ends_with("eabihf") {
- cmd.args.push("-mfloat-abi=hard".into())
- }
- }
- if target.starts_with("thumbv6m") {
- cmd.args.push("-march=armv6s-m".into());
- }
- if target.starts_with("thumbv7em") {
- cmd.args.push("-march=armv7e-m".into());
-
- if target.ends_with("eabihf") {
- cmd.args.push("-mfpu=fpv4-sp-d16".into())
- }
- }
- if target.starts_with("thumbv7m") {
- cmd.args.push("-march=armv7-m".into());
- }
- if target.starts_with("thumbv8m.base") {
- cmd.args.push("-march=armv8-m.base".into());
- }
- if target.starts_with("thumbv8m.main") {
- cmd.args.push("-march=armv8-m.main".into());
-
- if target.ends_with("eabihf") {
- cmd.args.push("-mfpu=fpv5-sp-d16".into())
- }
- }
- if target.starts_with("armebv7r") | target.starts_with("armv7r") {
- if target.starts_with("armeb") {
- cmd.args.push("-mbig-endian".into());
- } else {
- cmd.args.push("-mlittle-endian".into());
- }
-
- // ARM mode
- cmd.args.push("-marm".into());
-
- // R Profile
- cmd.args.push("-march=armv7-r".into());
-
- if target.ends_with("eabihf") {
- // Calling convention
- cmd.args.push("-mfloat-abi=hard".into());
-
- // lowest common denominator FPU
- // (see Cortex-R4 technical reference manual)
- cmd.args.push("-mfpu=vfpv3-d16".into())
- } else {
- // Calling convention
- cmd.args.push("-mfloat-abi=soft".into());
- }
- }
- if target.starts_with("riscv32") || target.starts_with("riscv64") {
- // get the 32i/32imac/32imc/64gc/64imac/... part
- let mut parts = target.split('-');
- if let Some(arch) = parts.next() {
- let arch = &arch[5..];
- cmd.args.push(("-march=rv".to_owned() + arch).into());
- if target.contains("linux") && arch.starts_with("64") {
- cmd.args.push("-mabi=lp64d".into());
- } else if target.contains("linux") && arch.starts_with("32") {
- cmd.args.push("-mabi=ilp32d".into());
- } else if arch.starts_with("64") {
- cmd.args.push("-mabi=lp64".into());
- } else {
- cmd.args.push("-mabi=ilp32".into());
- }
- }
- }
- }
- }
-
- if target.contains("-ios") {
- // FIXME: potential bug. iOS is always compiled with Clang, but Gcc compiler may be
- // detected instead.
- self.ios_flags(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 {
- match (self.cpp_set_stdlib.as_ref(), cmd.family) {
- (None, _) => {}
- (Some(stdlib), ToolFamily::Gnu) | (Some(stdlib), ToolFamily::Clang) => {
- cmd.push_cc_arg(format!("-stdlib=lib{}", stdlib).into());
- }
- _ => {
- println!(
- "cargo:warning=cpp_set_stdlib is specified, but the {:?} compiler \
- does not support this option, ignored",
- cmd.family
- );
- }
- }
- }
-
- Ok(())
- }
-
- fn has_flags(&self) -> bool {
- let flags_env_var_name = if self.cpp { "CXXFLAGS" } else { "CFLAGS" };
- let flags_env_var_value = self.get_var(flags_env_var_name);
- if let Ok(_) = flags_env_var_value {
- true
- } else {
- false
- }
- }
-
- fn msvc_macro_assembler(&self) -> Result<(Command, String), Error> {
- let target = self.get_target()?;
- let tool = if target.contains("x86_64") {
- "ml64.exe"
- } else if target.contains("arm") {
- "armasm.exe"
- } else if target.contains("aarch64") {
- "armasm64.exe"
- } else {
- "ml.exe"
- };
- let mut cmd = windows_registry::find(&target, tool).unwrap_or_else(|| self.cmd(tool));
- for directory in self.include_directories.iter() {
- cmd.arg("-I").arg(directory);
- }
- for &(ref key, ref value) in self.definitions.iter() {
- if let Some(ref value) = *value {
- cmd.arg(&format!("-D{}={}", key, value));
- } else {
- cmd.arg(&format!("-D{}", key));
- }
- }
-
- if target.contains("i686") || target.contains("i586") {
- cmd.arg("-safeseh");
- }
- for flag in self.flags.iter() {
- cmd.arg(flag);
- }
-
- Ok((cmd, tool.to_string()))
- }
-
- fn assemble(&self, lib_name: &str, dst: &Path, objs: &[Object]) -> 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 objects: Vec<_> = objs.iter().map(|obj| obj.dst.clone()).collect();
- let target = self.get_target()?;
- if target.contains("msvc") {
- let (mut cmd, program) = self.get_ar()?;
- let mut out = OsString::from("-out:");
- out.push(dst);
- cmd.arg(out).arg("-nologo");
- for flag in self.ar_flags.iter() {
- cmd.arg(flag);
- }
-
- // Similar to https://github.com/rust-lang/rust/pull/47507
- // and https://github.com/rust-lang/rust/pull/48548
- let estimated_command_line_len = objects
- .iter()
- .chain(&self.objects)
- .map(|a| a.as_os_str().len())
- .sum::<usize>();
- if estimated_command_line_len > 1024 * 6 {
- let mut args = String::from("\u{FEFF}"); // BOM
- for arg in objects.iter().chain(&self.objects) {
- args.push('"');
- for c in arg.to_str().unwrap().chars() {
- if c == '"' {
- args.push('\\')
- }
- args.push(c)
- }
- args.push('"');
- args.push('\n');
- }
-
- let mut utf16le = Vec::new();
- for code_unit in args.encode_utf16() {
- utf16le.push(code_unit as u8);
- utf16le.push((code_unit >> 8) as u8);
- }
-
- let mut args_file = OsString::from(dst);
- args_file.push(".args");
- fs::File::create(&args_file)
- .unwrap()
- .write_all(&utf16le)
- .unwrap();
-
- let mut args_file_arg = OsString::from("@");
- args_file_arg.push(args_file);
- cmd.arg(args_file_arg);
- } else {
- cmd.args(&objects).args(&self.objects);
- }
- run(&mut cmd, &program)?;
-
- // 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);
- 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(|_| ())
- }) {
- Ok(_) => (),
- Err(_) => {
- return Err(Error::new(
- ErrorKind::IOError,
- "Could not copy or create a hard-link to the generated lib file.",
- ));
- }
- };
- } else {
- let (mut ar, cmd) = self.get_ar()?;
-
- // Set an environment variable to tell the OSX archiver to ensure
- // that all dates listed in the archive are zero, improving
- // determinism of builds. AFAIK there's not really official
- // documentation of this but there's a lot of references to it if
- // you search google.
- //
- // You can reproduce this locally on a mac with:
- //
- // $ touch foo.c
- // $ cc -c foo.c -o foo.o
- //
- // # Notice that these two checksums are different
- // $ ar crus libfoo1.a foo.o && sleep 2 && ar crus libfoo2.a foo.o
- // $ md5sum libfoo*.a
- //
- // # Notice that these two checksums are the same
- // $ export ZERO_AR_DATE=1
- // $ ar crus libfoo1.a foo.o && sleep 2 && touch foo.o && ar crus libfoo2.a foo.o
- // $ md5sum libfoo*.a
- //
- // In any case if this doesn't end up getting read, it shouldn't
- // cause that many issues!
- ar.env("ZERO_AR_DATE", "1");
- for flag in self.ar_flags.iter() {
- ar.arg(flag);
- }
- run(
- ar.arg("crs").arg(dst).args(&objects).args(&self.objects),
- &cmd,
- )?;
- }
-
- Ok(())
- }
-
- 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).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"),
- _ => {
- return Err(Error::new(
- ErrorKind::ArchitectureInvalid,
- "Unknown architecture for iOS target.",
- ));
- }
- };
-
- let min_version =
- std::env::var("IPHONEOS_DEPLOYMENT_TARGET").unwrap_or_else(|_| "7.0".into());
-
- let sdk = match arch {
- ArchSpec::Device(arch) => {
- cmd.args.push("-arch".into());
- cmd.args.push(arch.into());
- cmd.args
- .push(format!("-miphoneos-version-min={}", min_version).into());
- "iphoneos"
- }
- ArchSpec::Simulator(arch) => {
- cmd.args.push(arch.into());
- cmd.args
- .push(format!("-mios-simulator-version-min={}", min_version).into());
- "iphonesimulator"
- }
- };
-
- self.print(&format!("Detecting iOS SDK path for {}", sdk));
- let sdk_path = self
- .cmd("xcrun")
- .arg("--show-sdk-path")
- .arg("--sdk")
- .arg(sdk)
- .stderr(Stdio::inherit())
- .output()?
- .stdout;
-
- 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());
- cmd.args.push("-fembed-bitcode".into());
- /*
- * TODO we probably ultimatedly want the -fembed-bitcode-marker flag
- * but can't have it now because of an issue in LLVM:
- * https://github.com/alexcrichton/cc-rs/issues/301
- * https://github.com/rust-lang/rust/pull/48896#comment-372192660
- */
- /*
- if self.get_opt_level()? == "0" {
- cmd.args.push("-fembed-bitcode-marker".into());
- }
- */
-
- Ok(())
- }
-
- fn cmd<P: AsRef<OsStr>>(&self, prog: P) -> Command {
- let mut cmd = Command::new(prog);
- for &(ref a, ref b) in self.env.iter() {
- cmd.env(a, b);
- }
- cmd
- }
-
- fn get_base_compiler(&self) -> Result<Tool, Error> {
- if let Some(ref c) = self.compiler {
- return Ok(Tool::new(c.clone()));
- }
- let host = self.get_host()?;
- let target = self.get_target()?;
- let (env, msvc, gnu, traditional, clang) = if self.cpp {
- ("CXX", "cl.exe", "g++", "c++", "clang++")
- } else {
- ("CC", "cl.exe", "gcc", "cc", "clang")
- };
-
- // On Solaris, c++/cc unlikely to exist or be correct.
- let default = if host.contains("solaris") {
- gnu
- } else {
- traditional
- };
-
- let cl_exe = windows_registry::find_tool(&target, "cl.exe");
-
- let tool_opt: Option<Tool> = self
- .env_tool(env)
- .map(|(tool, wrapper, args)| {
- // find the driver mode, if any
- const DRIVER_MODE: &str = "--driver-mode=";
- let driver_mode = args
- .iter()
- .find(|a| a.starts_with(DRIVER_MODE))
- .map(|a| &a[DRIVER_MODE.len()..]);
- // chop off leading/trailing whitespace to work around
- // semi-buggy build scripts which are shared in
- // makefiles/configure scripts (where spaces are far more
- // lenient)
- let mut t = Tool::with_clang_driver(PathBuf::from(tool.trim()), driver_mode);
- if let Some(cc) = wrapper {
- t.cc_wrapper_path = Some(PathBuf::from(cc));
- }
- for arg in args {
- t.cc_wrapper_args.push(arg.into());
- }
- t
- })
- .or_else(|| {
- if target.contains("emscripten") {
- let tool = if self.cpp { "em++" } else { "emcc" };
- // 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(|| cl_exe.clone());
-
- 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()
- } else {
- format!("{}.exe", gnu)
- }
- } else if target.contains("android") {
- let target = target
- .replace("armv7neon", "arm")
- .replace("armv7", "arm")
- .replace("thumbv7neon", "arm")
- .replace("thumbv7", "arm");
- let gnu_compiler = format!("{}-{}", target, gnu);
- let clang_compiler = format!("{}-{}", target, clang);
- // Check if gnu compiler is present
- // if not, use clang
- if Command::new(&gnu_compiler).spawn().is_ok() {
- gnu_compiler
- } else {
- clang_compiler
- }
- } else if target.contains("cloudabi") {
- format!("{}-{}", target, traditional)
- } else if target == "wasm32-wasi"
- || target == "wasm32-unknown-wasi"
- || target == "wasm32-unknown-unknown"
- {
- "clang".to_string()
- } else if target.contains("vxworks") {
- "wr-c++".to_string()
- } 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('-'));
- let prefix = cross_compile.or(match &target[..] {
- "aarch64-unknown-linux-gnu" => Some("aarch64-linux-gnu"),
- "aarch64-unknown-linux-musl" => Some("aarch64-linux-musl"),
- "aarch64-unknown-netbsd" => Some("aarch64--netbsd"),
- "arm-unknown-linux-gnueabi" => Some("arm-linux-gnueabi"),
- "armv4t-unknown-linux-gnueabi" => Some("arm-linux-gnueabi"),
- "armv5te-unknown-linux-gnueabi" => Some("arm-linux-gnueabi"),
- "arm-frc-linux-gnueabi" => Some("arm-frc-linux-gnueabi"),
- "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-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"),
- "armv7neon-unknown-linux-gnueabihf" => Some("arm-linux-gnueabihf"),
- "armv7neon-unknown-linux-musleabihf" => Some("arm-linux-musleabihf"),
- "thumbv7-unknown-linux-gnueabihf" => Some("arm-linux-gnueabihf"),
- "thumbv7-unknown-linux-musleabihf" => Some("arm-linux-musleabihf"),
- "thumbv7neon-unknown-linux-gnueabihf" => Some("arm-linux-gnueabihf"),
- "thumbv7neon-unknown-linux-musleabihf" => Some("arm-linux-musleabihf"),
- "armv7-unknown-netbsd-eabihf" => Some("armv7--netbsdelf-eabihf"),
- "i586-unknown-linux-musl" => Some("musl"),
- "i686-pc-windows-gnu" => Some("i686-w64-mingw32"),
- "i686-uwp-windows-gnu" => Some("i686-w64-mingw32"),
- "i686-unknown-linux-musl" => Some("musl"),
- "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"),
- "mips64el-unknown-linux-gnuabi64" => Some("mips64el-linux-gnuabi64"),
- "mipsisa32r6-unknown-linux-gnu" => Some("mipsisa32r6-linux-gnu"),
- "mipsisa32r6el-unknown-linux-gnu" => Some("mipsisa32r6el-linux-gnu"),
- "mipsisa64r6-unknown-linux-gnuabi64" => Some("mipsisa64r6-linux-gnuabi64"),
- "mipsisa64r6el-unknown-linux-gnuabi64" => {
- Some("mipsisa64r6el-linux-gnuabi64")
- }
- "powerpc-unknown-linux-gnu" => Some("powerpc-linux-gnu"),
- "powerpc-unknown-linux-gnuspe" => Some("powerpc-linux-gnuspe"),
- "powerpc-unknown-netbsd" => Some("powerpc--netbsd"),
- "powerpc64-unknown-linux-gnu" => Some("powerpc-linux-gnu"),
- "powerpc64le-unknown-linux-gnu" => Some("powerpc64le-linux-gnu"),
- "riscv32i-unknown-none-elf" => Some("riscv32-unknown-elf"),
- "riscv32imac-unknown-none-elf" => Some("riscv32-unknown-elf"),
- "riscv32imc-unknown-none-elf" => Some("riscv32-unknown-elf"),
- "riscv64gc-unknown-none-elf" => Some("riscv64-unknown-elf"),
- "riscv64imac-unknown-none-elf" => Some("riscv64-unknown-elf"),
- "s390x-unknown-linux-gnu" => Some("s390x-linux-gnu"),
- "sparc-unknown-linux-gnu" => Some("sparc-linux-gnu"),
- "sparc64-unknown-linux-gnu" => Some("sparc64-linux-gnu"),
- "sparc64-unknown-netbsd" => Some("sparc64--netbsd"),
- "sparcv9-sun-solaris" => Some("sparcv9-sun-solaris"),
- "armebv7r-none-eabi" => Some("arm-none-eabi"),
- "armebv7r-none-eabihf" => Some("arm-none-eabi"),
- "armv7r-none-eabi" => Some("arm-none-eabi"),
- "armv7r-none-eabihf" => Some("arm-none-eabi"),
- "thumbv6m-none-eabi" => Some("arm-none-eabi"),
- "thumbv7em-none-eabi" => Some("arm-none-eabi"),
- "thumbv7em-none-eabihf" => Some("arm-none-eabi"),
- "thumbv7m-none-eabi" => Some("arm-none-eabi"),
- "thumbv8m.base-none-eabi" => Some("arm-none-eabi"),
- "thumbv8m.main-none-eabi" => Some("arm-none-eabi"),
- "thumbv8m.main-none-eabihf" => Some("arm-none-eabi"),
- "x86_64-pc-windows-gnu" => Some("x86_64-w64-mingw32"),
- "x86_64-uwp-windows-gnu" => Some("x86_64-w64-mingw32"),
- "x86_64-rumprun-netbsd" => Some("x86_64-rumprun-netbsd"),
- "x86_64-unknown-linux-musl" => Some("musl"),
- "x86_64-unknown-netbsd" => Some("x86_64--netbsd"),
- _ => None,
- });
- match prefix {
- Some(prefix) => format!("{}-{}", prefix, gnu),
- None => default.to_string(),
- }
- } else {
- default.to_string()
- };
- Tool::new(PathBuf::from(compiler))
- }
- };
-
- let mut tool = if self.cuda {
- assert!(
- tool.args.is_empty(),
- "CUDA compilation currently assumes empty pre-existing args"
- );
- let nvcc = match self.get_var("NVCC") {
- Err(_) => "nvcc".into(),
- Ok(nvcc) => nvcc,
- };
- let mut nvcc_tool = Tool::with_features(PathBuf::from(nvcc), None, self.cuda);
- nvcc_tool
- .args
- .push(format!("-ccbin={}", tool.path.display()).into());
- nvcc_tool.family = tool.family;
- nvcc_tool
- } else {
- tool
- };
-
- // If we found `cl.exe` in our environment, the tool we're returning is
- // an MSVC-like tool, *and* no env vars were set then set env vars for
- // the tool that we're returning.
- //
- // Env vars are needed for things like `link.exe` being put into PATH as
- // well as header include paths sometimes. These paths are automatically
- // included by default but if the `CC` or `CXX` env vars are set these
- // won't be used. This'll ensure that when the env vars are used to
- // configure for invocations like `clang-cl` we still get a "works out
- // of the box" experience.
- if let Some(cl_exe) = cl_exe {
- if tool.family == (ToolFamily::Msvc { clang_cl: true })
- && tool.env.len() == 0
- && target.contains("msvc")
- {
- for &(ref k, ref v) in cl_exe.env.iter() {
- tool.env.push((k.to_owned(), v.to_owned()));
- }
- }
- }
-
- Ok(tool)
- }
-
- fn get_var(&self, var_base: &str) -> Result<String, Error> {
- 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))
- .or_else(|| self.getenv(&format!("{}_{}", var_base, target_u)))
- .or_else(|| self.getenv(&format!("{}_{}", kind, var_base)))
- .or_else(|| self.getenv(var_base));
-
- match res {
- Some(res) => Ok(res),
- None => Err(Error::new(
- ErrorKind::EnvVarNotFound,
- &format!("Could not find environment variable {}.", var_base),
- )),
- }
- }
-
- fn envflags(&self, name: &str) -> Vec<String> {
- self.get_var(name)
- .unwrap_or(String::new())
- .split(|c: char| c.is_whitespace())
- .filter(|s| !s.is_empty())
- .map(|s| s.to_string())
- .collect()
- }
-
- /// Returns compiler path, optional modifier name from whitelist, and arguments vec
- fn env_tool(&self, name: &str) -> Option<(String, Option<String>, Vec<String>)> {
- let tool = match self.get_var(name) {
- Ok(tool) => tool,
- Err(_) => return None,
- };
-
- // If this is an exact path on the filesystem we don't want to do any
- // interpretation at all, just pass it on through. This'll hopefully get
- // us to support spaces-in-paths.
- if Path::new(&tool).exists() {
- return Some((tool, None, Vec::new()));
- }
-
- // Ok now we want to handle a couple of scenarios. We'll assume from
- // here on out that spaces are splitting separate arguments. Two major
- // features we want to support are:
- //
- // CC='sccache cc'
- //
- // aka using `sccache` or any other wrapper/caching-like-thing for
- // compilations. We want to know what the actual compiler is still,
- // though, because our `Tool` API support introspection of it to see
- // what compiler is in use.
- //
- // additionally we want to support
- //
- // CC='cc -flag'
- //
- // where the CC env var is used to also pass default flags to the C
- // compiler.
- //
- // It's true that everything here is a bit of a pain, but apparently if
- // you're not literally make or bash then you get a lot of bug reports.
- let known_wrappers = ["ccache", "distcc", "sccache", "icecc"];
-
- let mut parts = tool.split_whitespace();
- let maybe_wrapper = match parts.next() {
- Some(s) => s,
- None => return None,
- };
-
- let file_stem = Path::new(maybe_wrapper)
- .file_stem()
- .unwrap()
- .to_str()
- .unwrap();
- if known_wrappers.contains(&file_stem) {
- if let Some(compiler) = parts.next() {
- return Some((
- compiler.to_string(),
- Some(maybe_wrapper.to_string()),
- parts.map(|s| s.to_string()).collect(),
- ));
- }
- }
-
- Some((
- maybe_wrapper.to_string(),
- None,
- parts.map(|s| s.to_string()).collect(),
- ))
- }
-
- /// 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) -> Result<Option<String>, Error> {
- match self.cpp_link_stdlib.clone() {
- Some(s) => Ok(s),
- None => {
- if let Ok(stdlib) = self.get_var("CXXSTDLIB") {
- if stdlib.is_empty() {
- Ok(None)
- } else {
- Ok(Some(stdlib))
- }
- } else {
- let target = self.get_target()?;
- if target.contains("msvc") {
- Ok(None)
- } else if target.contains("apple") {
- Ok(Some("c++".to_string()))
- } else if target.contains("freebsd") {
- Ok(Some("c++".to_string()))
- } else if target.contains("openbsd") {
- Ok(Some("c++".to_string()))
- } else {
- Ok(Some("stdc++".to_string()))
- }
- }
- }
- }
- }
-
- fn get_ar(&self) -> Result<(Command, String), Error> {
- if let Some(ref p) = self.archiver {
- let name = p.file_name().and_then(|s| s.to_str()).unwrap_or("ar");
- return Ok((self.cmd(p), name.to_string()));
- }
- if let Ok(p) = self.get_var("AR") {
- return Ok((self.cmd(&p), p));
- }
- let target = self.get_target()?;
- let program = if target.contains("android") {
- format!("{}-ar", target.replace("armv7", "arm"))
- } else if target.contains("emscripten") {
- // Windows use bat files so we have to be a bit more specific
- if cfg!(windows) {
- let mut cmd = self.cmd("cmd");
- cmd.arg("/c").arg("emar.bat");
- return Ok((cmd, "emar.bat".to_string()));
- }
-
- "emar".to_string()
- } else if target.contains("msvc") {
- match windows_registry::find(&target, "lib.exe") {
- Some(t) => return Ok((t, "lib.exe".to_string())),
- None => "lib.exe".to_string(),
- }
- } else {
- "ar".to_string()
- };
- Ok((self.cmd(&program), program))
- }
-
- fn get_target(&self) -> Result<String, Error> {
- match self.target.clone() {
- Some(t) => Ok(t),
- None => Ok(self.getenv_unwrap("TARGET")?),
- }
- }
-
- fn get_host(&self) -> Result<String, Error> {
- match self.host.clone() {
- Some(h) => Ok(h),
- None => Ok(self.getenv_unwrap("HOST")?),
- }
- }
-
- fn get_opt_level(&self) -> Result<String, Error> {
- 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(|| match self.getenv("DEBUG") {
- Some(s) => s != "false",
- None => false,
- })
- }
-
- fn get_force_frame_pointer(&self) -> bool {
- self.force_frame_pointer.unwrap_or_else(|| self.get_debug())
- }
-
- fn get_out_dir(&self) -> Result<PathBuf, Error> {
- 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<String> {
- let mut cache = self.env_cache.lock().unwrap();
- if let Some(val) = cache.get(v) {
- return val.clone();
- }
- let r = env::var(v).ok();
- self.print(&format!("{} = {:?}", v, r));
- cache.insert(v.to_string(), r.clone());
- r
- }
-
- fn getenv_unwrap(&self, v: &str) -> Result<String, Error> {
- match self.getenv(v) {
- Some(s) => Ok(s),
- None => Err(Error::new(
- ErrorKind::EnvVarNotFound,
- &format!("Environment variable {} not defined.", v.to_string()),
- )),
- }
- }
-
- fn print(&self, s: &str) {
- if self.cargo_metadata {
- println!("{}", s);
- }
- }
-}
-
-impl Default for Build {
- fn default() -> Build {
- Build::new()
- }
-}
-
-impl Tool {
- fn new(path: PathBuf) -> Self {
- Tool::with_features(path, None, false)
- }
-
- fn with_clang_driver(path: PathBuf, clang_driver: Option<&str>) -> Self {
- Self::with_features(path, clang_driver, false)
- }
-
- fn with_features(path: PathBuf, clang_driver: Option<&str>, cuda: bool) -> Self {
- // Try to detect family of the tool from its name, falling back to Gnu.
- let family = if let Some(fname) = path.file_name().and_then(|p| p.to_str()) {
- if fname.contains("clang-cl") {
- ToolFamily::Msvc { clang_cl: true }
- } else if fname.contains("cl")
- && !fname.contains("cloudabi")
- && !fname.contains("uclibc")
- && !fname.contains("clang")
- {
- ToolFamily::Msvc { clang_cl: false }
- } else if fname.contains("clang") {
- match clang_driver {
- Some("cl") => ToolFamily::Msvc { clang_cl: true },
- _ => ToolFamily::Clang,
- }
- } else {
- ToolFamily::Gnu
- }
- } else {
- ToolFamily::Gnu
- };
-
- Tool {
- path: path,
- cc_wrapper_path: None,
- cc_wrapper_args: Vec::new(),
- args: Vec::new(),
- env: Vec::new(),
- family: family,
- cuda: cuda,
- removed_args: Vec::new(),
- }
- }
-
- /// Add an argument to be stripped from the final command arguments.
- fn remove_arg(&mut self, flag: OsString) {
- self.removed_args.push(flag);
- }
-
- /// Add a flag, and optionally prepend the NVCC wrapper flag "-Xcompiler".
- ///
- /// Currently this is only used for compiling CUDA sources, since NVCC only
- /// accepts a limited set of GNU-like flags, and the rest must be prefixed
- /// with a "-Xcompiler" flag to get passed to the underlying C++ compiler.
- fn push_cc_arg(&mut self, flag: OsString) {
- if self.cuda {
- self.args.push("-Xcompiler".into());
- }
- self.args.push(flag);
- }
-
- fn is_duplicate_opt_arg(&self, flag: &OsString) -> bool {
- let flag = flag.to_str().unwrap();
- let mut chars = flag.chars();
-
- // Only duplicate check compiler flags
- if self.is_like_msvc() {
- if chars.next() != Some('/') {
- return false;
- }
- } else if self.is_like_gnu() || self.is_like_clang() {
- if chars.next() != Some('-') {
- return false;
- }
- }
-
- // Check for existing optimization flags (-O, /O)
- if chars.next() == Some('O') {
- return self
- .args()
- .iter()
- .any(|ref a| a.to_str().unwrap_or("").chars().nth(1) == Some('O'));
- }
-
- // TODO Check for existing -m..., -m...=..., /arch:... flags
- return false;
- }
-
- /// Don't push optimization arg if it conflicts with existing args
- fn push_opt_unless_duplicate(&mut self, flag: OsString) {
- if self.is_duplicate_opt_arg(&flag) {
- println!("Info: Ignoring duplicate arg {:?}", &flag);
- } else {
- self.push_cc_arg(flag);
- }
- }
-
- /// Converts this compiler into a `Command` that's ready to be run.
- ///
- /// This is useful for when the compiler needs to be executed and the
- /// command returned will already have the initial arguments and environment
- /// variables configured.
- pub fn to_command(&self) -> Command {
- let mut cmd = match self.cc_wrapper_path {
- Some(ref cc_wrapper_path) => {
- let mut cmd = Command::new(&cc_wrapper_path);
- cmd.arg(&self.path);
- cmd
- }
- None => Command::new(&self.path),
- };
- cmd.args(&self.cc_wrapper_args);
-
- let value = self
- .args
- .iter()
- .filter(|a| !self.removed_args.contains(a))
- .collect::<Vec<_>>();
- cmd.args(&value);
-
- for &(ref k, ref v) in self.env.iter() {
- cmd.env(k, v);
- }
- cmd
- }
-
- /// Returns the path for this compiler.
- ///
- /// Note that this may not be a path to a file on the filesystem, e.g. "cc",
- /// but rather something which will be resolved when a process is spawned.
- pub fn path(&self) -> &Path {
- &self.path
- }
-
- /// Returns the default set of arguments to the compiler needed to produce
- /// executables for the target this compiler generates.
- pub fn args(&self) -> &[OsString] {
- &self.args
- }
-
- /// Returns the set of environment variables needed for this compiler to
- /// operate.
- ///
- /// This is typically only used for MSVC compilers currently.
- pub fn env(&self) -> &[(OsString, OsString)] {
- &self.env
- }
-
- /// Returns the compiler command in format of CC environment variable.
- /// Or empty string if CC env was not present
- ///
- /// This is typically used by configure script
- pub fn cc_env(&self) -> OsString {
- match self.cc_wrapper_path {
- Some(ref cc_wrapper_path) => {
- let mut cc_env = cc_wrapper_path.as_os_str().to_owned();
- cc_env.push(" ");
- cc_env.push(self.path.to_path_buf().into_os_string());
- for arg in self.cc_wrapper_args.iter() {
- cc_env.push(" ");
- cc_env.push(arg);
- }
- cc_env
- }
- None => OsString::from(""),
- }
- }
-
- /// Returns the compiler flags in format of CFLAGS environment variable.
- /// Important here - this will not be CFLAGS from env, its internal gcc's flags to use as CFLAGS
- /// This is typically used by configure script
- pub fn cflags_env(&self) -> OsString {
- let mut flags = OsString::new();
- for (i, arg) in self.args.iter().enumerate() {
- if i > 0 {
- flags.push(" ");
- }
- flags.push(arg);
- }
- flags
- }
-
- /// Whether the tool is GNU Compiler Collection-like.
- pub fn is_like_gnu(&self) -> bool {
- self.family == ToolFamily::Gnu
- }
-
- /// Whether the tool is Clang-like.
- pub fn is_like_clang(&self) -> bool {
- self.family == ToolFamily::Clang
- }
-
- /// Whether the tool is MSVC-like.
- pub fn is_like_msvc(&self) -> bool {
- match self.family {
- ToolFamily::Msvc { .. } => true,
- _ => false,
- }
- }
-}
-
-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() {
- 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) -> Result<Vec<u8>, Error> {
- cmd.stdout(Stdio::piped());
- let (mut child, print) = spawn(cmd, program)?;
- let mut stdout = vec![];
- child
- .stdout
- .take()
- .unwrap()
- .read_to_end(&mut stdout)
- .unwrap();
- 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() {
- Ok(stdout)
- } else {
- Err(Error::new(
- ErrorKind::ToolExecError,
- &format!(
- "Command {:?} with args {:?} did not execute successfully (status code {}).",
- cmd, program, status
- ),
- ))
- }
-}
-
-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
- // with cargo:warning= prefixes. Note that this is a bit wonky to avoid
- // requiring the output to be UTF-8, we instead just ship bytes from one
- // location to another.
- match cmd.stderr(Stdio::piped()).spawn() {
- Ok(mut child) => {
- let stderr = BufReader::new(child.stderr.take().unwrap());
- let print = thread::spawn(move || {
- for line in stderr.split(b'\n').filter_map(|l| l.ok()) {
- print!("cargo:warning=");
- std::io::stdout().write_all(&line).unwrap();
- println!("");
- }
- });
- Ok((child, print))
- }
- Err(ref e) if e.kind() == io::ErrorKind::NotFound => {
- let extra = if cfg!(windows) {
- " (see https://github.com/alexcrichton/cc-rs#compile-time-requirements \
- for help)"
- } else {
- ""
- };
- Err(Error::new(
- ErrorKind::ToolNotFound,
- &format!("Failed to find tool. Is `{}` installed?{}", program, extra),
- ))
- }
- Err(_) => Err(Error::new(
- ErrorKind::ToolExecError,
- &format!("Command {:?} with args {:?} failed to start.", cmd, program),
- )),
- }
-}
-
-fn fail(s: &str) -> ! {
- let _ = writeln!(io::stderr(), "\n\nerror occurred: {}\n\n", s);
- std::process::exit(1);
-}
-
-fn command_add_output_file(
- cmd: &mut Command,
- dst: &Path,
- cuda: bool,
- msvc: bool,
- is_asm: bool,
- is_arm: bool,
-) {
- if msvc && !cuda && !(is_asm && is_arm) {
- let mut s = OsString::from("-Fo");
- s.push(&dst);
- cmd.arg(s);
- } else {
- cmd.arg("-o").arg(&dst);
- }
-}
diff --git a/cc/src/registry.rs b/cc/src/registry.rs
deleted file mode 100644
index 2ac2fa6..0000000
--- a/cc/src/registry.rs
+++ /dev/null
@@ -1,204 +0,0 @@
-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::ffi::{OsStr, OsString};
-use std::io;
-use std::ops::RangeFrom;
-use std::os::raw;
-use std::os::windows::prelude::*;
-
-pub struct RegistryKey(Repr);
-
-type HKEY = *mut u8;
-type DWORD = u32;
-type LPDWORD = *mut DWORD;
-type LPCWSTR = *const u16;
-type LPWSTR = *mut u16;
-type LONG = raw::c_long;
-type PHKEY = *mut HKEY;
-type PFILETIME = *mut u8;
-type LPBYTE = *mut u8;
-type REGSAM = u32;
-
-const ERROR_SUCCESS: DWORD = 0;
-const ERROR_NO_MORE_ITEMS: DWORD = 259;
-const HKEY_LOCAL_MACHINE: HKEY = 0x80000002 as HKEY;
-const REG_SZ: DWORD = 1;
-const KEY_READ: DWORD = 0x20019;
-const KEY_WOW64_32KEY: DWORD = 0x200;
-
-#[link(name = "advapi32")]
-extern "system" {
- fn RegOpenKeyExW(
- key: HKEY,
- lpSubKey: LPCWSTR,
- ulOptions: DWORD,
- samDesired: REGSAM,
- phkResult: PHKEY,
- ) -> LONG;
- fn RegEnumKeyExW(
- key: HKEY,
- dwIndex: DWORD,
- lpName: LPWSTR,
- lpcName: LPDWORD,
- lpReserved: LPDWORD,
- lpClass: LPWSTR,
- lpcClass: LPDWORD,
- lpftLastWriteTime: PFILETIME,
- ) -> LONG;
- fn RegQueryValueExW(
- hKey: HKEY,
- lpValueName: LPCWSTR,
- lpReserved: LPDWORD,
- lpType: LPDWORD,
- lpData: LPBYTE,
- lpcbData: LPDWORD,
- ) -> LONG;
- fn RegCloseKey(hKey: HKEY) -> LONG;
-}
-
-struct OwnedKey(HKEY);
-
-enum Repr {
- Const(HKEY),
- Owned(OwnedKey),
-}
-
-pub struct Iter<'a> {
- idx: RangeFrom<DWORD>,
- key: &'a RegistryKey,
-}
-
-unsafe impl Sync for Repr {}
-unsafe impl Send for Repr {}
-
-pub static LOCAL_MACHINE: RegistryKey = RegistryKey(Repr::Const(HKEY_LOCAL_MACHINE));
-
-impl RegistryKey {
- fn raw(&self) -> HKEY {
- match self.0 {
- Repr::Const(val) => val,
- Repr::Owned(ref val) => val.0,
- }
- }
-
- pub fn open(&self, key: &OsStr) -> io::Result<RegistryKey> {
- let key = key.encode_wide().chain(Some(0)).collect::<Vec<_>>();
- let mut ret = 0 as *mut _;
- let err = unsafe {
- RegOpenKeyExW(
- self.raw(),
- key.as_ptr(),
- 0,
- KEY_READ | KEY_WOW64_32KEY,
- &mut ret,
- )
- };
- if err == ERROR_SUCCESS as LONG {
- Ok(RegistryKey(Repr::Owned(OwnedKey(ret))))
- } else {
- Err(io::Error::from_raw_os_error(err as i32))
- }
- }
-
- pub fn iter(&self) -> Iter {
- Iter {
- idx: 0..,
- key: self,
- }
- }
-
- pub fn query_str(&self, name: &str) -> io::Result<OsString> {
- let name: &OsStr = name.as_ref();
- let name = name.encode_wide().chain(Some(0)).collect::<Vec<_>>();
- let mut len = 0;
- let mut kind = 0;
- unsafe {
- let err = RegQueryValueExW(
- self.raw(),
- name.as_ptr(),
- 0 as *mut _,
- &mut kind,
- 0 as *mut _,
- &mut len,
- );
- if err != ERROR_SUCCESS as LONG {
- return Err(io::Error::from_raw_os_error(err as i32));
- }
- if kind != REG_SZ {
- return Err(io::Error::new(
- io::ErrorKind::Other,
- "registry key wasn't a string",
- ));
- }
-
- // The length here is the length in bytes, but we're using wide
- // characters so we need to be sure to halve it for the capacity
- // passed in.
- let mut v = Vec::with_capacity(len as usize / 2);
- let err = RegQueryValueExW(
- self.raw(),
- name.as_ptr(),
- 0 as *mut _,
- 0 as *mut _,
- v.as_mut_ptr() as *mut _,
- &mut len,
- );
- if err != ERROR_SUCCESS as LONG {
- return Err(io::Error::from_raw_os_error(err as i32));
- }
- v.set_len(len as usize / 2);
-
- // Some registry keys may have a terminating nul character, but
- // we're not interested in that, so chop it off if it's there.
- if v[v.len() - 1] == 0 {
- v.pop();
- }
- Ok(OsString::from_wide(&v))
- }
- }
-}
-
-impl Drop for OwnedKey {
- fn drop(&mut self) {
- unsafe {
- RegCloseKey(self.0);
- }
- }
-}
-
-impl<'a> Iterator for Iter<'a> {
- type Item = io::Result<OsString>;
-
- fn next(&mut self) -> Option<io::Result<OsString>> {
- self.idx.next().and_then(|i| unsafe {
- let mut v = Vec::with_capacity(256);
- let mut len = v.capacity() as DWORD;
- let ret = RegEnumKeyExW(
- self.key.raw(),
- i,
- v.as_mut_ptr(),
- &mut len,
- 0 as *mut _,
- 0 as *mut _,
- 0 as *mut _,
- 0 as *mut _,
- );
- if ret == ERROR_NO_MORE_ITEMS as LONG {
- None
- } else if ret != ERROR_SUCCESS as LONG {
- Some(Err(io::Error::from_raw_os_error(ret as i32)))
- } else {
- v.set_len(len as usize);
- Some(Ok(OsString::from_wide(&v)))
- }
- })
- }
-}
diff --git a/cc/src/setup_config.rs b/cc/src/setup_config.rs
deleted file mode 100644
index bc2b1c2..0000000
--- a/cc/src/setup_config.rs
+++ /dev/null
@@ -1,283 +0,0 @@
-// Copyright © 2017 winapi-rs developers
-// Licensed under the Apache License, Version 2.0
-// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
-// All files in the project carrying such notice may not be copied, modified, or distributed
-// except according to those terms.
-
-#![allow(bad_style)]
-#![allow(unused)]
-
-use crate::winapi::Interface;
-use crate::winapi::BSTR;
-use crate::winapi::LPCOLESTR;
-use crate::winapi::LPSAFEARRAY;
-use crate::winapi::S_FALSE;
-use crate::winapi::{CoCreateInstance, CLSCTX_ALL};
-use crate::winapi::{IUnknown, IUnknownVtbl};
-use crate::winapi::{HRESULT, LCID, LPCWSTR, PULONGLONG};
-use crate::winapi::{LPFILETIME, ULONG};
-use std::ffi::OsString;
-use std::ptr::null_mut;
-
-use crate::com::{BStr, ComPtr};
-
-// Bindings to the Setup.Configuration stuff
-pub type InstanceState = u32;
-
-pub const eNone: InstanceState = 0;
-pub const eLocal: InstanceState = 1;
-pub const eRegistered: InstanceState = 2;
-pub const eNoRebootRequired: InstanceState = 4;
-pub const eComplete: InstanceState = -1i32 as u32;
-
-RIDL! {#[uuid(0xb41463c3, 0x8866, 0x43b5, 0xbc, 0x33, 0x2b, 0x06, 0x76, 0xf7, 0xf4, 0x2e)]
-interface ISetupInstance(ISetupInstanceVtbl): IUnknown(IUnknownVtbl) {
- fn GetInstanceId(
- pbstrInstanceId: *mut BSTR,
- ) -> HRESULT,
- fn GetInstallDate(
- pInstallDate: LPFILETIME,
- ) -> HRESULT,
- fn GetInstallationName(
- pbstrInstallationName: *mut BSTR,
- ) -> HRESULT,
- fn GetInstallationPath(
- pbstrInstallationPath: *mut BSTR,
- ) -> HRESULT,
- fn GetInstallationVersion(
- pbstrInstallationVersion: *mut BSTR,
- ) -> HRESULT,
- fn GetDisplayName(
- lcid: LCID,
- pbstrDisplayName: *mut BSTR,
- ) -> HRESULT,
- fn GetDescription(
- lcid: LCID,
- pbstrDescription: *mut BSTR,
- ) -> HRESULT,
- fn ResolvePath(
- pwszRelativePath: LPCOLESTR,
- pbstrAbsolutePath: *mut BSTR,
- ) -> HRESULT,
-}}
-
-RIDL! {#[uuid(0x89143c9a, 0x05af, 0x49b0, 0xb7, 0x17, 0x72, 0xe2, 0x18, 0xa2, 0x18, 0x5c)]
-interface ISetupInstance2(ISetupInstance2Vtbl): ISetupInstance(ISetupInstanceVtbl) {
- fn GetState(
- pState: *mut InstanceState,
- ) -> HRESULT,
- fn GetPackages(
- ppsaPackages: *mut LPSAFEARRAY,
- ) -> HRESULT,
- fn GetProduct(
- ppPackage: *mut *mut ISetupPackageReference,
- ) -> HRESULT,
- fn GetProductPath(
- pbstrProductPath: *mut BSTR,
- ) -> HRESULT,
-}}
-
-RIDL! {#[uuid(0x6380bcff, 0x41d3, 0x4b2e, 0x8b, 0x2e, 0xbf, 0x8a, 0x68, 0x10, 0xc8, 0x48)]
-interface IEnumSetupInstances(IEnumSetupInstancesVtbl): IUnknown(IUnknownVtbl) {
- fn Next(
- celt: ULONG,
- rgelt: *mut *mut ISetupInstance,
- pceltFetched: *mut ULONG,
- ) -> HRESULT,
- fn Skip(
- celt: ULONG,
- ) -> HRESULT,
- fn Reset() -> HRESULT,
- fn Clone(
- ppenum: *mut *mut IEnumSetupInstances,
- ) -> HRESULT,
-}}
-
-RIDL! {#[uuid(0x42843719, 0xdb4c, 0x46c2, 0x8e, 0x7c, 0x64, 0xf1, 0x81, 0x6e, 0xfd, 0x5b)]
-interface ISetupConfiguration(ISetupConfigurationVtbl): IUnknown(IUnknownVtbl) {
- fn EnumInstances(
- ppEnumInstances: *mut *mut IEnumSetupInstances,
- ) -> HRESULT,
- fn GetInstanceForCurrentProcess(
- ppInstance: *mut *mut ISetupInstance,
- ) -> HRESULT,
- fn GetInstanceForPath(
- wzPath: LPCWSTR,
- ppInstance: *mut *mut ISetupInstance,
- ) -> HRESULT,
-}}
-
-RIDL! {#[uuid(0x26aab78c, 0x4a60, 0x49d6, 0xaf, 0x3b, 0x3c, 0x35, 0xbc, 0x93, 0x36, 0x5d)]
-interface ISetupConfiguration2(ISetupConfiguration2Vtbl):
- ISetupConfiguration(ISetupConfigurationVtbl) {
- fn EnumAllInstances(
- ppEnumInstances: *mut *mut IEnumSetupInstances,
- ) -> HRESULT,
-}}
-
-RIDL! {#[uuid(0xda8d8a16, 0xb2b6, 0x4487, 0xa2, 0xf1, 0x59, 0x4c, 0xcc, 0xcd, 0x6b, 0xf5)]
-interface ISetupPackageReference(ISetupPackageReferenceVtbl): IUnknown(IUnknownVtbl) {
- fn GetId(
- pbstrId: *mut BSTR,
- ) -> HRESULT,
- fn GetVersion(
- pbstrVersion: *mut BSTR,
- ) -> HRESULT,
- fn GetChip(
- pbstrChip: *mut BSTR,
- ) -> HRESULT,
- fn GetLanguage(
- pbstrLanguage: *mut BSTR,
- ) -> HRESULT,
- fn GetBranch(
- pbstrBranch: *mut BSTR,
- ) -> HRESULT,
- fn GetType(
- pbstrType: *mut BSTR,
- ) -> HRESULT,
- fn GetUniqueId(
- pbstrUniqueId: *mut BSTR,
- ) -> HRESULT,
-}}
-
-RIDL! {#[uuid(0x42b21b78, 0x6192, 0x463e, 0x87, 0xbf, 0xd5, 0x77, 0x83, 0x8f, 0x1d, 0x5c)]
-interface ISetupHelper(ISetupHelperVtbl): IUnknown(IUnknownVtbl) {
- fn ParseVersion(
- pwszVersion: LPCOLESTR,
- pullVersion: PULONGLONG,
- ) -> HRESULT,
- fn ParseVersionRange(
- pwszVersionRange: LPCOLESTR,
- pullMinVersion: PULONGLONG,
- pullMaxVersion: PULONGLONG,
- ) -> HRESULT,
-}}
-
-DEFINE_GUID! {CLSID_SetupConfiguration,
-0x177f0c4a, 0x1cd3, 0x4de7, 0xa3, 0x2c, 0x71, 0xdb, 0xbb, 0x9f, 0xa3, 0x6d}
-
-// Safe wrapper around the COM interfaces
-pub struct SetupConfiguration(ComPtr<ISetupConfiguration>);
-
-impl SetupConfiguration {
- pub fn new() -> Result<SetupConfiguration, i32> {
- let mut obj = null_mut();
- let err = unsafe {
- CoCreateInstance(
- &CLSID_SetupConfiguration,
- null_mut(),
- CLSCTX_ALL,
- &ISetupConfiguration::uuidof(),
- &mut obj,
- )
- };
- if err < 0 {
- return Err(err);
- }
- let obj = unsafe { ComPtr::from_raw(obj as *mut ISetupConfiguration) };
- Ok(SetupConfiguration(obj))
- }
- pub fn get_instance_for_current_process(&self) -> Result<SetupInstance, i32> {
- let mut obj = null_mut();
- let err = unsafe { self.0.GetInstanceForCurrentProcess(&mut obj) };
- if err < 0 {
- return Err(err);
- }
- Ok(unsafe { SetupInstance::from_raw(obj) })
- }
- pub fn enum_instances(&self) -> Result<EnumSetupInstances, i32> {
- let mut obj = null_mut();
- let err = unsafe { self.0.EnumInstances(&mut obj) };
- if err < 0 {
- return Err(err);
- }
- Ok(unsafe { EnumSetupInstances::from_raw(obj) })
- }
- pub fn enum_all_instances(&self) -> Result<EnumSetupInstances, i32> {
- let mut obj = null_mut();
- let this = self.0.cast::<ISetupConfiguration2>()?;
- let err = unsafe { this.EnumAllInstances(&mut obj) };
- if err < 0 {
- return Err(err);
- }
- Ok(unsafe { EnumSetupInstances::from_raw(obj) })
- }
-}
-
-pub struct SetupInstance(ComPtr<ISetupInstance>);
-
-impl SetupInstance {
- pub unsafe fn from_raw(obj: *mut ISetupInstance) -> SetupInstance {
- SetupInstance(ComPtr::from_raw(obj))
- }
- pub fn instance_id(&self) -> Result<OsString, i32> {
- let mut s = null_mut();
- let err = unsafe { self.0.GetInstanceId(&mut s) };
- let bstr = unsafe { BStr::from_raw(s) };
- if err < 0 {
- return Err(err);
- }
- Ok(bstr.to_osstring())
- }
- pub fn installation_name(&self) -> Result<OsString, i32> {
- let mut s = null_mut();
- let err = unsafe { self.0.GetInstallationName(&mut s) };
- let bstr = unsafe { BStr::from_raw(s) };
- if err < 0 {
- return Err(err);
- }
- Ok(bstr.to_osstring())
- }
- pub fn installation_path(&self) -> Result<OsString, i32> {
- let mut s = null_mut();
- let err = unsafe { self.0.GetInstallationPath(&mut s) };
- let bstr = unsafe { BStr::from_raw(s) };
- if err < 0 {
- return Err(err);
- }
- Ok(bstr.to_osstring())
- }
- pub fn installation_version(&self) -> Result<OsString, i32> {
- let mut s = null_mut();
- let err = unsafe { self.0.GetInstallationVersion(&mut s) };
- let bstr = unsafe { BStr::from_raw(s) };
- if err < 0 {
- return Err(err);
- }
- Ok(bstr.to_osstring())
- }
- pub fn product_path(&self) -> Result<OsString, i32> {
- let mut s = null_mut();
- let this = self.0.cast::<ISetupInstance2>()?;
- let err = unsafe { this.GetProductPath(&mut s) };
- let bstr = unsafe { BStr::from_raw(s) };
- if err < 0 {
- return Err(err);
- }
- Ok(bstr.to_osstring())
- }
-}
-
-pub struct EnumSetupInstances(ComPtr<IEnumSetupInstances>);
-
-impl EnumSetupInstances {
- pub unsafe fn from_raw(obj: *mut IEnumSetupInstances) -> EnumSetupInstances {
- EnumSetupInstances(ComPtr::from_raw(obj))
- }
-}
-
-impl Iterator for EnumSetupInstances {
- type Item = Result<SetupInstance, i32>;
- fn next(&mut self) -> Option<Result<SetupInstance, i32>> {
- let mut obj = null_mut();
- let err = unsafe { self.0.Next(1, &mut obj, null_mut()) };
- if err < 0 {
- return Some(Err(err));
- }
- if err == S_FALSE {
- return None;
- }
- Some(Ok(unsafe { SetupInstance::from_raw(obj) }))
- }
-}
diff --git a/cc/src/winapi.rs b/cc/src/winapi.rs
deleted file mode 100644
index c416325..0000000
--- a/cc/src/winapi.rs
+++ /dev/null
@@ -1,218 +0,0 @@
-// Copyright © 2015-2017 winapi-rs developers
-// Licensed under the Apache License, Version 2.0
-// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
-// All files in the project carrying such notice may not be copied, modified, or distributed
-// except according to those terms.
-
-#![allow(bad_style)]
-
-use std::os::raw;
-
-pub type wchar_t = u16;
-
-pub type UINT = raw::c_uint;
-pub type LPUNKNOWN = *mut IUnknown;
-pub type REFIID = *const IID;
-pub type IID = GUID;
-pub type REFCLSID = *const IID;
-pub type PVOID = *mut raw::c_void;
-pub type USHORT = raw::c_ushort;
-pub type ULONG = raw::c_ulong;
-pub type LONG = raw::c_long;
-pub type DWORD = u32;
-pub type LPVOID = *mut raw::c_void;
-pub type HRESULT = raw::c_long;
-pub type LPFILETIME = *mut FILETIME;
-pub type BSTR = *mut OLECHAR;
-pub type OLECHAR = WCHAR;
-pub type WCHAR = wchar_t;
-pub type LPCOLESTR = *const OLECHAR;
-pub type LCID = DWORD;
-pub type LPCWSTR = *const WCHAR;
-pub type PULONGLONG = *mut ULONGLONG;
-pub type ULONGLONG = u64;
-
-pub const S_OK: HRESULT = 0;
-pub const S_FALSE: HRESULT = 1;
-pub const COINIT_MULTITHREADED: u32 = 0x0;
-
-pub type CLSCTX = u32;
-
-pub const CLSCTX_INPROC_SERVER: CLSCTX = 0x1;
-pub const CLSCTX_INPROC_HANDLER: CLSCTX = 0x2;
-pub const CLSCTX_LOCAL_SERVER: CLSCTX = 0x4;
-pub const CLSCTX_REMOTE_SERVER: CLSCTX = 0x10;
-
-pub const CLSCTX_ALL: CLSCTX =
- CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER;
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct GUID {
- pub Data1: raw::c_ulong,
- pub Data2: raw::c_ushort,
- pub Data3: raw::c_ushort,
- pub Data4: [raw::c_uchar; 8],
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct FILETIME {
- pub dwLowDateTime: DWORD,
- pub dwHighDateTime: DWORD,
-}
-
-pub trait Interface {
- fn uuidof() -> GUID;
-}
-
-#[link(name = "ole32")]
-#[link(name = "oleaut32")]
-extern "C" {}
-
-extern "system" {
- pub fn CoInitializeEx(pvReserved: LPVOID, dwCoInit: DWORD) -> HRESULT;
- pub fn CoCreateInstance(
- rclsid: REFCLSID,
- pUnkOuter: LPUNKNOWN,
- dwClsContext: DWORD,
- riid: REFIID,
- ppv: *mut LPVOID,
- ) -> HRESULT;
- pub fn SysFreeString(bstrString: BSTR);
- pub fn SysStringLen(pbstr: BSTR) -> UINT;
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SAFEARRAYBOUND {
- pub cElements: ULONG,
- pub lLbound: LONG,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SAFEARRAY {
- pub cDims: USHORT,
- pub fFeatures: USHORT,
- pub cbElements: ULONG,
- pub cLocks: ULONG,
- pub pvData: PVOID,
- pub rgsabound: [SAFEARRAYBOUND; 1],
-}
-
-pub type LPSAFEARRAY = *mut SAFEARRAY;
-
-macro_rules! DEFINE_GUID {
- (
- $name:ident, $l:expr, $w1:expr, $w2:expr,
- $b1:expr, $b2:expr, $b3:expr, $b4:expr, $b5:expr, $b6:expr, $b7:expr, $b8:expr
- ) => {
- pub const $name: $crate::winapi::GUID = $crate::winapi::GUID {
- Data1: $l,
- Data2: $w1,
- Data3: $w2,
- Data4: [$b1, $b2, $b3, $b4, $b5, $b6, $b7, $b8],
- };
- };
-}
-
-macro_rules! RIDL {
- (#[uuid($($uuid:expr),+)]
- interface $interface:ident ($vtbl:ident) {$(
- fn $method:ident($($p:ident : $t:ty,)*) -> $rtr:ty,
- )+}) => (
- #[repr(C)]
- pub struct $vtbl {
- $(pub $method: unsafe extern "system" fn(
- This: *mut $interface,
- $($p: $t),*
- ) -> $rtr,)+
- }
- #[repr(C)]
- pub struct $interface {
- pub lpVtbl: *const $vtbl,
- }
- RIDL!{@impl $interface {$(fn $method($($p: $t,)*) -> $rtr,)+}}
- RIDL!{@uuid $interface $($uuid),+}
- );
- (#[uuid($($uuid:expr),+)]
- interface $interface:ident ($vtbl:ident) : $pinterface:ident ($pvtbl:ident) {
- }) => (
- #[repr(C)]
- pub struct $vtbl {
- pub parent: $pvtbl,
- }
- #[repr(C)]
- pub struct $interface {
- pub lpVtbl: *const $vtbl,
- }
- RIDL!{@deref $interface $pinterface}
- RIDL!{@uuid $interface $($uuid),+}
- );
- (#[uuid($($uuid:expr),+)]
- interface $interface:ident ($vtbl:ident) : $pinterface:ident ($pvtbl:ident) {$(
- fn $method:ident($($p:ident : $t:ty,)*) -> $rtr:ty,
- )+}) => (
- #[repr(C)]
- pub struct $vtbl {
- pub parent: $pvtbl,
- $(pub $method: unsafe extern "system" fn(
- This: *mut $interface,
- $($p: $t,)*
- ) -> $rtr,)+
- }
- #[repr(C)]
- pub struct $interface {
- pub lpVtbl: *const $vtbl,
- }
- RIDL!{@impl $interface {$(fn $method($($p: $t,)*) -> $rtr,)+}}
- RIDL!{@deref $interface $pinterface}
- RIDL!{@uuid $interface $($uuid),+}
- );
- (@deref $interface:ident $pinterface:ident) => (
- impl ::std::ops::Deref for $interface {
- type Target = $pinterface;
- #[inline]
- fn deref(&self) -> &$pinterface {
- unsafe { &*(self as *const $interface as *const $pinterface) }
- }
- }
- );
- (@impl $interface:ident {$(
- fn $method:ident($($p:ident : $t:ty,)*) -> $rtr:ty,
- )+}) => (
- impl $interface {
- $(#[inline] pub unsafe fn $method(&self, $($p: $t,)*) -> $rtr {
- ((*self.lpVtbl).$method)(self as *const _ as *mut _, $($p,)*)
- })+
- }
- );
- (@uuid $interface:ident
- $l:expr, $w1:expr, $w2:expr,
- $b1:expr, $b2:expr, $b3:expr, $b4:expr, $b5:expr, $b6:expr, $b7:expr, $b8:expr
- ) => (
- impl $crate::winapi::Interface for $interface {
- #[inline]
- fn uuidof() -> $crate::winapi::GUID {
- $crate::winapi::GUID {
- Data1: $l,
- Data2: $w1,
- Data3: $w2,
- Data4: [$b1, $b2, $b3, $b4, $b5, $b6, $b7, $b8],
- }
- }
- }
- );
-}
-
-RIDL! {#[uuid(0x00000000, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
-interface IUnknown(IUnknownVtbl) {
- fn QueryInterface(
- riid: REFIID,
- ppvObject: *mut *mut raw::c_void,
- ) -> HRESULT,
- fn AddRef() -> ULONG,
- fn Release() -> ULONG,
-}}
diff --git a/cc/src/windows_registry.rs b/cc/src/windows_registry.rs
deleted file mode 100644
index 5af3ff7..0000000
--- a/cc/src/windows_registry.rs
+++ /dev/null
@@ -1,754 +0,0 @@
-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! A helper module to probe the Windows Registry when looking for
-//! windows-specific tools.
-
-use std::process::Command;
-
-use crate::Tool;
-
-/// Attempts to find a tool within an MSVC installation using the Windows
-/// registry as a point to search from.
-///
-/// The `target` argument is the target that the tool should work for (e.g.
-/// compile or link for) and the `tool` argument is the tool to find (e.g.
-/// `cl.exe` or `link.exe`).
-///
-/// This function will return `None` if the tool could not be found, or it will
-/// return `Some(cmd)` which represents a command that's ready to execute the
-/// tool with the appropriate environment variables set.
-///
-/// Note that this function always returns `None` for non-MSVC targets.
-pub fn find(target: &str, tool: &str) -> Option<Command> {
- find_tool(target, tool).map(|c| c.to_command())
-}
-
-/// Similar to the `find` function above, this function will attempt the same
-/// operation (finding a MSVC tool in a local install) but instead returns a
-/// `Tool` which may be introspected.
-#[cfg(not(windows))]
-pub fn find_tool(_target: &str, _tool: &str) -> Option<Tool> {
- None
-}
-
-/// Documented above.
-#[cfg(windows)]
-pub fn find_tool(target: &str, tool: &str) -> Option<Tool> {
- use std::env;
-
- // This logic is all tailored for MSVC, if we're not that then bail out
- // early.
- if !target.contains("msvc") {
- return None;
- }
-
- // Looks like msbuild isn't located in the same location as other tools like
- // cl.exe and lib.exe. To handle this we probe for it manually with
- // dedicated registry keys.
- if tool.contains("msbuild") {
- return impl_::find_msbuild(target);
- }
-
- if tool.contains("devenv") {
- return impl_::find_devenv(target);
- }
-
- // If VCINSTALLDIR is set, then someone's probably already run vcvars and we
- // should just find whatever that indicates.
- if env::var_os("VCINSTALLDIR").is_some() {
- return env::var_os("PATH")
- .and_then(|path| {
- env::split_paths(&path)
- .map(|p| p.join(tool))
- .find(|p| p.exists())
- })
- .map(|path| Tool::new(path.into()));
- }
-
- // Ok, if we're here, now comes the fun part of the probing. Default shells
- // or shells like MSYS aren't really configured to execute `cl.exe` and the
- // various compiler tools shipped as part of Visual Studio. Here we try to
- // first find the relevant tool, then we also have to be sure to fill in
- // environment variables like `LIB`, `INCLUDE`, and `PATH` to ensure that
- // the tool is actually usable.
-
- return impl_::find_msvc_15(tool, target)
- .or_else(|| impl_::find_msvc_14(tool, target))
- .or_else(|| impl_::find_msvc_12(tool, target))
- .or_else(|| impl_::find_msvc_11(tool, target));
-}
-
-/// A version of Visual Studio
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
-pub enum VsVers {
- /// Visual Studio 12 (2013)
- Vs12,
- /// Visual Studio 14 (2015)
- Vs14,
- /// Visual Studio 15 (2017)
- Vs15,
- /// Visual Studio 16 (2019)
- Vs16,
-
- /// Hidden variant that should not be matched on. Callers that want to
- /// 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,
-}
-
-/// Find the most recent installed version of Visual Studio
-///
-/// This is used by the cmake crate to figure out the correct
-/// generator.
-#[cfg(not(windows))]
-pub fn find_vs_version() -> Result<VsVers, String> {
- Err(format!("not windows"))
-}
-
-/// Documented above
-#[cfg(windows)]
-pub fn find_vs_version() -> Result<VsVers, String> {
- use std::env;
-
- match env::var("VisualStudioVersion") {
- Ok(version) => match &version[..] {
- "16.0" => Ok(VsVers::Vs16),
- "15.0" => Ok(VsVers::Vs15),
- "14.0" => Ok(VsVers::Vs14),
- "12.0" => Ok(VsVers::Vs12),
- vers => Err(format!(
- "\n\n\
- unsupported or unknown VisualStudio version: {}\n\
- if another version is installed consider running \
- the appropriate vcvars script before building this \
- crate\n\
- ",
- vers
- )),
- },
- _ => {
- // Check for the presense of a specific registry key
- // that indicates visual studio is installed.
- if impl_::has_msbuild_version("16.0") {
- Ok(VsVers::Vs16)
- } else if impl_::has_msbuild_version("15.0") {
- Ok(VsVers::Vs15)
- } else if impl_::has_msbuild_version("14.0") {
- Ok(VsVers::Vs14)
- } else if impl_::has_msbuild_version("12.0") {
- Ok(VsVers::Vs12)
- } else {
- Err(format!(
- "\n\n\
- couldn't determine visual studio generator\n\
- if VisualStudio is installed, however, consider \
- running the appropriate vcvars script before building \
- this crate\n\
- "
- ))
- }
- }
- }
-}
-
-#[cfg(windows)]
-mod impl_ {
- use crate::com;
- use crate::registry::{RegistryKey, LOCAL_MACHINE};
- use crate::setup_config::{EnumSetupInstances, SetupConfiguration, SetupInstance};
- use std::env;
- use std::ffi::OsString;
- use std::fs::File;
- use std::io::Read;
- use std::iter;
- use std::mem;
- use std::path::{Path, PathBuf};
-
- use crate::Tool;
-
- struct MsvcTool {
- tool: PathBuf,
- libs: Vec<PathBuf>,
- path: Vec<PathBuf>,
- include: Vec<PathBuf>,
- }
-
- impl MsvcTool {
- fn new(tool: PathBuf) -> MsvcTool {
- MsvcTool {
- tool: tool,
- libs: Vec::new(),
- path: Vec::new(),
- include: Vec::new(),
- }
- }
-
- fn into_tool(self) -> Tool {
- let MsvcTool {
- tool,
- libs,
- path,
- include,
- } = self;
- let mut tool = Tool::new(tool.into());
- add_env(&mut tool, "LIB", libs);
- add_env(&mut tool, "PATH", path);
- add_env(&mut tool, "INCLUDE", include);
- tool
- }
- }
-
- #[allow(bare_trait_objects)]
- fn vs16_instances() -> Box<Iterator<Item = PathBuf>> {
- let instances = if let Some(instances) = vs15_instances() {
- instances
- } else {
- return Box::new(iter::empty());
- };
- Box::new(instances.filter_map(|instance| {
- let instance = instance.ok()?;
- let installation_name = instance.installation_name().ok()?;
- if installation_name.to_str()?.starts_with("VisualStudio/16.") {
- Some(PathBuf::from(instance.installation_path().ok()?))
- } else {
- None
- }
- }))
- }
-
- fn find_tool_in_vs16_path(tool: &str, target: &str) -> Option<Tool> {
- vs16_instances()
- .filter_map(|path| {
- let path = path.join(tool);
- if !path.is_file() {
- return None;
- }
- let mut tool = Tool::new(path);
- if target.contains("x86_64") {
- tool.env.push(("Platform".into(), "X64".into()));
- }
- Some(tool)
- })
- .next()
- }
-
- fn find_msbuild_vs16(target: &str) -> Option<Tool> {
- find_tool_in_vs16_path(r"MSBuild\Current\Bin\MSBuild.exe", target)
- }
-
- // 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/
- fn vs15_instances() -> Option<EnumSetupInstances> {
- com::initialize().ok()?;
-
- let config = SetupConfiguration::new().ok()?;
- config.enum_all_instances().ok()
- }
-
- pub fn find_msvc_15(tool: &str, target: &str) -> Option<Tool> {
- let iter = vs15_instances()?;
- for instance in iter {
- let instance = instance.ok()?;
- let tool = tool_from_vs15_instance(tool, target, &instance);
- if tool.is_some() {
- return tool;
- }
- }
-
- None
- }
-
- // While the paths to Visual Studio 2017's devenv and MSBuild could
- // potentially be retrieved from the registry, finding them via
- // SetupConfiguration has shown to be [more reliable], and is preferred
- // according to Microsoft. To help head off potential regressions though,
- // we keep the registry method as a fallback option.
- //
- // [more reliable]: https://github.com/alexcrichton/cc-rs/pull/331
- fn find_tool_in_vs15_path(tool: &str, target: &str) -> Option<Tool> {
- let mut path = match vs15_instances() {
- Some(instances) => instances
- .filter_map(|instance| {
- instance
- .ok()
- .and_then(|instance| instance.installation_path().ok())
- })
- .map(|path| PathBuf::from(path).join(tool))
- .find(|ref path| path.is_file()),
- None => None,
- };
-
- if path.is_none() {
- let key = r"SOFTWARE\WOW6432Node\Microsoft\VisualStudio\SxS\VS7";
- path = LOCAL_MACHINE
- .open(key.as_ref())
- .ok()
- .and_then(|key| key.query_str("15.0").ok())
- .map(|path| PathBuf::from(path).join(tool))
- .and_then(|path| if path.is_file() { Some(path) } else { None });
- }
-
- path.map(|path| {
- let mut tool = Tool::new(path);
- if target.contains("x86_64") {
- tool.env.push(("Platform".into(), "X64".into()));
- }
- tool
- })
- }
-
- fn tool_from_vs15_instance(tool: &str, target: &str, instance: &SetupInstance) -> Option<Tool> {
- let (bin_path, host_dylib_path, lib_path, include_path) = 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(host_dylib_path);
- tool.libs.push(lib_path);
- tool.include.push(include_path);
-
- if let Some((atl_lib_path, atl_include_path)) = atl_paths(target, &bin_path) {
- tool.libs.push(atl_lib_path);
- tool.include.push(atl_include_path);
- }
-
- add_sdks(&mut tool, target)?;
-
- Some(tool.into_tool())
- }
-
- fn vs15_vc_paths(
- target: &str,
- instance: &SetupInstance,
- ) -> Option<(PathBuf, PathBuf, PathBuf, PathBuf)> {
- let instance_path: PathBuf = instance.installation_path().ok()?.into();
- let version_path =
- instance_path.join(r"VC\Auxiliary\Build\Microsoft.VCToolsVersion.default.txt");
- let mut version_file = File::open(version_path).ok()?;
- let mut version = String::new();
- version_file.read_to_string(&mut version).ok()?;
- let version = version.trim();
- let host = match host_arch() {
- X86 => "X86",
- X86_64 => "X64",
- _ => return None,
- };
- let target = 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, host_dylib_path, lib_path, include_path))
- }
-
- fn atl_paths(target: &str, path: &Path) -> Option<(PathBuf, PathBuf)> {
- let atl_path = path.join("atlfmc");
- let sub = lib_subdir(target)?;
- if atl_path.exists() {
- Some((atl_path.join("lib").join(sub), atl_path.join("include")))
- } else {
- None
- }
- }
-
- // For MSVC 14 we need to find the Universal CRT as well as either
- // the Windows 10 SDK or Windows 8.1 SDK.
- pub fn find_msvc_14(tool: &str, target: &str) -> Option<Tool> {
- let vcdir = get_vc_dir("14.0")?;
- let mut tool = get_tool(tool, &vcdir, target)?;
- add_sdks(&mut tool, target)?;
- Some(tool.into_tool())
- }
-
- fn add_sdks(tool: &mut MsvcTool, target: &str) -> Option<()> {
- let sub = lib_subdir(target)?;
- let (ucrt, ucrt_version) = get_ucrt_dir()?;
-
- tool.path
- .push(ucrt.join("bin").join(&ucrt_version).join(sub));
-
- let ucrt_include = ucrt.join("include").join(&ucrt_version);
- tool.include.push(ucrt_include.join("ucrt"));
-
- let ucrt_lib = ucrt.join("lib").join(&ucrt_version);
- tool.libs.push(ucrt_lib.join("ucrt").join(sub));
-
- if let Some((sdk, version)) = get_sdk10_dir() {
- tool.path.push(sdk.join("bin").join(sub));
- let sdk_lib = sdk.join("lib").join(&version);
- tool.libs.push(sdk_lib.join("um").join(sub));
- let sdk_include = sdk.join("include").join(&version);
- tool.include.push(sdk_include.join("um"));
- tool.include.push(sdk_include.join("cppwinrt"));
- tool.include.push(sdk_include.join("winrt"));
- tool.include.push(sdk_include.join("shared"));
- } else if let Some(sdk) = get_sdk81_dir() {
- tool.path.push(sdk.join("bin").join(sub));
- let sdk_lib = sdk.join("lib").join("winv6.3");
- tool.libs.push(sdk_lib.join("um").join(sub));
- let sdk_include = sdk.join("include");
- tool.include.push(sdk_include.join("um"));
- tool.include.push(sdk_include.join("winrt"));
- tool.include.push(sdk_include.join("shared"));
- }
-
- Some(())
- }
-
- // For MSVC 12 we need to find the Windows 8.1 SDK.
- pub fn find_msvc_12(tool: &str, target: &str) -> Option<Tool> {
- let vcdir = get_vc_dir("12.0")?;
- let mut tool = get_tool(tool, &vcdir, target)?;
- let sub = lib_subdir(target)?;
- let sdk81 = get_sdk81_dir()?;
- tool.path.push(sdk81.join("bin").join(sub));
- let sdk_lib = sdk81.join("lib").join("winv6.3");
- tool.libs.push(sdk_lib.join("um").join(sub));
- let sdk_include = sdk81.join("include");
- tool.include.push(sdk_include.join("shared"));
- tool.include.push(sdk_include.join("um"));
- tool.include.push(sdk_include.join("winrt"));
- Some(tool.into_tool())
- }
-
- // For MSVC 11 we need to find the Windows 8 SDK.
- pub fn find_msvc_11(tool: &str, target: &str) -> Option<Tool> {
- let vcdir = get_vc_dir("11.0")?;
- let mut tool = get_tool(tool, &vcdir, target)?;
- let sub = lib_subdir(target)?;
- let sdk8 = get_sdk8_dir()?;
- tool.path.push(sdk8.join("bin").join(sub));
- let sdk_lib = sdk8.join("lib").join("win8");
- tool.libs.push(sdk_lib.join("um").join(sub));
- let sdk_include = sdk8.join("include");
- tool.include.push(sdk_include.join("shared"));
- tool.include.push(sdk_include.join("um"));
- tool.include.push(sdk_include.join("winrt"));
- Some(tool.into_tool())
- }
-
- fn add_env(tool: &mut Tool, env: &str, paths: Vec<PathBuf>) {
- let prev = env::var_os(env).unwrap_or(OsString::new());
- let prev = env::split_paths(&prev);
- let new = paths.into_iter().chain(prev);
- tool.env
- .push((env.to_string().into(), env::join_paths(new).unwrap()));
- }
-
- // Given a possible MSVC installation directory, we look for the linker and
- // then add the MSVC library path.
- fn get_tool(tool: &str, path: &Path, target: &str) -> Option<MsvcTool> {
- bin_subdir(target)
- .into_iter()
- .map(|(sub, host)| {
- (
- path.join("bin").join(sub).join(tool),
- path.join("bin").join(host),
- )
- })
- .filter(|&(ref path, _)| path.is_file())
- .map(|(path, host)| {
- let mut tool = MsvcTool::new(path);
- tool.path.push(host);
- tool
- })
- .filter_map(|mut tool| {
- let sub = vc_lib_subdir(target)?;
- tool.libs.push(path.join("lib").join(sub));
- tool.include.push(path.join("include"));
- let atlmfc_path = path.join("atlmfc");
- if atlmfc_path.exists() {
- tool.libs.push(atlmfc_path.join("lib").join(sub));
- tool.include.push(atlmfc_path.join("include"));
- }
- Some(tool)
- })
- .next()
- }
-
- // To find MSVC we look in a specific registry key for the version we are
- // trying to find.
- fn get_vc_dir(ver: &str) -> Option<PathBuf> {
- let key = r"SOFTWARE\Microsoft\VisualStudio\SxS\VC7";
- let key = LOCAL_MACHINE.open(key.as_ref()).ok()?;
- let path = key.query_str(ver).ok()?;
- Some(path.into())
- }
-
- // To find the Universal CRT we look in a specific registry key for where
- // all the Universal CRTs are located and then sort them asciibetically to
- // find the newest version. While this sort of sorting isn't ideal, it is
- // what vcvars does so that's good enough for us.
- //
- // Returns a pair of (root, version) for the ucrt dir if found
- fn get_ucrt_dir() -> Option<(PathBuf, String)> {
- let key = r"SOFTWARE\Microsoft\Windows Kits\Installed Roots";
- let key = LOCAL_MACHINE.open(key.as_ref()).ok()?;
- let root = key.query_str("KitsRoot10").ok()?;
- let readdir = Path::new(&root).join("lib").read_dir().ok()?;
- let max_libdir = readdir
- .filter_map(|dir| dir.ok())
- .map(|dir| dir.path())
- .filter(|dir| {
- dir.components()
- .last()
- .and_then(|c| c.as_os_str().to_str())
- .map(|c| c.starts_with("10.") && dir.join("ucrt").is_dir())
- .unwrap_or(false)
- })
- .max()?;
- let version = max_libdir.components().last().unwrap();
- let version = version.as_os_str().to_str().unwrap().to_string();
- Some((root.into(), version))
- }
-
- // Vcvars finds the correct version of the Windows 10 SDK by looking
- // for the include `um\Windows.h` because sometimes a given version will
- // only have UCRT bits without the rest of the SDK. Since we only care about
- // libraries and not includes, we instead look for `um\x64\kernel32.lib`.
- // Since the 32-bit and 64-bit libraries are always installed together we
- // only need to bother checking x64, making this code a tiny bit simpler.
- // Like we do for the Universal CRT, we sort the possibilities
- // asciibetically to find the newest one as that is what vcvars does.
- fn get_sdk10_dir() -> Option<(PathBuf, String)> {
- let key = r"SOFTWARE\Microsoft\Microsoft SDKs\Windows\v10.0";
- let key = LOCAL_MACHINE.open(key.as_ref()).ok()?;
- let root = key.query_str("InstallationFolder").ok()?;
- let readdir = Path::new(&root).join("lib").read_dir().ok()?;
- let mut dirs = readdir
- .filter_map(|dir| dir.ok())
- .map(|dir| dir.path())
- .collect::<Vec<_>>();
- dirs.sort();
- let dir = dirs
- .into_iter()
- .rev()
- .filter(|dir| dir.join("um").join("x64").join("kernel32.lib").is_file())
- .next()?;
- let version = dir.components().last().unwrap();
- let version = version.as_os_str().to_str().unwrap().to_string();
- Some((root.into(), version))
- }
-
- // Interestingly there are several subdirectories, `win7` `win8` and
- // `winv6.3`. Vcvars seems to only care about `winv6.3` though, so the same
- // applies to us. Note that if we were targetting kernel mode drivers
- // instead of user mode applications, we would care.
- fn get_sdk81_dir() -> Option<PathBuf> {
- let key = r"SOFTWARE\Microsoft\Microsoft SDKs\Windows\v8.1";
- let key = LOCAL_MACHINE.open(key.as_ref()).ok()?;
- let root = key.query_str("InstallationFolder").ok()?;
- Some(root.into())
- }
-
- fn get_sdk8_dir() -> Option<PathBuf> {
- let key = r"SOFTWARE\Microsoft\Microsoft SDKs\Windows\v8.0";
- let key = LOCAL_MACHINE.open(key.as_ref()).ok()?;
- let root = key.query_str("InstallationFolder").ok()?;
- Some(root.into())
- }
-
- const PROCESSOR_ARCHITECTURE_INTEL: u16 = 0;
- const PROCESSOR_ARCHITECTURE_AMD64: u16 = 9;
- const X86: u16 = PROCESSOR_ARCHITECTURE_INTEL;
- const X86_64: u16 = PROCESSOR_ARCHITECTURE_AMD64;
-
- // When choosing the tool to use, we have to choose the one which matches
- // the target architecture. Otherwise we end up in situations where someone
- // on 32-bit Windows is trying to cross compile to 64-bit and it tries to
- // invoke the native 64-bit compiler which won't work.
- //
- // For the return value of this function, the first member of the tuple is
- // the folder of the tool we will be invoking, while the second member is
- // the folder of the host toolchain for that tool which is essential when
- // using a cross linker. We return a Vec since on x64 there are often two
- // linkers that can target the architecture we desire. The 64-bit host
- // linker is preferred, and hence first, due to 64-bit allowing it more
- // address space to work with and potentially being faster.
- fn bin_subdir(target: &str) -> Vec<(&'static str, &'static str)> {
- let arch = target.split('-').next().unwrap();
- match (arch, host_arch()) {
- ("i586", X86) | ("i686", X86) => vec![("", "")],
- ("i586", X86_64) | ("i686", X86_64) => vec![("amd64_x86", "amd64"), ("", "")],
- ("x86_64", X86) => vec![("x86_amd64", "")],
- ("x86_64", X86_64) => vec![("amd64", "amd64"), ("x86_amd64", "")],
- ("arm", X86) | ("thumbv7a", X86) => vec![("x86_arm", "")],
- ("arm", X86_64) | ("thumbv7a", X86_64) => vec![("amd64_arm", "amd64"), ("x86_arm", "")],
- _ => vec![],
- }
- }
-
- fn lib_subdir(target: &str) -> Option<&'static str> {
- let arch = target.split('-').next().unwrap();
- match arch {
- "i586" | "i686" => Some("x86"),
- "x86_64" => Some("x64"),
- "arm" | "thumbv7a" => Some("arm"),
- "aarch64" => Some("arm64"),
- _ => None,
- }
- }
-
- // MSVC's x86 libraries are not in a subfolder
- fn vc_lib_subdir(target: &str) -> Option<&'static str> {
- let arch = target.split('-').next().unwrap();
- match arch {
- "i586" | "i686" => Some(""),
- "x86_64" => Some("amd64"),
- "arm" | "thumbv7a" => Some("arm"),
- "aarch64" => Some("arm64"),
- _ => None,
- }
- }
-
- #[allow(bad_style)]
- fn host_arch() -> u16 {
- type DWORD = u32;
- type WORD = u16;
- type LPVOID = *mut u8;
- type DWORD_PTR = usize;
-
- #[repr(C)]
- struct SYSTEM_INFO {
- wProcessorArchitecture: WORD,
- _wReserved: WORD,
- _dwPageSize: DWORD,
- _lpMinimumApplicationAddress: LPVOID,
- _lpMaximumApplicationAddress: LPVOID,
- _dwActiveProcessorMask: DWORD_PTR,
- _dwNumberOfProcessors: DWORD,
- _dwProcessorType: DWORD,
- _dwAllocationGranularity: DWORD,
- _wProcessorLevel: WORD,
- _wProcessorRevision: WORD,
- }
-
- extern "system" {
- fn GetNativeSystemInfo(lpSystemInfo: *mut SYSTEM_INFO);
- }
-
- unsafe {
- let mut info = mem::zeroed();
- GetNativeSystemInfo(&mut info);
- info.wProcessorArchitecture
- }
- }
-
- // Given a registry key, look at all the sub keys and find the one which has
- // the maximal numeric value.
- //
- // Returns the name of the maximal key as well as the opened maximal key.
- fn max_version(key: &RegistryKey) -> Option<(OsString, RegistryKey)> {
- let mut max_vers = 0;
- let mut max_key = None;
- for subkey in key.iter().filter_map(|k| k.ok()) {
- let val = subkey
- .to_str()
- .and_then(|s| s.trim_left_matches("v").replace(".", "").parse().ok());
- let val = match val {
- Some(s) => s,
- None => continue,
- };
- if val > max_vers {
- if let Ok(k) = key.open(&subkey) {
- max_vers = val;
- max_key = Some((subkey, k));
- }
- }
- }
- max_key
- }
-
- pub fn has_msbuild_version(version: &str) -> bool {
- match version {
- "16.0" => {
- find_msbuild_vs16("x86_64-pc-windows-msvc").is_some()
- || find_msbuild_vs16("i686-pc-windows-msvc").is_some()
- }
- "15.0" => {
- find_msbuild_vs15("x86_64-pc-windows-msvc").is_some()
- || find_msbuild_vs15("i686-pc-windows-msvc").is_some()
- }
- "12.0" | "14.0" => LOCAL_MACHINE
- .open(&OsString::from(format!(
- "SOFTWARE\\Microsoft\\MSBuild\\ToolsVersions\\{}",
- version
- )))
- .is_ok(),
- _ => false,
- }
- }
-
- pub fn find_devenv(target: &str) -> Option<Tool> {
- find_devenv_vs15(&target)
- }
-
- fn find_devenv_vs15(target: &str) -> Option<Tool> {
- find_tool_in_vs15_path(r"Common7\IDE\devenv.exe", target)
- }
-
- // see http://stackoverflow.com/questions/328017/path-to-msbuild
- pub fn find_msbuild(target: &str) -> Option<Tool> {
- // VS 15 (2017) changed how to locate msbuild
- if let Some(r) = find_msbuild_vs16(target) {
- return Some(r);
- } else if let Some(r) = find_msbuild_vs15(target) {
- return Some(r);
- } else {
- find_old_msbuild(target)
- }
- }
-
- fn find_msbuild_vs15(target: &str) -> Option<Tool> {
- find_tool_in_vs15_path(r"MSBuild\15.0\Bin\MSBuild.exe", target)
- }
-
- fn find_old_msbuild(target: &str) -> Option<Tool> {
- let key = r"SOFTWARE\Microsoft\MSBuild\ToolsVersions";
- LOCAL_MACHINE
- .open(key.as_ref())
- .ok()
- .and_then(|key| {
- max_version(&key).and_then(|(_vers, key)| key.query_str("MSBuildToolsPath").ok())
- })
- .map(|path| {
- let mut path = PathBuf::from(path);
- path.push("MSBuild.exe");
- let mut tool = Tool::new(path);
- if target.contains("x86_64") {
- tool.env.push(("Platform".into(), "X64".into()));
- }
- tool
- })
- }
-}
generated by cgit v1.2.3 (git 2.46.0) at 2024-11-22 23:26:01 +0000