      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

    // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
    // file at the top-level directory of this distribution and at
    // http://rust-lang.org/COPYRIGHT.
    //
    // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
    // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
    // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
    // option. This file may not be copied, modified, or distributed
    // except according to those terms.

    //! Raw OS-specific types for the current platform/architecture

    #![stable(feature = "raw_os", since = "1.1.0")]

    use fmt;

    #[cfg(any(all(target_os = "linux", any(target_arch = "aarch64",
                                           target_arch = "arm",
                                           target_arch = "powerpc",
                                           target_arch = "powerpc64",
                                           target_arch = "s390x")),
              all(target_os = "android", any(target_arch = "aarch64",
                                             target_arch = "arm")),
              all(target_os = "fuchsia", target_arch = "aarch64")))]
    #[stable(feature = "raw_os", since = "1.1.0")] pub type c_char = u8;
    #[cfg(not(any(all(target_os = "linux", any(target_arch = "aarch64",
                                               target_arch = "arm",
                                               target_arch = "powerpc",
                                               target_arch = "powerpc64",
                                               target_arch = "s390x")),
                  all(target_os = "android", any(target_arch = "aarch64",
                                                 target_arch = "arm")),
                  all(target_os = "fuchsia", target_arch = "aarch64"))))]
    #[stable(feature = "raw_os", since = "1.1.0")] pub type c_char = i8;
    #[stable(feature = "raw_os", since = "1.1.0")] pub type c_schar = i8;
    #[stable(feature = "raw_os", since = "1.1.0")] pub type c_uchar = u8;
    #[stable(feature = "raw_os", since = "1.1.0")] pub type c_short = i16;
    #[stable(feature = "raw_os", since = "1.1.0")] pub type c_ushort = u16;
    #[stable(feature = "raw_os", since = "1.1.0")] pub type c_int = i32;
    #[stable(feature = "raw_os", since = "1.1.0")] pub type c_uint = u32;
    #[cfg(any(target_pointer_width = "32", windows))]
    #[stable(feature = "raw_os", since = "1.1.0")] pub type c_long = i32;
    #[cfg(any(target_pointer_width = "32", windows))]
    #[stable(feature = "raw_os", since = "1.1.0")] pub type c_ulong = u32;
    #[cfg(all(target_pointer_width = "64", not(windows)))]
    #[stable(feature = "raw_os", since = "1.1.0")] pub type c_long = i64;
    #[cfg(all(target_pointer_width = "64", not(windows)))]
    #[stable(feature = "raw_os", since = "1.1.0")] pub type c_ulong = u64;
    #[stable(feature = "raw_os", since = "1.1.0")] pub type c_longlong = i64;
    #[stable(feature = "raw_os", since = "1.1.0")] pub type c_ulonglong = u64;
    #[stable(feature = "raw_os", since = "1.1.0")] pub type c_float = f32;
    #[stable(feature = "raw_os", since = "1.1.0")] pub type c_double = f64;

    /// Type used to construct void pointers for use with C.
    ///
    /// This type is only useful as a pointer target. Do not use it as a
    /// return type for FFI functions which have the `void` return type in
    /// C. Use the unit type `()` or omit the return type instead.
    // NB: For LLVM to recognize the void pointer type and by extension
    //     functions like malloc(), we need to have it represented as i8* in
    //     LLVM bitcode. The enum used here ensures this and prevents misuse
    //     of the "raw" type by only having private variants.. We need two
    //     variants, because the compiler complains about the repr attribute
    //     otherwise.
    #[repr(u8)]
    #[stable(feature = "raw_os", since = "1.1.0")]
    pub enum c_void {
        #[unstable(feature = "c_void_variant", reason = "should not have to exist",
                   issue = "0")]
        #[doc(hidden)] __variant1,
        #[unstable(feature = "c_void_variant", reason = "should not have to exist",
                   issue = "0")]
        #[doc(hidden)] __variant2,
    }

    #[stable(feature = "std_debug", since = "1.16.0")]
    impl fmt::Debug for c_void {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            f.pad("c_void")
        }
    }

    #[cfg(test)]
    #[allow(unused_imports)]
    mod tests {
        use any::TypeId;
        use libc;
        use mem;

        macro_rules! ok {
            ($($t:ident)*) => {$(
                assert!(TypeId::of::<libc::$t>() == TypeId::of::<raw::$t>(),
                        "{} is wrong", stringify!($t));
            )*}
        }

        #[test]
        fn same() {
            use os::raw;
            ok!(c_char c_schar c_uchar c_short c_ushort c_int c_uint c_long c_ulong
                c_longlong c_ulonglong c_float c_double);
        }
    }

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand 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`)