     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

    /// A macro for defining #[cfg] if-else statements.
    ///
    /// This 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.
    macro_rules! cfg_if {
        ($(
            if #[cfg($($meta:meta),*)] { $($it:item)* }
        ) else * else {
            $($it2:item)*
        }) => {
            __cfg_if_items! {
                () ;
                $( ( ($($meta),*) ($($it)*) ), )*
                ( () ($($it2)*) ),
            }
        }
    }

    macro_rules! __cfg_if_items {
        (($($not:meta,)*) ; ) => {};
        (($($not:meta,)*) ; ( ($($m:meta),*) ($($it:item)*) ), $($rest:tt)*) => {
            __cfg_if_apply! { cfg(all(not(any($($not),*)), $($m,)*)), $($it)* }
            __cfg_if_items! { ($($not,)* $($m,)*) ; $($rest)* }
        }
    }

    macro_rules! __cfg_if_apply {
        ($m:meta, $($it:item)*) => {
            $(#[$m] $it)*
        }
    }

    macro_rules! s {
        ($($(#[$attr:meta])* pub struct $i:ident { $($field:tt)* })*) => ($(
            __item! {
                #[repr(C)]
                $(#[$attr])*
                pub struct $i { $($field)* }
            }
            impl ::dox::Copy for $i {}
            impl ::dox::Clone for $i {
                fn clone(&self) -> $i { *self }
            }
        )*)
    }

    macro_rules! f {
        ($(pub fn $i:ident($($arg:ident: $argty:ty),*) -> $ret:ty {
            $($body:stmt);*
        })*) => ($(
            #[inline]
            #[cfg(not(dox))]
            pub unsafe extern fn $i($($arg: $argty),*) -> $ret {
                $($body);*
            }

            #[cfg(dox)]
            #[allow(dead_code)]
            pub unsafe extern fn $i($($arg: $argty),*) -> $ret {
                loop {}
            }
        )*)
    }

    macro_rules! __item {
        ($i:item) => ($i)
    }

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)