# Conditional compilation

> Syntax
> ConfigurationPredicate :
> ConfigurationOption
> | ConfigurationAll
> | ConfigurationAny
> | ConfigurationNot

> ConfigurationOption :
> IDENTIFIER (`=` (STRING_LITERAL | RAW_STRING_LITERAL))?

> ConfigurationAll
> `all` `(` ConfigurationPredicateList? `)`

> ConfigurationAny
> `any` `(` ConfigurationPredicateList? `)`

> ConfigurationNot
> `not` `(` ConfigurationPredicate `)`

> ConfigurationPredicateList
> ConfigurationPredicate (`,` ConfigurationPredicate)* `,`?

Conditionally compiled source code is source code that may or may not be considered a part of the source code depending on certain conditions. Source code can be conditionally compiled using attributes, `cfg` and `cfg_attr`, and the built-in `cfg` macro. These conditions are based on the target architecture of the compiled crate, arbitrary values passed to the compiler, and a few other miscellaneous things further described below in detail.

Each form of conditional compilation takes a configuration predicate that evaluates to true or false. The predicate is one of the following:

- A configuration option. It is true if the option is set and false if it is unset.
- `all()` with a comma separated list of configuration predicates. It is false if at least one predicate is false. If there are no predicates, it is true.
- `any()` with a comma separated list of configuration predicates. It is true if at least one predicate is true. If there are no predicates, it is false.
- `not()` with a configuration predicate. It is true if its predicate is false and false if its predicate is true.

Configuration options are names and key-value pairs that are either set or unset. Names are written as a single identifier such as, for example, `unix`. Key-value pairs are written as an identifier, `=`, and then a string. For example, `target_arch = "x86_64"` is a configuration option.

> Note: Whitespace around the `=` is ignored. `foo="bar"` and `foo = "bar"` are equivalent configuration options.

Keys are not unique in the set of key-value configuration options. For example, both `feature = "std"` and `feature = "serde"` can be set at the same time.

## Set Configuration Options

Which configuration options are set is determined statically during the compilation of the crate. Certain options are compiler-set based on data about the compilation. Other options are arbitrarily-set, set based on input passed to the compiler outside of the code. It is not possible to set a configuration option from within the source code of the crate being compiled.

> Note: For `rustc`, arbitrary-set configuration options are set using the `--cfg` flag.

Warning: It is possible for arbitrarily-set configuration options to have the same value as compiler-set configuration options. For example, it is possible to do `rustc --cfg "unix" program.rs` while compiling to a Windows target, and have both `unix` and `windows` configuration options set at the same time. It is unwise to actually do this.

### `target_arch`

Key-value option set once with the target's CPU architecture. The value is similar to the first element of the platform's target triple, but not identical.

Example values:

- `"x86"`
- `"x86_64"`
- `"mips"`
- `"powerpc"`
- `"powerpc64"`
- `"arm"`
- `"aarch64"`

### `target_os`

Key-value option set once with the target's operating system. This value is similar to the second and third element of the platform's target triple.

Example values:

- `"windows"`
- `"macos"`
- `"ios"`
- `"linux"`
- `"android"`
- `"freebsd"`
- `"dragonfly"`
- `"bitrig"`
- `"openbsd"`
- `"netbsd"`

### `target_family`

Key-value option set at most once with the target's operating system value.

Example values:

- `"unix"`
- `"windows"`

### `unix` and `windows`

`unix` is set if `target_family = "unix"` is set and `windows` is set if `target_family = "windows"` is set.

### `target_env`

Key-value option set with further disambiguating information about the target platform with information about the ABI or `libc` used. For historical reasons, this value is only defined as not the empty-string when actually needed for disambiguation. Thus, for example, on many GNU platforms, this value will be empty. This value is similar to the fourth element of the platform's target triple. One difference is that embedded ABIs such as `gnueabihf` will simply define `target_env` as `"gnu"`.

Example values:

- `""`
- `"gnu"`
- `"msvc"`
- `"musl"`

### `target_endian`

Key-value option set once with either a value of "little" or "big" depending on the endianness of the target's CPU.

### `target_pointer_width`

Key-value option set once with the target's pointer width in bits. For example, for targets with 32-bit pointers, this is set to `"32"`. Likewise, it is set to `"64"` for targets with 64-bit pointers.

### `target_has_atomic`

Key-value option set for each integer size on which the target can perform atomic operations.

Possible values:

- `"8"`
- `"16"`
- `"32"`
- `"64"`
- `"128"`
- `"ptr"`

### `target_vendor`

Key-value option set once with the vendor of the target.

Example values:

- `"apple"`
- `"pc"`
- `"sgx"`
- `"unknown"`

### `test`

Enabled when compiling the test harness. Done with `rustc` by using the `--test` flag.

### `debug_assertions`

Enabled by default when compiling without optimizations. This can be used to enable extra debugging code in development but not in production. For example, it controls the behavior of the standard library's `debug_assert!` macro.

### `proc_macro`

Set when the crate being compiled is being compiled with the `proc_macro` crate type.

## Forms of conditional compilation

### The `cfg` attribute

> Syntax
> CfgAttrAttribute :
> `cfg` `(` ConfigurationPredicate `)`

The `cfg` attribute conditionally includes the thing it is attached to based on a configuration predicate.

It is written as `cfg`, `(`, a configuration predicate, and finally `)`.

If the predicate is true, the thing is rewritten to not have the `cfg` attribute on it. If the predicate is false, the thing is removed from the source code.

Some examples on functions:

    # #![allow(unused_variables)]
    #fn main() {
    // The function is only included in the build when compiling for macOS
    #[cfg(target_os = "macos")]
    fn macos_only() {
      // ...
    }

    // This function is only included when either foo or bar is defined
    #[cfg(any(foo, bar))]
    fn needs_foo_or_bar() {
      // ...
    }

    // This function is only included when compiling for a unixish OS with a 32-bit
    // architecture
    #[cfg(all(unix, target_pointer_width = "32"))]
    fn on_32bit_unix() {
      // ...
    }

    // This function is only included when foo is not defined
    #[cfg(not(foo))]
    fn needs_not_foo() {
      // ...
    }
    #}

The `cfg` attribute is allowed anywhere attributes are allowed except on generic parameters.

### The `cfg_attr` attribute

> Syntax
> CfgAttrAttribute :
> `cfg_attr` `(` ConfigurationPredicate `,` MetaItem `,`? `)`

The `cfg_attr` attribute conditionally includes attributes based on a configuration predicate.

It is written as `cfg_attr` followed by `(`, a configuration predicate, a metaitem, an optional `,`, and finally a `)`.

When the configuration predicate is true, this attribute expands out to be an attribute of the attribute metaitem. For example, the following module will either be found at `linux.rs` or `windows.rs` based on the target.

    #[cfg_attr(linux, path = "linux.rs")]
    #[cfg_attr(windows, path = "windows.rs")]
    mod os;

> Note: The `cfg_attr` can expand to another `cfg_attr`. For example, `#[cfg_attr(linux, cfg_attr(feature = "multithreaded", some_other_attribute))` is valid. This example would be equivalent to `#[cfg_attr(all(linux, feature ="multithreaded"), some_other_attribute)]`.

The `cfg_attr` attribute is allowed anywhere attributes are allowed except on generic parameters.

### The `cfg` macro

The built-in `cfg` macro takes in a single configuration predicate and evaluates to the `true` literal when the predicate is true and the `false` literal when it is false.

For example:

    # #![allow(unused_variables)]
    #fn main() {
    let machine_kind = if cfg!(unix) {
      "unix"
    } else if cfg!(windows) {
      "windows"
    } else {
      "unknown"
    };

    println!("I'm running on a {} machine!", machine_kind);
    #}