Struct cfg_expr::targets::Arch

source ·

pub struct Arch(pub Cow<'static, str>);

Expand description

The “architecture” field

Tuple Fields§

§0: Cow<'static, str>

Implementations§

source §

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

Constructs a new instance of this field.

This method accepts both owned Strings and &'static strs.

Examples found in repository ?

src/expr.rs (lines 440-442)

    fn to_pred<'a>(&self, s: &'a str) -> Predicate<'a> {
        use InnerPredicate as IP;
        use Predicate::{
            DebugAssertions, Feature, Flag, KeyValue, ProcMacro, Target, TargetFeature, Test,
        };

        match self {
            IP::Target(it) => match &it.which {
                Which::Abi => Target(TargetPredicate::Abi(targ::Abi::new(
                    s[it.span.clone().unwrap()].to_owned(),
                ))),
                Which::Arch => Target(TargetPredicate::Arch(targ::Arch::new(
                    s[it.span.clone().unwrap()].to_owned(),
                ))),
                Which::Os => Target(TargetPredicate::Os(targ::Os::new(
                    s[it.span.clone().unwrap()].to_owned(),
                ))),
                Which::Vendor => Target(TargetPredicate::Vendor(targ::Vendor::new(
                    s[it.span.clone().unwrap()].to_owned(),
                ))),
                Which::Env => Target(TargetPredicate::Env(targ::Env::new(
                    s[it.span.clone().unwrap()].to_owned(),
                ))),
                Which::Family => Target(TargetPredicate::Family(targ::Family::new(
                    s[it.span.clone().unwrap()].to_owned(),
                ))),
                Which::Endian(end) => Target(TargetPredicate::Endian(*end)),
                Which::HasAtomic(has_atomic) => Target(TargetPredicate::HasAtomic(*has_atomic)),
                Which::Panic => Target(TargetPredicate::Panic(targ::Panic::new(
                    s[it.span.clone().unwrap()].to_owned(),
                ))),
                Which::PointerWidth(pw) => Target(TargetPredicate::PointerWidth(*pw)),
            },
            IP::Test => Test,
            IP::DebugAssertions => DebugAssertions,
            IP::ProcMacro => ProcMacro,
            IP::Feature(rng) => Feature(&s[rng.clone()]),
            IP::TargetFeature(rng) => TargetFeature(&s[rng.clone()]),
            IP::Other { identifier, value } => match value {
                Some(vs) => KeyValue {
                    key: &s[identifier.clone()],
                    val: &s[vs.clone()],
                },
                None => Flag(&s[identifier.clone()]),
            },
        }
    }

source

pub const fn new_const(val: &'static str) -> Self

Constructs a new instance of this field from a &'static str.

Examples found in repository ?

src/targets/builtins.rs (line 2530)

    pub const aarch64: Arch = Arch::new_const("aarch64");
    pub const arm: Arch = Arch::new_const("arm");
    pub const avr: Arch = Arch::new_const("avr");
    pub const bpf: Arch = Arch::new_const("bpf");
    pub const hexagon: Arch = Arch::new_const("hexagon");
    pub const m68k: Arch = Arch::new_const("m68k");
    pub const mips: Arch = Arch::new_const("mips");
    pub const mips64: Arch = Arch::new_const("mips64");
    pub const msp430: Arch = Arch::new_const("msp430");
    pub const nvptx64: Arch = Arch::new_const("nvptx64");
    pub const powerpc: Arch = Arch::new_const("powerpc");
    pub const powerpc64: Arch = Arch::new_const("powerpc64");
    pub const riscv32: Arch = Arch::new_const("riscv32");
    pub const riscv64: Arch = Arch::new_const("riscv64");
    pub const s390x: Arch = Arch::new_const("s390x");
    pub const sparc: Arch = Arch::new_const("sparc");
    pub const sparc64: Arch = Arch::new_const("sparc64");
    pub const wasm32: Arch = Arch::new_const("wasm32");
    pub const wasm64: Arch = Arch::new_const("wasm64");
    pub const x86: Arch = Arch::new_const("x86");
    pub const x86_64: Arch = Arch::new_const("x86_64");