| 1 |
//! A macro for defining `#[cfg]` if-else statements. |
| 2 |
//! |
| 3 |
//! The macro provided by this crate, `cfg_if`, is similar to the `if/elif` C |
| 4 |
//! preprocessor macro by allowing definition of a cascade of `#[cfg]` cases, |
| 5 |
//! emitting the implementation which matches first. |
| 6 |
//! |
| 7 |
//! This allows you to conveniently provide a long list `#[cfg]`'d blocks of code |
| 8 |
//! without having to rewrite each clause multiple times. |
| 9 |
//! |
| 10 |
//! # Example |
| 11 |
//! |
| 12 |
//! ``` |
| 13 |
//! cfg_if::cfg_if! { |
| 14 |
//! if #[cfg(unix)] { |
| 15 |
//! fn foo() { /* unix specific functionality */ } |
| 16 |
//! } else if #[cfg(target_pointer_width = "32")] { |
| 17 |
//! fn foo() { /* non-unix, 32-bit functionality */ } |
| 18 |
//! } else { |
| 19 |
//! fn foo() { /* fallback implementation */ } |
| 20 |
//! } |
| 21 |
//! } |
| 22 |
//! |
| 23 |
//! # fn main() {} |
| 24 |
//! ``` |
| 25 |
|
| 26 |
#![no_std] |
| 27 |
#![doc(html_root_url = "https://docs.rs/cfg-if")] |
| 28 |
#![deny(missing_docs)] |
| 29 |
#![cfg_attr(test, deny(warnings))] |
| 30 |
|
| 31 |
/// The main macro provided by this crate. See crate documentation for more |
| 32 |
/// information. |
| 33 |
#[macro_export] |
| 34 |
macro_rules! cfg_if { |
| 35 |
// match if/else chains with a final `else` |
| 36 |
($( |
| 37 |
if #[cfg($meta:meta)] { $($tokens:tt)* } |
| 38 |
) else * else { |
| 39 |
$($tokens2:tt)* |
| 40 |
}) => { |
| 41 |
$crate::cfg_if! { |
| 42 |
@__items |
| 43 |
() ; |
| 44 |
$( ( ($meta) ($($tokens)*) ), )* |
| 45 |
( () ($($tokens2)*) ), |
| 46 |
} |
| 47 |
}; |
| 48 |
|
| 49 |
// match if/else chains lacking a final `else` |
| 50 |
( |
| 51 |
if #[cfg($i_met:meta)] { $($i_tokens:tt)* } |
| 52 |
$( |
| 53 |
else if #[cfg($e_met:meta)] { $($e_tokens:tt)* } |
| 54 |
)* |
| 55 |
) => { |
| 56 |
$crate::cfg_if! { |
| 57 |
@__items |
| 58 |
() ; |
| 59 |
( ($i_met) ($($i_tokens)*) ), |
| 60 |
$( ( ($e_met) ($($e_tokens)*) ), )* |
| 61 |
( () () ), |
| 62 |
} |
| 63 |
}; |
| 64 |
|
| 65 |
// Internal and recursive macro to emit all the items |
| 66 |
// |
| 67 |
// Collects all the negated cfgs in a list at the beginning and after the |
| 68 |
// semicolon is all the remaining items |
| 69 |
(@__items ($($not:meta,)*) ; ) => {}; |
| 70 |
(@__items ($($not:meta,)*) ; ( ($($m:meta),*) ($($tokens:tt)*) ), $($rest:tt)*) => { |
| 71 |
// Emit all items within one block, applying an appropriate #[cfg]. The |
| 72 |
// #[cfg] will require all `$m` matchers specified and must also negate |
| 73 |
// all previous matchers. |
| 74 |
#[cfg(all($($m,)* not(any($($not),*))))] $crate::cfg_if! { @__identity $($tokens)* } |
| 75 |
|
| 76 |
// Recurse to emit all other items in `$rest`, and when we do so add all |
| 77 |
// our `$m` matchers to the list of `$not` matchers as future emissions |
| 78 |
// will have to negate everything we just matched as well. |
| 79 |
$crate::cfg_if! { @__items ($($not,)* $($m,)*) ; $($rest)* } |
| 80 |
}; |
| 81 |
|
| 82 |
// Internal macro to make __apply work out right for different match types, |
| 83 |
// because of how macros matching/expand stuff. |
| 84 |
(@__identity $($tokens:tt)*) => { |
| 85 |
$($tokens)* |
| 86 |
}; |
| 87 |
} |
| 88 |
|
| 89 |
#[cfg(test)] |
| 90 |
mod tests { |
| 91 |
cfg_if! { |
| 92 |
if #[cfg(test)] { |
| 93 |
use core::option::Option as Option2; |
| 94 |
fn works1() -> Option2<u32> { Some(1) } |
| 95 |
} else { |
| 96 |
fn works1() -> Option<u32> { None } |
| 97 |
} |
| 98 |
} |
| 99 |
|
| 100 |
cfg_if! { |
| 101 |
if #[cfg(foo)] { |
| 102 |
fn works2() -> bool { false } |
| 103 |
} else if #[cfg(test)] { |
| 104 |
fn works2() -> bool { true } |
| 105 |
} else { |
| 106 |
fn works2() -> bool { false } |
| 107 |
} |
| 108 |
} |
| 109 |
|
| 110 |
cfg_if! { |
| 111 |
if #[cfg(foo)] { |
| 112 |
fn works3() -> bool { false } |
| 113 |
} else { |
| 114 |
fn works3() -> bool { true } |
| 115 |
} |
| 116 |
} |
| 117 |
|
| 118 |
cfg_if! { |
| 119 |
if #[cfg(test)] { |
| 120 |
use core::option::Option as Option3; |
| 121 |
fn works4() -> Option3<u32> { Some(1) } |
| 122 |
} |
| 123 |
} |
| 124 |
|
| 125 |
cfg_if! { |
| 126 |
if #[cfg(foo)] { |
| 127 |
fn works5() -> bool { false } |
| 128 |
} else if #[cfg(test)] { |
| 129 |
fn works5() -> bool { true } |
| 130 |
} |
| 131 |
} |
| 132 |
|
| 133 |
#[test] |
| 134 |
fn it_works() { |
| 135 |
assert!(works1().is_some()); |
| 136 |
assert!(works2()); |
| 137 |
assert!(works3()); |
| 138 |
assert!(works4().is_some()); |
| 139 |
assert!(works5()); |
| 140 |
} |
| 141 |
|
| 142 |
#[test] |
| 143 |
#[allow(clippy::assertions_on_constants)] |
| 144 |
fn test_usage_within_a_function() { |
| 145 |
cfg_if! {if #[cfg(debug_assertions)] { |
| 146 |
// we want to put more than one thing here to make sure that they |
| 147 |
// all get configured properly. |
| 148 |
assert!(cfg!(debug_assertions)); |
| 149 |
assert_eq!(4, 2+2); |
| 150 |
} else { |
| 151 |
assert!(works1().is_some()); |
| 152 |
assert_eq!(10, 5+5); |
| 153 |
}} |
| 154 |
} |
| 155 |
|
| 156 |
trait Trait { |
| 157 |
fn blah(&self); |
| 158 |
} |
| 159 |
|
| 160 |
#[allow(dead_code)] |
| 161 |
struct Struct; |
| 162 |
|
| 163 |
impl Trait for Struct { |
| 164 |
cfg_if! { |
| 165 |
if #[cfg(feature = "blah")] { |
| 166 |
fn blah(&self) { |
| 167 |
unimplemented!(); |
| 168 |
} |
| 169 |
} else { |
| 170 |
fn blah(&self) { |
| 171 |
unimplemented!(); |
| 172 |
} |
| 173 |
} |
| 174 |
} |
| 175 |
} |
| 176 |
} |