platforms 0.1.3

Rust platform registry with information about valid Rust platforms (target triple, target_arch, target_os) sourced from Rust Forge
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

use core::str::FromStr;
#[cfg(feature = "serde")]
use serde::{Deserialize, Deserializer, Serialize, Serializer};

use error::Error;

/// `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. `target::Env::GNU`)
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
pub enum Env {
    /// `gnu`: The GNU C Library (glibc)
    GNU,

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

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

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

    /// Unknown target environment
    Unknown,
}

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

impl FromStr for Env {
    type Err = Error;

    /// Create a new `Env` from the given string
    fn from_str(env_name: &str) -> Result<Self, Self::Err> {
        let env = match env_name {
            "gnu" => Env::GNU,
            "msvc" => Env::MSVC,
            "musl" => Env::Musl,
            "uclibc" => Env::uClibc,
            _ => return Err(Error),
        };

        Ok(env)
    }
}

#[cfg(feature = "serde")]
impl Serialize for Env {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(self.as_str())
    }
}

#[cfg(all(feature = "serde", feature = "std"))]
impl<'de> Deserialize<'de> for Env {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        // TODO: no_std support
        use std::string::String;
        Ok(Self::from_str(&String::deserialize(deserializer)?).unwrap_or(Env::Unknown))
    }
}

// Detect and expose `target_env` as a constant
// Whether this is a good idea is somewhat debatable

#[cfg(target_env = "gnu")]
/// `target_env` when building this crate: `gnu`
pub const TARGET_ENV: Option<Env> = Some(Env::GNU);

#[cfg(target_env = "msvc")]
/// `target_env` when building this crate: `msvc`
pub const TARGET_ENV: Option<Env> = Some(Env::MSVC);

#[cfg(target_env = "musl")]
/// `target_env` when building this crate: `musl`
pub const TARGET_ENV: Option<Env> = Some(Env::Musl);

#[cfg(target_env = "uclibc")]
/// `target_env` when building this crate: `uclibc`
pub const TARGET_ENV: Option<Env> = Some(Env::uClibc);

#[cfg(
    not(
        any(
            target_env = "gnu",
            target_env = "msvc",
            target_env = "musl",
            target_env = "uclibc",
        )
    )
)]
/// `target_env` when building this crate: none
pub const TARGET_ENV: Option<Env> = None;