cargo-xwin 0.22.0

Cross compile Cargo project to Windows MSVC target with ease
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use std::path::{Path, PathBuf};
use std::process::Command;

use anyhow::Result;
use clap::{
    Parser, ValueEnum,
    builder::{PossibleValuesParser, TypedValueParser as _},
};
use fs_err as fs;

/// MSVC cross compiler
#[derive(Clone, Debug, Default, ValueEnum)]
pub enum CrossCompiler {
    /// clang-cl backend
    #[default]
    ClangCl,
    /// clang backend
    Clang,
}

/// common xwin options
#[derive(Clone, Debug, Parser)]
pub struct XWinOptions {
    /// The cross compiler to use
    #[arg(long, env = "XWIN_CROSS_COMPILER", default_value = "clang-cl")]
    pub cross_compiler: CrossCompiler,

    /// xwin cache directory
    #[arg(long, env = "XWIN_CACHE_DIR", hide = true)]
    pub xwin_cache_dir: Option<PathBuf>,

    /// The architectures to include in CRT/SDK
    #[arg(
        long,
        env = "XWIN_ARCH",
        value_parser = PossibleValuesParser::new(["x86", "x86_64", "aarch", "aarch64"])
            .map(|s| s.parse::<xwin::Arch>().unwrap()),
        value_delimiter = ',',
        default_values_t = vec![xwin::Arch::X86_64, xwin::Arch::Aarch64],
        hide = true,
    )]
    pub xwin_arch: Vec<xwin::Arch>,

    /// The variants to include
    #[arg(
        long,
        env = "XWIN_VARIANT",
        value_parser = PossibleValuesParser::new(["desktop", "onecore", /*"store",*/ "spectre"])
            .map(|s| s.parse::<xwin::Variant>().unwrap()),
        value_delimiter = ',',
        default_values_t = vec![xwin::Variant::Desktop],
        hide = true,
    )]
    pub xwin_variant: Vec<xwin::Variant>,

    /// The version to retrieve, can either be a major version of 15, 16, 17 or 18, or
    /// a "<major>.<minor>" version.
    #[arg(long, env = "XWIN_VERSION", default_value = "17")]
    pub xwin_version: u8,

    /// If specified, this is the version of the SDK that the user wishes to use
    /// instead of defaulting to the latest SDK available in the the manifest
    #[arg(long, env = "XWIN_SDK_VERSION")]
    pub xwin_sdk_version: Option<String>,
    /// If specified, this is the version of the MSVCRT that the user wishes to use
    /// instead of defaulting to the latest MSVCRT available in the the manifest
    #[arg(long, env = "XWIN_CRT_VERSION")]
    pub xwin_crt_version: Option<String>,

    /// Whether to include the Active Template Library (ATL) in the installation
    #[arg(long, env = "XWIN_INCLUDE_ATL")]
    pub xwin_include_atl: bool,

    /// Whether or not to include debug libs
    #[arg(long, env = "XWIN_INCLUDE_DEBUG_LIBS", hide = true)]
    pub xwin_include_debug_libs: bool,

    /// Whether or not to include debug symbols (PDBs)
    #[arg(long, env = "XWIN_INCLUDE_DEBUG_SYMBOLS", hide = true)]
    pub xwin_include_debug_symbols: bool,

    /// Number of times to retry HTTP requests when downloading
    #[arg(long, env = "XWIN_HTTP_RETRIES", default_value = "3")]
    pub xwin_http_retries: u32,
}

impl Default for XWinOptions {
    fn default() -> Self {
        Self {
            xwin_cache_dir: None,
            xwin_arch: vec![xwin::Arch::X86_64, xwin::Arch::Aarch64],
            xwin_variant: vec![xwin::Variant::Desktop],
            xwin_version: 17,
            xwin_sdk_version: None,
            xwin_crt_version: None,
            xwin_include_atl: false,
            xwin_include_debug_libs: false,
            xwin_include_debug_symbols: false,
            cross_compiler: CrossCompiler::ClangCl,
            xwin_http_retries: 3,
        }
    }
}

impl XWinOptions {
    pub fn apply_command_env(
        &self,
        manifest_path: Option<&Path>,
        cargo: &cargo_options::CommonOptions,
        cmd: &mut Command,
    ) -> Result<()> {
        let cache_dir = {
            let cache_dir = self.xwin_cache_dir.clone().unwrap_or_else(|| {
                dirs::cache_dir()
                    .unwrap_or_else(|| std::env::current_dir().expect("Failed to get current dir"))
                    .join(env!("CARGO_PKG_NAME"))
            });
            fs::create_dir_all(&cache_dir)?;
            cache_dir.canonicalize()?
        };
        match self.cross_compiler {
            CrossCompiler::ClangCl => {
                let clang_cl = crate::compiler::clang_cl::ClangCl::new(self);
                clang_cl.apply_command_env(manifest_path, cargo, cache_dir, cmd)?;
            }
            CrossCompiler::Clang => {
                let clang = crate::compiler::clang::Clang::new();
                clang.apply_command_env(manifest_path, cargo, cache_dir, cmd)?;
            }
        }
        Ok(())
    }
}