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

use std::{
    borrow::Cow,
    env::{self, VarError},
    fmt,
};

// adapted from target/env.rs from platforms crate
/// `target_env`: target enviroment that disambiguates the target platform by ABI / libc.
/// This value is closely related to the fourth element of the platform target triple,
/// though it is not identical. For example, embedded ABIs such as `gnueabihf` will simply
/// define `target_env` as `"gnu"` (i.e. [`Env::GNU`])
#[derive(Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
#[non_exhaustive]
pub enum Env<'a> {
    /// `gnu`: The GNU C Library (glibc)
    GNU,

    /// `msvc`: Microsoft Visual C(++)
    MSVC,

    /// `musl`: Clean, efficient, standards-conformant libc implementation.
    Musl,

    /// `sgx`: Intel Software Guard Extensions (SGX) Enclave
    SGX,

    /// `uclibc`: C library for developing embedded Linux systems
    #[allow(non_camel_case_types)]
    uClibc,

    /// Unknown target environment
    Other(Cow<'a, str>),
}

impl<'a> Env<'a> {
    /// String representing this environment which matches `#[cfg(target_env)]`.
    pub fn as_str(&self) -> &str {
        match self {
            Env::GNU => "gnu",
            Env::MSVC => "msvc",
            Env::Musl => "musl",
            Env::SGX => "sgx",
            Env::uClibc => "uclibc",
            Env::Other(s) => s,
        }
    }

    /// Create a new [`Env`] from the given string.
    fn from_str(env_name: impl Into<Cow<'a, str>>) -> Self {
        let env_name = env_name.into();
        match env_name.as_ref() {
            "gnu" => Env::GNU,
            "msvc" => Env::MSVC,
            "musl" => Env::Musl,
            "sgx" => Env::SGX,
            "uclibc" => Env::uClibc,
            _ => Env::Other(env_name),
        }
    }

    pub fn target() -> Result<Self, VarError> {
        env::var("CARGO_CFG_TARGET_ENV").map(Self::from_str)
    }
}

impl<'a> fmt::Display for Env<'a> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(self.as_str())
    }
}