Enum target_spec::TargetSpec

pub enum TargetSpec {
    Triple(Triple),
    Expression(TargetExpression),
}

A parsed target specification or triple, as found in a Cargo.toml file.

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

Triple(Triple)

An exact target parsed from a triple.

Parsed from strings like "i686-pc-windows-gnu".

Expression(TargetExpression)

A complex expression.

Parsed from strings like "cfg(any(windows, target_arch = \"x86_64\"))".

Implementations

impl TargetSpec

pub fn new(input: impl Into<Cow<'static, str>>) -> Result<Self, Error>

Creates a new target from a string.

This constructor covers many, but not all, cases. To customize target spec construction, use Self::looks_like_expression.

pub fn looks_like_expression(input: &str) -> bool

Returns true if the input resembles a target expression.

This simply checks that the input begins with "cfg(".

Examples

looks_like_expression can be used to customize target spec construction. For example, it can be used to resolve custom targets:

use target_spec::{Error, TargetExpression, TargetSpec, Triple};

fn make_target_spec(input: &str) -> Result<TargetSpec, Error> {
    if TargetSpec::looks_like_expression(input) {
        Ok(TargetSpec::Expression(TargetExpression::new(&input)?))
    } else {
        let json = "{}";  // perform custom target resolution here
        let triple = Triple::new_custom(input.to_owned(), json)
            .map_err(Error::CustomTripleCreate)?;
        Ok(TargetSpec::Triple(triple))
    }
}

pub fn eval(&self, platform: &Platform) -> Option<bool>

Evaluates this specification against the given platform.

Returns Some(true) if there’s a match, Some(false) if there’s none, or None if the result of the evaluation is unknown (typically found if target features are involved).

Trait Implementations

impl Clone for TargetSpec

fn clone(&self) -> TargetSpec

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TargetSpec

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromStr for TargetSpec

type Err = Error

The associated error which can be returned from parsing.

fn from_str(input: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.