1
-2
-3
-4
-5
-6
-7
-8
-9
-10
-11
-12
-13
-14
-15
-16
-17
-18
-19
-20
-21
-22
-23
-24
-25
-26
-27
-28
-29
-30
-31
-32
-33
-34
-35
-36
-37
-38
-39
-40
-41
-42
-43
-44
-45
-46
-47
-48
-49
-50
-51
-52
-53
-54
-55
-56
-57
-58
-59
-60
-61
-62
-63
-64
-65
-66
-67
-68
-69
-70
-71
-72
-73
-74
-75
-76
-77
-78
-79
-80
-81
-82
-83
-84
-85
-86
-87
-88
-89
-90
-91
-92
-93
-94
-95
-96
-97
-98
-99
-100
-101
-102
-103
-104
-105
-106
-107
-108
-109
-110
-111
-112
-113
-114
-115
-116
-117
-118
-119
-120
-121
-122
-123
-124
-125
-126
-127
-128
-129
-130
-131
-132
-133
-134
-135
-136
-137
-138
-139
-140
-141
-142
-143
-144
-145
-146
-147
-148
-149
-150
-151
-152
-153
-154
-155
-156
-157
-158
-159
-160
-161
-162
-163
-164
-165
-166
-167
-168
-169
-170
-171
-172
-173
-174
-175
-176
-

//! A macro for defining `#[cfg]` if-else statements.
-//!
-//! The macro provided by this crate, `cfg_if`, is similar to the `if/elif` C
-//! preprocessor macro by allowing definition of a cascade of `#[cfg]` cases,
-//! emitting the implementation which matches first.
-//!
-//! This allows you to conveniently provide a long list `#[cfg]`'d blocks of code
-//! without having to rewrite each clause multiple times.
-//!
-//! # Example
-//!
-//! ```
-//! cfg_if::cfg_if! {
-//!     if #[cfg(unix)] {
-//!         fn foo() { /* unix specific functionality */ }
-//!     } else if #[cfg(target_pointer_width = "32")] {
-//!         fn foo() { /* non-unix, 32-bit functionality */ }
-//!     } else {
-//!         fn foo() { /* fallback implementation */ }
-//!     }
-//! }
-//!
-//! # fn main() {}
-//! ```
-
-#![no_std]
-#![doc(html_root_url = "https://docs.rs/cfg-if")]
-#![deny(missing_docs)]
-#![cfg_attr(test, deny(warnings))]
-
-/// The main macro provided by this crate. See crate documentation for more
-/// information.
-#[macro_export]
-macro_rules! cfg_if {
-    // match if/else chains with a final `else`
-    ($(
-        if #[cfg($meta:meta)] { $($tokens:tt)* }
-    ) else * else {
-        $($tokens2:tt)*
-    }) => {
-        $crate::cfg_if! {
-            @__items
-            () ;
-            $( ( ($meta) ($($tokens)*) ), )*
-            ( () ($($tokens2)*) ),
-        }
-    };
-
-    // match if/else chains lacking a final `else`
-    (
-        if #[cfg($i_met:meta)] { $($i_tokens:tt)* }
-        $(
-            else if #[cfg($e_met:meta)] { $($e_tokens:tt)* }
-        )*
-    ) => {
-        $crate::cfg_if! {
-            @__items
-            () ;
-            ( ($i_met) ($($i_tokens)*) ),
-            $( ( ($e_met) ($($e_tokens)*) ), )*
-            ( () () ),
-        }
-    };
-
-    // Internal and recursive macro to emit all the items
-    //
-    // Collects all the negated cfgs in a list at the beginning and after the
-    // semicolon is all the remaining items
-    (@__items ($($not:meta,)*) ; ) => {};
-    (@__items ($($not:meta,)*) ; ( ($($m:meta),*) ($($tokens:tt)*) ), $($rest:tt)*) => {
-        // Emit all items within one block, applying an appropriate #[cfg]. The
-        // #[cfg] will require all `$m` matchers specified and must also negate
-        // all previous matchers.
-        #[cfg(all($($m,)* not(any($($not),*))))] $crate::cfg_if! { @__identity $($tokens)* }
-
-        // Recurse to emit all other items in `$rest`, and when we do so add all
-        // our `$m` matchers to the list of `$not` matchers as future emissions
-        // will have to negate everything we just matched as well.
-        $crate::cfg_if! { @__items ($($not,)* $($m,)*) ; $($rest)* }
-    };
-
-    // Internal macro to make __apply work out right for different match types,
-    // because of how macros matching/expand stuff.
-    (@__identity $($tokens:tt)*) => {
-        $($tokens)*
-    };
-}
-
-#[cfg(test)]
-mod tests {
-    cfg_if! {
-        if #[cfg(test)] {
-            use core::option::Option as Option2;
-            fn works1() -> Option2<u32> { Some(1) }
-        } else {
-            fn works1() -> Option<u32> { None }
-        }
-    }
-
-    cfg_if! {
-        if #[cfg(foo)] {
-            fn works2() -> bool { false }
-        } else if #[cfg(test)] {
-            fn works2() -> bool { true }
-        } else {
-            fn works2() -> bool { false }
-        }
-    }
-
-    cfg_if! {
-        if #[cfg(foo)] {
-            fn works3() -> bool { false }
-        } else {
-            fn works3() -> bool { true }
-        }
-    }
-
-    cfg_if! {
-        if #[cfg(test)] {
-            use core::option::Option as Option3;
-            fn works4() -> Option3<u32> { Some(1) }
-        }
-    }
-
-    cfg_if! {
-        if #[cfg(foo)] {
-            fn works5() -> bool { false }
-        } else if #[cfg(test)] {
-            fn works5() -> bool { true }
-        }
-    }
-
-    #[test]
-    fn it_works() {
-        assert!(works1().is_some());
-        assert!(works2());
-        assert!(works3());
-        assert!(works4().is_some());
-        assert!(works5());
-    }
-
-    #[test]
-    #[allow(clippy::assertions_on_constants)]
-    fn test_usage_within_a_function() {
-        cfg_if! {if #[cfg(debug_assertions)] {
-            // we want to put more than one thing here to make sure that they
-            // all get configured properly.
-            assert!(cfg!(debug_assertions));
-            assert_eq!(4, 2+2);
-        } else {
-            assert!(works1().is_some());
-            assert_eq!(10, 5+5);
-        }}
-    }
-
-    trait Trait {
-        fn blah(&self);
-    }
-
-    #[allow(dead_code)]
-    struct Struct;
-
-    impl Trait for Struct {
-        cfg_if! {
-            if #[cfg(feature = "blah")] {
-                fn blah(&self) {
-                    unimplemented!();
-                }
-            } else {
-                fn blah(&self) {
-                    unimplemented!();
-                }
-            }
-        }
-    }
-}
-

-