pub enum TargetSpec {
Expression(TargetSpecExpression),
PlainString(TargetSpecPlainString),
}
Expand description
A parsed target specification or triple string, as found in a Cargo.toml
file.
§Expressions and triple strings
Cargo supports platform-specific dependencies. These dependencies can be specified in one of two ways:
# 1. As Rust-like `#[cfg]` syntax.
[target.'cfg(all(unix, target_arch = "x86_64"))'.dependencies]
native = { path = "native/x86_64" }
# 2. Listing out the full target triple.
[target.x86_64-pc-windows-gnu.dependencies]
winhttp = "0.4.0"
§The cfg()
syntax
The first cfg()
syntax is
represented via the TargetSpec::Expression
variant. This variant represents an arbitrary
expression against certain properties of the target. To evaluate a Platform
against this
variant, target-spec
builds an expression tree (currently via
cfg-expr
).
§Plain string syntax
The second syntax, listing just the name of a platform, is represented via the
TargetSpec::PlainString
variant. In target-spec’s model, the contained data is arbitrary
and used only for string comparisons. For example,
TargetSpec::PlainString("x86_64-pc-windows-gnu")
will match the x86_64-pc-windows-gnu
platform.
target-spec
checks that the string looks sufficiently like a triple. This check is duplicated
from Cargo’s own check and is implemented in Self::looks_like_plain_string
.
§Examples
use target_spec::{Platform, TargetFeatures, TargetSpec};
let i686_windows = Platform::new("i686-pc-windows-gnu", TargetFeatures::Unknown).unwrap();
let x86_64_mac = Platform::new("x86_64-apple-darwin", TargetFeatures::none()).unwrap();
let i686_linux = Platform::new(
"i686-unknown-linux-gnu",
TargetFeatures::features(["sse2"].iter().copied()),
).unwrap();
let spec: TargetSpec = "cfg(any(windows, target_arch = \"x86_64\"))".parse().unwrap();
assert_eq!(spec.eval(&i686_windows), Some(true), "i686 Windows");
assert_eq!(spec.eval(&x86_64_mac), Some(true), "x86_64 MacOS");
assert_eq!(spec.eval(&i686_linux), Some(false), "i686 Linux (should not match)");
let spec: TargetSpec = "cfg(any(target_feature = \"sse2\", target_feature = \"sse\"))".parse().unwrap();
assert_eq!(spec.eval(&i686_windows), None, "i686 Windows features are unknown");
assert_eq!(spec.eval(&x86_64_mac), Some(false), "x86_64 MacOS matches no features");
assert_eq!(spec.eval(&i686_linux), Some(true), "i686 Linux matches some features");
Variants§
Expression(TargetSpecExpression)
A complex expression.
Parsed from strings like "cfg(any(windows, target_arch = \"x86_64\"))"
.
PlainString(TargetSpecPlainString)
A plain string representing a triple.
This string hasn’t been validated because it may represent a custom platform. To validate
this string, use Self::is_known
.
Implementations§
Source§impl TargetSpec
impl TargetSpec
Sourcepub fn new(input: impl Into<Cow<'static, str>>) -> Result<Self, Error>
pub fn new(input: impl Into<Cow<'static, str>>) -> Result<Self, Error>
Creates a new target spec from a string.
Sourcepub fn looks_like_expression(input: &str) -> bool
pub fn looks_like_expression(input: &str) -> bool
Returns true if the input will be parsed as a target expression.
In other words, returns true if the input begins with "cfg("
.
Sourcepub fn looks_like_plain_string(input: &str) -> bool
pub fn looks_like_plain_string(input: &str) -> bool
Returns true if the input will be understood to be a plain string.
This check is borrowed from
cargo-platform
.
Note that this currently accepts an empty string. This matches Cargo’s behavior as of Rust 1.70.
Sourcepub fn is_known(&self) -> bool
pub fn is_known(&self) -> bool
Returns true if an input looks like it’s known and understood.
- For
Self::Expression
, the innerTargetSpecExpression
has already been parsed as valid, so this returns true. - For
Self::PlainString
, this returns true if the string matches a builtin triple or has heuristically been determined to be valid.
This method does not take into account custom platforms. If you know about custom platforms, consider checking against those as well.
Trait Implementations§
Source§impl Clone for TargetSpec
impl Clone for TargetSpec
Source§fn clone(&self) -> TargetSpec
fn clone(&self) -> TargetSpec
1.0.0 · Source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read more