pub const _STDINT_H: u32 = 1;
pub const _FEATURES_H: u32 = 1;
pub const _DEFAULT_SOURCE: u32 = 1;
pub const __GLIBC_USE_ISOC2X: u32 = 0;
pub const __USE_ISOC11: u32 = 1;
pub const __USE_ISOC99: u32 = 1;
pub const __USE_ISOC95: u32 = 1;
pub const __USE_POSIX_IMPLICITLY: u32 = 1;
pub const _POSIX_SOURCE: u32 = 1;
pub const _POSIX_C_SOURCE: u32 = 200809;
pub const __USE_POSIX: u32 = 1;
pub const __USE_POSIX2: u32 = 1;
pub const __USE_POSIX199309: u32 = 1;
pub const __USE_POSIX199506: u32 = 1;
pub const __USE_XOPEN2K: u32 = 1;
pub const __USE_XOPEN2K8: u32 = 1;
pub const _ATFILE_SOURCE: u32 = 1;
pub const __USE_MISC: u32 = 1;
pub const __USE_ATFILE: u32 = 1;
pub const __USE_FORTIFY_LEVEL: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
pub const _STDC_PREDEF_H: u32 = 1;
pub const __STDC_IEC_559__: u32 = 1;
pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
pub const __STDC_ISO_10646__: u32 = 201706;
pub const __GNU_LIBRARY__: u32 = 6;
pub const __GLIBC__: u32 = 2;
pub const __GLIBC_MINOR__: u32 = 33;
pub const _SYS_CDEFS_H: u32 = 1;
pub const __glibc_c99_flexarr_available: u32 = 1;
pub const __WORDSIZE: u32 = 64;
pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
pub const __SYSCALL_WORDSIZE: u32 = 64;
pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
pub const __HAVE_GENERIC_SELECTION: u32 = 1;
pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
pub const _BITS_TYPES_H: u32 = 1;
pub const __TIMESIZE: u32 = 64;
pub const _BITS_TYPESIZES_H: u32 = 1;
pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
pub const __INO_T_MATCHES_INO64_T: u32 = 1;
pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
pub const __STATFS_MATCHES_STATFS64: u32 = 1;
pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
pub const __FD_SETSIZE: u32 = 1024;
pub const _BITS_TIME64_H: u32 = 1;
pub const _BITS_WCHAR_H: u32 = 1;
pub const _BITS_STDINT_INTN_H: u32 = 1;
pub const _BITS_STDINT_UINTN_H: u32 = 1;
pub const INT8_MIN: i32 = -128;
pub const INT16_MIN: i32 = -32768;
pub const INT32_MIN: i32 = -2147483648;
pub const INT8_MAX: u32 = 127;
pub const INT16_MAX: u32 = 32767;
pub const INT32_MAX: u32 = 2147483647;
pub const UINT8_MAX: u32 = 255;
pub const UINT16_MAX: u32 = 65535;
pub const UINT32_MAX: u32 = 4294967295;
pub const INT_LEAST8_MIN: i32 = -128;
pub const INT_LEAST16_MIN: i32 = -32768;
pub const INT_LEAST32_MIN: i32 = -2147483648;
pub const INT_LEAST8_MAX: u32 = 127;
pub const INT_LEAST16_MAX: u32 = 32767;
pub const INT_LEAST32_MAX: u32 = 2147483647;
pub const UINT_LEAST8_MAX: u32 = 255;
pub const UINT_LEAST16_MAX: u32 = 65535;
pub const UINT_LEAST32_MAX: u32 = 4294967295;
pub const INT_FAST8_MIN: i32 = -128;
pub const INT_FAST16_MIN: i64 = -9223372036854775808;
pub const INT_FAST32_MIN: i64 = -9223372036854775808;
pub const INT_FAST8_MAX: u32 = 127;
pub const INT_FAST16_MAX: u64 = 9223372036854775807;
pub const INT_FAST32_MAX: u64 = 9223372036854775807;
pub const UINT_FAST8_MAX: u32 = 255;
pub const UINT_FAST16_MAX: i32 = -1;
pub const UINT_FAST32_MAX: i32 = -1;
pub const INTPTR_MIN: i64 = -9223372036854775808;
pub const INTPTR_MAX: u64 = 9223372036854775807;
pub const UINTPTR_MAX: i32 = -1;
pub const PTRDIFF_MIN: i64 = -9223372036854775808;
pub const PTRDIFF_MAX: u64 = 9223372036854775807;
pub const SIG_ATOMIC_MIN: i32 = -2147483648;
pub const SIG_ATOMIC_MAX: u32 = 2147483647;
pub const SIZE_MAX: i32 = -1;
pub const WINT_MIN: u32 = 0;
pub const WINT_MAX: u32 = 4294967295;
pub const _SYS_TYPES_H: u32 = 1;
pub const __clock_t_defined: u32 = 1;
pub const __clockid_t_defined: u32 = 1;
pub const __time_t_defined: u32 = 1;
pub const __timer_t_defined: u32 = 1;
pub const __BIT_TYPES_DEFINED__: u32 = 1;
pub const _ENDIAN_H: u32 = 1;
pub const _BITS_ENDIAN_H: u32 = 1;
pub const __LITTLE_ENDIAN: u32 = 1234;
pub const __BIG_ENDIAN: u32 = 4321;
pub const __PDP_ENDIAN: u32 = 3412;
pub const _BITS_ENDIANNESS_H: u32 = 1;
pub const __BYTE_ORDER: u32 = 1234;
pub const __FLOAT_WORD_ORDER: u32 = 1234;
pub const LITTLE_ENDIAN: u32 = 1234;
pub const BIG_ENDIAN: u32 = 4321;
pub const PDP_ENDIAN: u32 = 3412;
pub const BYTE_ORDER: u32 = 1234;
pub const _BITS_BYTESWAP_H: u32 = 1;
pub const _BITS_UINTN_IDENTITY_H: u32 = 1;
pub const _SYS_SELECT_H: u32 = 1;
pub const __sigset_t_defined: u32 = 1;
pub const __timeval_defined: u32 = 1;
pub const _STRUCT_TIMESPEC: u32 = 1;
pub const FD_SETSIZE: u32 = 1024;
pub const _BITS_PTHREADTYPES_COMMON_H: u32 = 1;
pub const _THREAD_SHARED_TYPES_H: u32 = 1;
pub const _BITS_PTHREADTYPES_ARCH_H: u32 = 1;
pub const __SIZEOF_PTHREAD_MUTEX_T: u32 = 40;
pub const __SIZEOF_PTHREAD_ATTR_T: u32 = 56;
pub const __SIZEOF_PTHREAD_RWLOCK_T: u32 = 56;
pub const __SIZEOF_PTHREAD_BARRIER_T: u32 = 32;
pub const __SIZEOF_PTHREAD_MUTEXATTR_T: u32 = 4;
pub const __SIZEOF_PTHREAD_COND_T: u32 = 48;
pub const __SIZEOF_PTHREAD_CONDATTR_T: u32 = 4;
pub const __SIZEOF_PTHREAD_RWLOCKATTR_T: u32 = 8;
pub const __SIZEOF_PTHREAD_BARRIERATTR_T: u32 = 4;
pub const _THREAD_MUTEX_INTERNAL_H: u32 = 1;
pub const __PTHREAD_MUTEX_HAVE_PREV: u32 = 1;
pub const __have_pthread_attr_t: u32 = 1;
pub const __GNUC_VA_LIST: u32 = 1;
pub type __u_char = ::std::os::raw::c_uchar;
pub type __u_short = ::std::os::raw::c_ushort;
pub type __u_int = ::std::os::raw::c_uint;
pub type __u_long = ::std::os::raw::c_ulong;
pub type __int8_t = ::std::os::raw::c_schar;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int16_t = ::std::os::raw::c_short;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __int64_t = ::std::os::raw::c_long;
pub type __uint64_t = ::std::os::raw::c_ulong;
pub type __int_least8_t = __int8_t;
pub type __uint_least8_t = __uint8_t;
pub type __int_least16_t = __int16_t;
pub type __uint_least16_t = __uint16_t;
pub type __int_least32_t = __int32_t;
pub type __uint_least32_t = __uint32_t;
pub type __int_least64_t = __int64_t;
pub type __uint_least64_t = __uint64_t;
pub type __quad_t = ::std::os::raw::c_long;
pub type __u_quad_t = ::std::os::raw::c_ulong;
pub type __intmax_t = ::std::os::raw::c_long;
pub type __uintmax_t = ::std::os::raw::c_ulong;
pub type __dev_t = ::std::os::raw::c_ulong;
pub type __uid_t = ::std::os::raw::c_uint;
pub type __gid_t = ::std::os::raw::c_uint;
pub type __ino_t = ::std::os::raw::c_ulong;
pub type __ino64_t = ::std::os::raw::c_ulong;
pub type __mode_t = ::std::os::raw::c_uint;
pub type __nlink_t = ::std::os::raw::c_ulong;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
pub type __pid_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __fsid_t {
pub __val: [::std::os::raw::c_int; 2usize],
}
#[test]
fn bindgen_test_layout___fsid_t() {
assert_eq!(
::std::mem::size_of::<__fsid_t>(),
8usize,
concat!("Size of: ", stringify!(__fsid_t))
);
assert_eq!(
::std::mem::align_of::<__fsid_t>(),
4usize,
concat!("Alignment of ", stringify!(__fsid_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__fsid_t>())).__val as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__fsid_t),
"::",
stringify!(__val)
)
);
}
pub type __clock_t = ::std::os::raw::c_long;
pub type __rlim_t = ::std::os::raw::c_ulong;
pub type __rlim64_t = ::std::os::raw::c_ulong;
pub type __id_t = ::std::os::raw::c_uint;
pub type __time_t = ::std::os::raw::c_long;
pub type __useconds_t = ::std::os::raw::c_uint;
pub type __suseconds_t = ::std::os::raw::c_long;
pub type __suseconds64_t = ::std::os::raw::c_long;
pub type __daddr_t = ::std::os::raw::c_int;
pub type __key_t = ::std::os::raw::c_int;
pub type __clockid_t = ::std::os::raw::c_int;
pub type __timer_t = *mut ::std::os::raw::c_void;
pub type __blksize_t = ::std::os::raw::c_long;
pub type __blkcnt_t = ::std::os::raw::c_long;
pub type __blkcnt64_t = ::std::os::raw::c_long;
pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
pub type __fsword_t = ::std::os::raw::c_long;
pub type __ssize_t = ::std::os::raw::c_long;
pub type __syscall_slong_t = ::std::os::raw::c_long;
pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
pub type __loff_t = __off64_t;
pub type __caddr_t = *mut ::std::os::raw::c_char;
pub type __intptr_t = ::std::os::raw::c_long;
pub type __socklen_t = ::std::os::raw::c_uint;
pub type __sig_atomic_t = ::std::os::raw::c_int;
pub type int_least8_t = __int_least8_t;
pub type int_least16_t = __int_least16_t;
pub type int_least32_t = __int_least32_t;
pub type int_least64_t = __int_least64_t;
pub type uint_least8_t = __uint_least8_t;
pub type uint_least16_t = __uint_least16_t;
pub type uint_least32_t = __uint_least32_t;
pub type uint_least64_t = __uint_least64_t;
pub type int_fast8_t = ::std::os::raw::c_schar;
pub type int_fast16_t = ::std::os::raw::c_long;
pub type int_fast32_t = ::std::os::raw::c_long;
pub type int_fast64_t = ::std::os::raw::c_long;
pub type uint_fast8_t = ::std::os::raw::c_uchar;
pub type uint_fast16_t = ::std::os::raw::c_ulong;
pub type uint_fast32_t = ::std::os::raw::c_ulong;
pub type uint_fast64_t = ::std::os::raw::c_ulong;
pub type intmax_t = __intmax_t;
pub type uintmax_t = __uintmax_t;
pub type u_char = __u_char;
pub type u_short = __u_short;
pub type u_int = __u_int;
pub type u_long = __u_long;
pub type quad_t = __quad_t;
pub type u_quad_t = __u_quad_t;
pub type fsid_t = __fsid_t;
pub type loff_t = __loff_t;
pub type ino_t = __ino_t;
pub type dev_t = __dev_t;
pub type gid_t = __gid_t;
pub type mode_t = __mode_t;
pub type nlink_t = __nlink_t;
pub type uid_t = __uid_t;
pub type off_t = __off_t;
pub type pid_t = __pid_t;
pub type id_t = __id_t;
pub type ssize_t = __ssize_t;
pub type daddr_t = __daddr_t;
pub type caddr_t = __caddr_t;
pub type key_t = __key_t;
pub type clock_t = __clock_t;
pub type clockid_t = __clockid_t;
pub type time_t = __time_t;
pub type timer_t = __timer_t;
pub type size_t = ::std::os::raw::c_ulong;
pub type ulong = ::std::os::raw::c_ulong;
pub type ushort = ::std::os::raw::c_ushort;
pub type uint = ::std::os::raw::c_uint;
pub type u_int8_t = __uint8_t;
pub type u_int16_t = __uint16_t;
pub type u_int32_t = __uint32_t;
pub type u_int64_t = __uint64_t;
pub type register_t = ::std::os::raw::c_long;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __sigset_t {
pub __val: [::std::os::raw::c_ulong; 16usize],
}
#[test]
fn bindgen_test_layout___sigset_t() {
assert_eq!(
::std::mem::size_of::<__sigset_t>(),
128usize,
concat!("Size of: ", stringify!(__sigset_t))
);
assert_eq!(
::std::mem::align_of::<__sigset_t>(),
8usize,
concat!("Alignment of ", stringify!(__sigset_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__sigset_t>())).__val as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__sigset_t),
"::",
stringify!(__val)
)
);
}
pub type sigset_t = __sigset_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct timeval {
pub tv_sec: __time_t,
pub tv_usec: __suseconds_t,
}
#[test]
fn bindgen_test_layout_timeval() {
assert_eq!(
::std::mem::size_of::<timeval>(),
16usize,
concat!("Size of: ", stringify!(timeval))
);
assert_eq!(
::std::mem::align_of::<timeval>(),
8usize,
concat!("Alignment of ", stringify!(timeval))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<timeval>())).tv_sec as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(timeval),
"::",
stringify!(tv_sec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<timeval>())).tv_usec as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(timeval),
"::",
stringify!(tv_usec)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct timespec {
pub tv_sec: __time_t,
pub tv_nsec: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_timespec() {
assert_eq!(
::std::mem::size_of::<timespec>(),
16usize,
concat!("Size of: ", stringify!(timespec))
);
assert_eq!(
::std::mem::align_of::<timespec>(),
8usize,
concat!("Alignment of ", stringify!(timespec))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<timespec>())).tv_sec as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(timespec),
"::",
stringify!(tv_sec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<timespec>())).tv_nsec as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(timespec),
"::",
stringify!(tv_nsec)
)
);
}
pub type suseconds_t = __suseconds_t;
pub type __fd_mask = ::std::os::raw::c_long;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fd_set {
pub __fds_bits: [__fd_mask; 16usize],
}
#[test]
fn bindgen_test_layout_fd_set() {
assert_eq!(
::std::mem::size_of::<fd_set>(),
128usize,
concat!("Size of: ", stringify!(fd_set))
);
assert_eq!(
::std::mem::align_of::<fd_set>(),
8usize,
concat!("Alignment of ", stringify!(fd_set))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<fd_set>())).__fds_bits as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(fd_set),
"::",
stringify!(__fds_bits)
)
);
}
pub type fd_mask = __fd_mask;
extern "C" {
pub fn select(
__nfds: ::std::os::raw::c_int,
__readfds: *mut fd_set,
__writefds: *mut fd_set,
__exceptfds: *mut fd_set,
__timeout: *mut timeval,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn pselect(
__nfds: ::std::os::raw::c_int,
__readfds: *mut fd_set,
__writefds: *mut fd_set,
__exceptfds: *mut fd_set,
__timeout: *const timespec,
__sigmask: *const __sigset_t,
) -> ::std::os::raw::c_int;
}
pub type blksize_t = __blksize_t;
pub type blkcnt_t = __blkcnt_t;
pub type fsblkcnt_t = __fsblkcnt_t;
pub type fsfilcnt_t = __fsfilcnt_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_internal_list {
pub __prev: *mut __pthread_internal_list,
pub __next: *mut __pthread_internal_list,
}
#[test]
fn bindgen_test_layout___pthread_internal_list() {
assert_eq!(
::std::mem::size_of::<__pthread_internal_list>(),
16usize,
concat!("Size of: ", stringify!(__pthread_internal_list))
);
assert_eq!(
::std::mem::align_of::<__pthread_internal_list>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_internal_list))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_internal_list>())).__prev as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_list),
"::",
stringify!(__prev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_internal_list>())).__next as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_list),
"::",
stringify!(__next)
)
);
}
pub type __pthread_list_t = __pthread_internal_list;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_internal_slist {
pub __next: *mut __pthread_internal_slist,
}
#[test]
fn bindgen_test_layout___pthread_internal_slist() {
assert_eq!(
::std::mem::size_of::<__pthread_internal_slist>(),
8usize,
concat!("Size of: ", stringify!(__pthread_internal_slist))
);
assert_eq!(
::std::mem::align_of::<__pthread_internal_slist>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_internal_slist))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_internal_slist>())).__next as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_slist),
"::",
stringify!(__next)
)
);
}
pub type __pthread_slist_t = __pthread_internal_slist;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_mutex_s {
pub __lock: ::std::os::raw::c_int,
pub __count: ::std::os::raw::c_uint,
pub __owner: ::std::os::raw::c_int,
pub __nusers: ::std::os::raw::c_uint,
pub __kind: ::std::os::raw::c_int,
pub __spins: ::std::os::raw::c_short,
pub __elision: ::std::os::raw::c_short,
pub __list: __pthread_list_t,
}
#[test]
fn bindgen_test_layout___pthread_mutex_s() {
assert_eq!(
::std::mem::size_of::<__pthread_mutex_s>(),
40usize,
concat!("Size of: ", stringify!(__pthread_mutex_s))
);
assert_eq!(
::std::mem::align_of::<__pthread_mutex_s>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_mutex_s))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__lock as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__lock)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__count as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__owner as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__owner)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__nusers as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__nusers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__kind as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__kind)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__spins as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__spins)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__elision as *const _ as usize },
22usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__elision)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__list as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__list)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_rwlock_arch_t {
pub __readers: ::std::os::raw::c_uint,
pub __writers: ::std::os::raw::c_uint,
pub __wrphase_futex: ::std::os::raw::c_uint,
pub __writers_futex: ::std::os::raw::c_uint,
pub __pad3: ::std::os::raw::c_uint,
pub __pad4: ::std::os::raw::c_uint,
pub __cur_writer: ::std::os::raw::c_int,
pub __shared: ::std::os::raw::c_int,
pub __rwelision: ::std::os::raw::c_schar,
pub __pad1: [::std::os::raw::c_uchar; 7usize],
pub __pad2: ::std::os::raw::c_ulong,
pub __flags: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout___pthread_rwlock_arch_t() {
assert_eq!(
::std::mem::size_of::<__pthread_rwlock_arch_t>(),
56usize,
concat!("Size of: ", stringify!(__pthread_rwlock_arch_t))
);
assert_eq!(
::std::mem::align_of::<__pthread_rwlock_arch_t>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_rwlock_arch_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__readers as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__readers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__writers as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__writers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__wrphase_futex as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__wrphase_futex)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__writers_futex as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__writers_futex)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__pad3 as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__pad3)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__pad4 as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__pad4)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__cur_writer as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__cur_writer)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__shared as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__shared)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__rwelision as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__rwelision)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__pad1 as *const _ as usize },
33usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__pad1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__pad2 as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__pad2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__flags as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__flags)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __pthread_cond_s {
pub __bindgen_anon_1: __pthread_cond_s__bindgen_ty_1,
pub __bindgen_anon_2: __pthread_cond_s__bindgen_ty_2,
pub __g_refs: [::std::os::raw::c_uint; 2usize],
pub __g_size: [::std::os::raw::c_uint; 2usize],
pub __g1_orig_size: ::std::os::raw::c_uint,
pub __wrefs: ::std::os::raw::c_uint,
pub __g_signals: [::std::os::raw::c_uint; 2usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __pthread_cond_s__bindgen_ty_1 {
pub __wseq: ::std::os::raw::c_ulonglong,
pub __wseq32: __pthread_cond_s__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_cond_s__bindgen_ty_1__bindgen_ty_1 {
pub __low: ::std::os::raw::c_uint,
pub __high: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>())).__low
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(__low)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>())).__high
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(__high)
)
);
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<__pthread_cond_s__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(__pthread_cond_s__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_cond_s__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_1>())).__wseq as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_1),
"::",
stringify!(__wseq)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_1>())).__wseq32 as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_1),
"::",
stringify!(__wseq32)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __pthread_cond_s__bindgen_ty_2 {
pub __g1_start: ::std::os::raw::c_ulonglong,
pub __g1_start32: __pthread_cond_s__bindgen_ty_2__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_cond_s__bindgen_ty_2__bindgen_ty_1 {
pub __low: ::std::os::raw::c_uint,
pub __high: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_2__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>())).__low
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(__low)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>())).__high
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(__high)
)
);
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<__pthread_cond_s__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(__pthread_cond_s__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_cond_s__bindgen_ty_2))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_2>())).__g1_start as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_2),
"::",
stringify!(__g1_start)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_2>())).__g1_start32 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_2),
"::",
stringify!(__g1_start32)
)
);
}
#[test]
fn bindgen_test_layout___pthread_cond_s() {
assert_eq!(
::std::mem::size_of::<__pthread_cond_s>(),
48usize,
concat!("Size of: ", stringify!(__pthread_cond_s))
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_cond_s))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__g_refs as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_refs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__g_size as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__g1_orig_size as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g1_orig_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__wrefs as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__wrefs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__g_signals as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_signals)
)
);
}
pub type __tss_t = ::std::os::raw::c_uint;
pub type __thrd_t = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __once_flag {
pub __data: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout___once_flag() {
assert_eq!(
::std::mem::size_of::<__once_flag>(),
4usize,
concat!("Size of: ", stringify!(__once_flag))
);
assert_eq!(
::std::mem::align_of::<__once_flag>(),
4usize,
concat!("Alignment of ", stringify!(__once_flag))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__once_flag>())).__data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__once_flag),
"::",
stringify!(__data)
)
);
}
pub type pthread_t = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_mutexattr_t {
pub __size: [::std::os::raw::c_char; 4usize],
pub __align: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_pthread_mutexattr_t() {
assert_eq!(
::std::mem::size_of::<pthread_mutexattr_t>(),
4usize,
concat!("Size of: ", stringify!(pthread_mutexattr_t))
);
assert_eq!(
::std::mem::align_of::<pthread_mutexattr_t>(),
4usize,
concat!("Alignment of ", stringify!(pthread_mutexattr_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutexattr_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutexattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutexattr_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutexattr_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_condattr_t {
pub __size: [::std::os::raw::c_char; 4usize],
pub __align: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_pthread_condattr_t() {
assert_eq!(
::std::mem::size_of::<pthread_condattr_t>(),
4usize,
concat!("Size of: ", stringify!(pthread_condattr_t))
);
assert_eq!(
::std::mem::align_of::<pthread_condattr_t>(),
4usize,
concat!("Alignment of ", stringify!(pthread_condattr_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_condattr_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_condattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_condattr_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_condattr_t),
"::",
stringify!(__align)
)
);
}
pub type pthread_key_t = ::std::os::raw::c_uint;
pub type pthread_once_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_attr_t {
pub __size: [::std::os::raw::c_char; 56usize],
pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_pthread_attr_t() {
assert_eq!(
::std::mem::size_of::<pthread_attr_t>(),
56usize,
concat!("Size of: ", stringify!(pthread_attr_t))
);
assert_eq!(
::std::mem::align_of::<pthread_attr_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_attr_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_attr_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_attr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_attr_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_attr_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_mutex_t {
pub __data: __pthread_mutex_s,
pub __size: [::std::os::raw::c_char; 40usize],
pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_pthread_mutex_t() {
assert_eq!(
::std::mem::size_of::<pthread_mutex_t>(),
40usize,
concat!("Size of: ", stringify!(pthread_mutex_t))
);
assert_eq!(
::std::mem::align_of::<pthread_mutex_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_mutex_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_cond_t {
pub __data: __pthread_cond_s,
pub __size: [::std::os::raw::c_char; 48usize],
pub __align: ::std::os::raw::c_longlong,
}
#[test]
fn bindgen_test_layout_pthread_cond_t() {
assert_eq!(
::std::mem::size_of::<pthread_cond_t>(),
48usize,
concat!("Size of: ", stringify!(pthread_cond_t))
);
assert_eq!(
::std::mem::align_of::<pthread_cond_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_cond_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_cond_t>())).__data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_cond_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_cond_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_rwlock_t {
pub __data: __pthread_rwlock_arch_t,
pub __size: [::std::os::raw::c_char; 56usize],
pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_pthread_rwlock_t() {
assert_eq!(
::std::mem::size_of::<pthread_rwlock_t>(),
56usize,
concat!("Size of: ", stringify!(pthread_rwlock_t))
);
assert_eq!(
::std::mem::align_of::<pthread_rwlock_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_rwlock_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_rwlock_t>())).__data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlock_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_rwlock_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlock_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_rwlock_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlock_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_rwlockattr_t {
pub __size: [::std::os::raw::c_char; 8usize],
pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_pthread_rwlockattr_t() {
assert_eq!(
::std::mem::size_of::<pthread_rwlockattr_t>(),
8usize,
concat!("Size of: ", stringify!(pthread_rwlockattr_t))
);
assert_eq!(
::std::mem::align_of::<pthread_rwlockattr_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_rwlockattr_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_rwlockattr_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlockattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_rwlockattr_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlockattr_t),
"::",
stringify!(__align)
)
);
}
pub type pthread_spinlock_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_barrier_t {
pub __size: [::std::os::raw::c_char; 32usize],
pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_pthread_barrier_t() {
assert_eq!(
::std::mem::size_of::<pthread_barrier_t>(),
32usize,
concat!("Size of: ", stringify!(pthread_barrier_t))
);
assert_eq!(
::std::mem::align_of::<pthread_barrier_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_barrier_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_barrier_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_barrier_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_barrier_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_barrier_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_barrierattr_t {
pub __size: [::std::os::raw::c_char; 4usize],
pub __align: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_pthread_barrierattr_t() {
assert_eq!(
::std::mem::size_of::<pthread_barrierattr_t>(),
4usize,
concat!("Size of: ", stringify!(pthread_barrierattr_t))
);
assert_eq!(
::std::mem::align_of::<pthread_barrierattr_t>(),
4usize,
concat!("Alignment of ", stringify!(pthread_barrierattr_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_barrierattr_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_barrierattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_barrierattr_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_barrierattr_t),
"::",
stringify!(__align)
)
);
}
pub type va_list = __builtin_va_list;
pub type __gnuc_va_list = __builtin_va_list;
#[doc = " The basic plist abstract data type."]
pub type plist_t = *mut ::std::os::raw::c_void;
#[doc = " The plist dictionary iterator."]
pub type plist_dict_iter = *mut ::std::os::raw::c_void;
#[doc = " The plist array iterator."]
pub type plist_array_iter = *mut ::std::os::raw::c_void;
#[doc = "< Boolean, scalar type"]
pub const plist_type_PLIST_BOOLEAN: plist_type = 0;
#[doc = "< Unsigned integer, scalar type"]
pub const plist_type_PLIST_UINT: plist_type = 1;
#[doc = "< Real, scalar type"]
pub const plist_type_PLIST_REAL: plist_type = 2;
#[doc = "< ASCII string, scalar type"]
pub const plist_type_PLIST_STRING: plist_type = 3;
#[doc = "< Ordered array, structured type"]
pub const plist_type_PLIST_ARRAY: plist_type = 4;
#[doc = "< Unordered dictionary (key/value pair), structured type"]
pub const plist_type_PLIST_DICT: plist_type = 5;
#[doc = "< Date, scalar type"]
pub const plist_type_PLIST_DATE: plist_type = 6;
#[doc = "< Binary data, scalar type"]
pub const plist_type_PLIST_DATA: plist_type = 7;
#[doc = "< Key in dictionaries (ASCII String), scalar type"]
pub const plist_type_PLIST_KEY: plist_type = 8;
#[doc = "< Special type used for 'keyed encoding'"]
pub const plist_type_PLIST_UID: plist_type = 9;
#[doc = "< NULL type"]
pub const plist_type_PLIST_NULL: plist_type = 10;
#[doc = "< No type"]
pub const plist_type_PLIST_NONE: plist_type = 11;
#[doc = " The enumeration of plist node types."]
pub type plist_type = ::std::os::raw::c_uint;
#[doc = "< operation successful"]
pub const plist_err_t_PLIST_ERR_SUCCESS: plist_err_t = 0;
#[doc = "< one or more of the parameters are invalid"]
pub const plist_err_t_PLIST_ERR_INVALID_ARG: plist_err_t = -1;
#[doc = "< the plist contains nodes not compatible with the output format"]
pub const plist_err_t_PLIST_ERR_FORMAT: plist_err_t = -2;
#[doc = "< parsing of the input format failed"]
pub const plist_err_t_PLIST_ERR_PARSE: plist_err_t = -3;
#[doc = "< not enough memory to handle the operation"]
pub const plist_err_t_PLIST_ERR_NO_MEM: plist_err_t = -4;
#[doc = "< an unspecified error occurred"]
pub const plist_err_t_PLIST_ERR_UNKNOWN: plist_err_t = -255;
#[doc = " libplist error values"]
pub type plist_err_t = ::std::os::raw::c_int;
extern "C" {
#[doc = " Create a new root plist_t type #PLIST_DICT"]
#[doc = ""]
#[doc = " @return the created plist"]
#[doc = " @sa #plist_type"]
pub fn plist_new_dict() -> plist_t;
}
extern "C" {
#[doc = " Create a new root plist_t type #PLIST_ARRAY"]
#[doc = ""]
#[doc = " @return the created plist"]
#[doc = " @sa #plist_type"]
pub fn plist_new_array() -> plist_t;
}
extern "C" {
#[doc = " Create a new plist_t type #PLIST_STRING"]
#[doc = ""]
#[doc = " @param val the sting value, encoded in UTF8."]
#[doc = " @return the created item"]
#[doc = " @sa #plist_type"]
pub fn plist_new_string(val: *const ::std::os::raw::c_char) -> plist_t;
}
extern "C" {
#[doc = " Create a new plist_t type #PLIST_BOOLEAN"]
#[doc = ""]
#[doc = " @param val the boolean value, 0 is false, other values are true."]
#[doc = " @return the created item"]
#[doc = " @sa #plist_type"]
pub fn plist_new_bool(val: u8) -> plist_t;
}
extern "C" {
#[doc = " Create a new plist_t type #PLIST_UINT"]
#[doc = ""]
#[doc = " @param val the unsigned integer value"]
#[doc = " @return the created item"]
#[doc = " @sa #plist_type"]
pub fn plist_new_uint(val: u64) -> plist_t;
}
extern "C" {
#[doc = " Create a new plist_t type #PLIST_REAL"]
#[doc = ""]
#[doc = " @param val the real value"]
#[doc = " @return the created item"]
#[doc = " @sa #plist_type"]
pub fn plist_new_real(val: f64) -> plist_t;
}
extern "C" {
#[doc = " Create a new plist_t type #PLIST_DATA"]
#[doc = ""]
#[doc = " @param val the binary buffer"]
#[doc = " @param length the length of the buffer"]
#[doc = " @return the created item"]
#[doc = " @sa #plist_type"]
pub fn plist_new_data(val: *const ::std::os::raw::c_char, length: u64) -> plist_t;
}
extern "C" {
#[doc = " Create a new plist_t type #PLIST_DATE"]
#[doc = ""]
#[doc = " @param sec the number of seconds since 01/01/2001"]
#[doc = " @param usec the number of microseconds"]
#[doc = " @return the created item"]
#[doc = " @sa #plist_type"]
pub fn plist_new_date(sec: i32, usec: i32) -> plist_t;
}
extern "C" {
#[doc = " Create a new plist_t type #PLIST_UID"]
#[doc = ""]
#[doc = " @param val the unsigned integer value"]
#[doc = " @return the created item"]
#[doc = " @sa #plist_type"]
pub fn plist_new_uid(val: u64) -> plist_t;
}
extern "C" {
#[doc = " Create a new plist_t type #PLIST_NULL"]
#[doc = " @return the created item"]
#[doc = " @sa #plist_type"]
#[doc = " @note This type is not valid for all formats, e.g. the XML format"]
#[doc = " does not support it."]
pub fn plist_new_null() -> plist_t;
}
extern "C" {
#[doc = " Destruct a plist_t node and all its children recursively"]
#[doc = ""]
#[doc = " @param plist the plist to free"]
pub fn plist_free(plist: plist_t);
}
extern "C" {
#[doc = " Return a copy of passed node and it's children"]
#[doc = ""]
#[doc = " @param node the plist to copy"]
#[doc = " @return copied plist"]
pub fn plist_copy(node: plist_t) -> plist_t;
}
extern "C" {
#[doc = " Get size of a #PLIST_ARRAY node."]
#[doc = ""]
#[doc = " @param node the node of type #PLIST_ARRAY"]
#[doc = " @return size of the #PLIST_ARRAY node"]
pub fn plist_array_get_size(node: plist_t) -> u32;
}
extern "C" {
#[doc = " Get the nth item in a #PLIST_ARRAY node."]
#[doc = ""]
#[doc = " @param node the node of type #PLIST_ARRAY"]
#[doc = " @param n the index of the item to get. Range is [0, array_size["]
#[doc = " @return the nth item or NULL if node is not of type #PLIST_ARRAY"]
pub fn plist_array_get_item(node: plist_t, n: u32) -> plist_t;
}
extern "C" {
#[doc = " Get the index of an item. item must be a member of a #PLIST_ARRAY node."]
#[doc = ""]
#[doc = " @param node the node"]
#[doc = " @return the node index or UINT_MAX if node index can't be determined"]
pub fn plist_array_get_item_index(node: plist_t) -> u32;
}
extern "C" {
#[doc = " Set the nth item in a #PLIST_ARRAY node."]
#[doc = " The previous item at index n will be freed using #plist_free"]
#[doc = ""]
#[doc = " @param node the node of type #PLIST_ARRAY"]
#[doc = " @param item the new item at index n. The array is responsible for freeing item when it is no longer needed."]
#[doc = " @param n the index of the item to get. Range is [0, array_size[. Assert if n is not in range."]
pub fn plist_array_set_item(node: plist_t, item: plist_t, n: u32);
}
extern "C" {
#[doc = " Append a new item at the end of a #PLIST_ARRAY node."]
#[doc = ""]
#[doc = " @param node the node of type #PLIST_ARRAY"]
#[doc = " @param item the new item. The array is responsible for freeing item when it is no longer needed."]
pub fn plist_array_append_item(node: plist_t, item: plist_t);
}
extern "C" {
#[doc = " Insert a new item at position n in a #PLIST_ARRAY node."]
#[doc = ""]
#[doc = " @param node the node of type #PLIST_ARRAY"]
#[doc = " @param item the new item to insert. The array is responsible for freeing item when it is no longer needed."]
#[doc = " @param n The position at which the node will be stored. Range is [0, array_size[. Assert if n is not in range."]
pub fn plist_array_insert_item(node: plist_t, item: plist_t, n: u32);
}
extern "C" {
#[doc = " Remove an existing position in a #PLIST_ARRAY node."]
#[doc = " Removed position will be freed using #plist_free."]
#[doc = ""]
#[doc = " @param node the node of type #PLIST_ARRAY"]
#[doc = " @param n The position to remove. Range is [0, array_size[. Assert if n is not in range."]
pub fn plist_array_remove_item(node: plist_t, n: u32);
}
extern "C" {
#[doc = " Remove a node that is a child node of a #PLIST_ARRAY node."]
#[doc = " node will be freed using #plist_free."]
#[doc = ""]
#[doc = " @param node The node to be removed from its #PLIST_ARRAY parent."]
pub fn plist_array_item_remove(node: plist_t);
}
extern "C" {
#[doc = " Create an iterator of a #PLIST_ARRAY node."]
#[doc = " The allocated iterator should be freed with the standard free function."]
#[doc = ""]
#[doc = " @param node The node of type #PLIST_ARRAY"]
#[doc = " @param iter Location to store the iterator for the array."]
pub fn plist_array_new_iter(node: plist_t, iter: *mut plist_array_iter);
}
extern "C" {
#[doc = " Increment iterator of a #PLIST_ARRAY node."]
#[doc = ""]
#[doc = " @param node The node of type #PLIST_ARRAY."]
#[doc = " @param iter Iterator of the array"]
#[doc = " @param item Location to store the item. The caller must *not* free the"]
#[doc = " returned item. Will be set to NULL when no more items are left"]
#[doc = " to iterate."]
pub fn plist_array_next_item(node: plist_t, iter: plist_array_iter, item: *mut plist_t);
}
extern "C" {
#[doc = " Get size of a #PLIST_DICT node."]
#[doc = ""]
#[doc = " @param node the node of type #PLIST_DICT"]
#[doc = " @return size of the #PLIST_DICT node"]
pub fn plist_dict_get_size(node: plist_t) -> u32;
}
extern "C" {
#[doc = " Create an iterator of a #PLIST_DICT node."]
#[doc = " The allocated iterator should be freed with the standard free function."]
#[doc = ""]
#[doc = " @param node The node of type #PLIST_DICT."]
#[doc = " @param iter Location to store the iterator for the dictionary."]
pub fn plist_dict_new_iter(node: plist_t, iter: *mut plist_dict_iter);
}
extern "C" {
#[doc = " Increment iterator of a #PLIST_DICT node."]
#[doc = ""]
#[doc = " @param node The node of type #PLIST_DICT"]
#[doc = " @param iter Iterator of the dictionary"]
#[doc = " @param key Location to store the key, or NULL. The caller is responsible"]
#[doc = "\t\tfor freeing the the returned string."]
#[doc = " @param val Location to store the value, or NULL. The caller must *not*"]
#[doc = "\t\tfree the returned value. Will be set to NULL when no more"]
#[doc = "\t\tkey/value pairs are left to iterate."]
pub fn plist_dict_next_item(
node: plist_t,
iter: plist_dict_iter,
key: *mut *mut ::std::os::raw::c_char,
val: *mut plist_t,
);
}
extern "C" {
#[doc = " Get key associated key to an item. Item must be member of a dictionary."]
#[doc = ""]
#[doc = " @param node the item"]
#[doc = " @param key a location to store the key. The caller is responsible for freeing the returned string."]
pub fn plist_dict_get_item_key(node: plist_t, key: *mut *mut ::std::os::raw::c_char);
}
extern "C" {
#[doc = " Get the nth item in a #PLIST_DICT node."]
#[doc = ""]
#[doc = " @param node the node of type #PLIST_DICT"]
#[doc = " @param key the identifier of the item to get."]
#[doc = " @return the item or NULL if node is not of type #PLIST_DICT. The caller should not free"]
#[doc = "\t\tthe returned node."]
pub fn plist_dict_get_item(node: plist_t, key: *const ::std::os::raw::c_char) -> plist_t;
}
extern "C" {
#[doc = " Get key node associated to an item. Item must be member of a dictionary."]
#[doc = ""]
#[doc = " @param node the item"]
#[doc = " @return the key node of the given item, or NULL."]
pub fn plist_dict_item_get_key(node: plist_t) -> plist_t;
}
extern "C" {
#[doc = " Set item identified by key in a #PLIST_DICT node."]
#[doc = " The previous item identified by key will be freed using #plist_free."]
#[doc = " If there is no item for the given key a new item will be inserted."]
#[doc = ""]
#[doc = " @param node the node of type #PLIST_DICT"]
#[doc = " @param item the new item associated to key"]
#[doc = " @param key the identifier of the item to set."]
pub fn plist_dict_set_item(node: plist_t, key: *const ::std::os::raw::c_char, item: plist_t);
}
extern "C" {
#[doc = " Insert a new item into a #PLIST_DICT node."]
#[doc = ""]
#[doc = " @deprecated Deprecated. Use plist_dict_set_item instead."]
#[doc = ""]
#[doc = " @param node the node of type #PLIST_DICT"]
#[doc = " @param item the new item to insert"]
#[doc = " @param key The identifier of the item to insert."]
pub fn plist_dict_insert_item(node: plist_t, key: *const ::std::os::raw::c_char, item: plist_t);
}
extern "C" {
#[doc = " Remove an existing position in a #PLIST_DICT node."]
#[doc = " Removed position will be freed using #plist_free"]
#[doc = ""]
#[doc = " @param node the node of type #PLIST_DICT"]
#[doc = " @param key The identifier of the item to remove. Assert if identifier is not present."]
pub fn plist_dict_remove_item(node: plist_t, key: *const ::std::os::raw::c_char);
}
extern "C" {
#[doc = " Merge a dictionary into another. This will add all key/value pairs"]
#[doc = " from the source dictionary to the target dictionary, overwriting"]
#[doc = " any existing key/value pairs that are already present in target."]
#[doc = ""]
#[doc = " @param target pointer to an existing node of type #PLIST_DICT"]
#[doc = " @param source node of type #PLIST_DICT that should be merged into target"]
pub fn plist_dict_merge(target: *mut plist_t, source: plist_t);
}
extern "C" {
#[doc = " Get the parent of a node"]
#[doc = ""]
#[doc = " @param node the parent (NULL if node is root)"]
pub fn plist_get_parent(node: plist_t) -> plist_t;
}
extern "C" {
#[doc = " Get the #plist_type of a node."]
#[doc = ""]
#[doc = " @param node the node"]
#[doc = " @return the type of the node"]
pub fn plist_get_node_type(node: plist_t) -> plist_type;
}
extern "C" {
#[doc = " Get the value of a #PLIST_KEY node."]
#[doc = " This function does nothing if node is not of type #PLIST_KEY"]
#[doc = ""]
#[doc = " @param node the node"]
#[doc = " @param val a pointer to a C-string. This function allocates the memory,"]
#[doc = " caller is responsible for freeing it."]
#[doc = " @note Use plist_mem_free() to free the allocated memory."]
pub fn plist_get_key_val(node: plist_t, val: *mut *mut ::std::os::raw::c_char);
}
extern "C" {
#[doc = " Get the value of a #PLIST_STRING node."]
#[doc = " This function does nothing if node is not of type #PLIST_STRING"]
#[doc = ""]
#[doc = " @param node the node"]
#[doc = " @param val a pointer to a C-string. This function allocates the memory,"]
#[doc = " caller is responsible for freeing it. Data is UTF-8 encoded."]
#[doc = " @note Use plist_mem_free() to free the allocated memory."]
pub fn plist_get_string_val(node: plist_t, val: *mut *mut ::std::os::raw::c_char);
}
extern "C" {
#[doc = " Get a pointer to the buffer of a #PLIST_STRING node."]
#[doc = ""]
#[doc = " @note DO NOT MODIFY the buffer. Mind that the buffer is only available"]
#[doc = " until the plist node gets freed. Make a copy if needed."]
#[doc = ""]
#[doc = " @param node The node"]
#[doc = " @param length If non-NULL, will be set to the length of the string"]
#[doc = ""]
#[doc = " @return Pointer to the NULL-terminated buffer."]
pub fn plist_get_string_ptr(node: plist_t, length: *mut u64) -> *const ::std::os::raw::c_char;
}
extern "C" {
#[doc = " Get the value of a #PLIST_BOOLEAN node."]
#[doc = " This function does nothing if node is not of type #PLIST_BOOLEAN"]
#[doc = ""]
#[doc = " @param node the node"]
#[doc = " @param val a pointer to a uint8_t variable."]
pub fn plist_get_bool_val(node: plist_t, val: *mut u8);
}
extern "C" {
#[doc = " Get the value of a #PLIST_UINT node."]
#[doc = " This function does nothing if node is not of type #PLIST_UINT"]
#[doc = ""]
#[doc = " @param node the node"]
#[doc = " @param val a pointer to a uint64_t variable."]
pub fn plist_get_uint_val(node: plist_t, val: *mut u64);
}
extern "C" {
#[doc = " Get the value of a #PLIST_REAL node."]
#[doc = " This function does nothing if node is not of type #PLIST_REAL"]
#[doc = ""]
#[doc = " @param node the node"]
#[doc = " @param val a pointer to a double variable."]
pub fn plist_get_real_val(node: plist_t, val: *mut f64);
}
extern "C" {
#[doc = " Get the value of a #PLIST_DATA node."]
#[doc = " This function does nothing if node is not of type #PLIST_DATA"]
#[doc = ""]
#[doc = " @param node the node"]
#[doc = " @param val a pointer to an unallocated char buffer. This function allocates the memory,"]
#[doc = " caller is responsible for freeing it."]
#[doc = " @param length the length of the buffer"]
#[doc = " @note Use plist_mem_free() to free the allocated memory."]
pub fn plist_get_data_val(
node: plist_t,
val: *mut *mut ::std::os::raw::c_char,
length: *mut u64,
);
}
extern "C" {
#[doc = " Get a pointer to the data buffer of a #PLIST_DATA node."]
#[doc = ""]
#[doc = " @note DO NOT MODIFY the buffer. Mind that the buffer is only available"]
#[doc = " until the plist node gets freed. Make a copy if needed."]
#[doc = ""]
#[doc = " @param node The node"]
#[doc = " @param length Pointer to a uint64_t that will be set to the length of the buffer"]
#[doc = ""]
#[doc = " @return Pointer to the buffer"]
pub fn plist_get_data_ptr(node: plist_t, length: *mut u64) -> *const ::std::os::raw::c_char;
}
extern "C" {
#[doc = " Get the value of a #PLIST_DATE node."]
#[doc = " This function does nothing if node is not of type #PLIST_DATE"]
#[doc = ""]
#[doc = " @param node the node"]
#[doc = " @param sec a pointer to an int32_t variable. Represents the number of seconds since 01/01/2001."]
#[doc = " @param usec a pointer to an int32_t variable. Represents the number of microseconds"]
pub fn plist_get_date_val(node: plist_t, sec: *mut i32, usec: *mut i32);
}
extern "C" {
#[doc = " Get the value of a #PLIST_UID node."]
#[doc = " This function does nothing if node is not of type #PLIST_UID"]
#[doc = ""]
#[doc = " @param node the node"]
#[doc = " @param val a pointer to a uint64_t variable."]
pub fn plist_get_uid_val(node: plist_t, val: *mut u64);
}
extern "C" {
#[doc = " Set the value of a node."]
#[doc = " Forces type of node to #PLIST_KEY"]
#[doc = ""]
#[doc = " @param node the node"]
#[doc = " @param val the key value"]
pub fn plist_set_key_val(node: plist_t, val: *const ::std::os::raw::c_char);
}
extern "C" {
#[doc = " Set the value of a node."]
#[doc = " Forces type of node to #PLIST_STRING"]
#[doc = ""]
#[doc = " @param node the node"]
#[doc = " @param val the string value. The string is copied when set and will be"]
#[doc = "\t\tfreed by the node."]
pub fn plist_set_string_val(node: plist_t, val: *const ::std::os::raw::c_char);
}
extern "C" {
#[doc = " Set the value of a node."]
#[doc = " Forces type of node to #PLIST_BOOLEAN"]
#[doc = ""]
#[doc = " @param node the node"]
#[doc = " @param val the boolean value"]
pub fn plist_set_bool_val(node: plist_t, val: u8);
}
extern "C" {
#[doc = " Set the value of a node."]
#[doc = " Forces type of node to #PLIST_UINT"]
#[doc = ""]
#[doc = " @param node the node"]
#[doc = " @param val the unsigned integer value"]
pub fn plist_set_uint_val(node: plist_t, val: u64);
}
extern "C" {
#[doc = " Set the value of a node."]
#[doc = " Forces type of node to #PLIST_REAL"]
#[doc = ""]
#[doc = " @param node the node"]
#[doc = " @param val the real value"]
pub fn plist_set_real_val(node: plist_t, val: f64);
}
extern "C" {
#[doc = " Set the value of a node."]
#[doc = " Forces type of node to #PLIST_DATA"]
#[doc = ""]
#[doc = " @param node the node"]
#[doc = " @param val the binary buffer. The buffer is copied when set and will"]
#[doc = "\t\tbe freed by the node."]
#[doc = " @param length the length of the buffer"]
pub fn plist_set_data_val(node: plist_t, val: *const ::std::os::raw::c_char, length: u64);
}
extern "C" {
#[doc = " Set the value of a node."]
#[doc = " Forces type of node to #PLIST_DATE"]
#[doc = ""]
#[doc = " @param node the node"]
#[doc = " @param sec the number of seconds since 01/01/2001"]
#[doc = " @param usec the number of microseconds"]
pub fn plist_set_date_val(node: plist_t, sec: i32, usec: i32);
}
extern "C" {
#[doc = " Set the value of a node."]
#[doc = " Forces type of node to #PLIST_UID"]
#[doc = ""]
#[doc = " @param node the node"]
#[doc = " @param val the unsigned integer value"]
pub fn plist_set_uid_val(node: plist_t, val: u64);
}
extern "C" {
#[doc = " Export the #plist_t structure to XML format."]
#[doc = ""]
#[doc = " @param plist the root node to export"]
#[doc = " @param plist_xml a pointer to a C-string. This function allocates the memory,"]
#[doc = " caller is responsible for freeing it. Data is UTF-8 encoded."]
#[doc = " @param length a pointer to an uint32_t variable. Represents the length of the allocated buffer."]
#[doc = " @return PLIST_ERR_SUCCESS on success or a #plist_err_t on failure"]
#[doc = " @note Use plist_mem_free() to free the allocated memory."]
pub fn plist_to_xml(
plist: plist_t,
plist_xml: *mut *mut ::std::os::raw::c_char,
length: *mut u32,
) -> plist_err_t;
}
extern "C" {
#[doc = " Export the #plist_t structure to binary format."]
#[doc = ""]
#[doc = " @param plist the root node to export"]
#[doc = " @param plist_bin a pointer to a char* buffer. This function allocates the memory,"]
#[doc = " caller is responsible for freeing it."]
#[doc = " @param length a pointer to an uint32_t variable. Represents the length of the allocated buffer."]
#[doc = " @return PLIST_ERR_SUCCESS on success or a #plist_err_t on failure"]
#[doc = " @note Use plist_mem_free() to free the allocated memory."]
pub fn plist_to_bin(
plist: plist_t,
plist_bin: *mut *mut ::std::os::raw::c_char,
length: *mut u32,
) -> plist_err_t;
}
extern "C" {
#[doc = " Export the #plist_t structure to JSON format."]
#[doc = ""]
#[doc = " @param plist the root node to export"]
#[doc = " @param plist_json a pointer to a char* buffer. This function allocates the memory,"]
#[doc = " caller is responsible for freeing it."]
#[doc = " @param length a pointer to an uint32_t variable. Represents the length of the allocated buffer."]
#[doc = " @param prettify pretty print the output if != 0"]
#[doc = " @return PLIST_ERR_SUCCESS on success or a #plist_err_t on failure"]
#[doc = " @note Use plist_mem_free() to free the allocated memory."]
pub fn plist_to_json(
plist: plist_t,
plist_json: *mut *mut ::std::os::raw::c_char,
length: *mut u32,
prettify: ::std::os::raw::c_int,
) -> plist_err_t;
}
extern "C" {
#[doc = " Import the #plist_t structure from XML format."]
#[doc = ""]
#[doc = " @param plist_xml a pointer to the xml buffer."]
#[doc = " @param length length of the buffer to read."]
#[doc = " @param plist a pointer to the imported plist."]
#[doc = " @return PLIST_ERR_SUCCESS on success or a #plist_err_t on failure"]
pub fn plist_from_xml(
plist_xml: *const ::std::os::raw::c_char,
length: u32,
plist: *mut plist_t,
) -> plist_err_t;
}
extern "C" {
#[doc = " Import the #plist_t structure from binary format."]
#[doc = ""]
#[doc = " @param plist_bin a pointer to the xml buffer."]
#[doc = " @param length length of the buffer to read."]
#[doc = " @param plist a pointer to the imported plist."]
#[doc = " @return PLIST_ERR_SUCCESS on success or a #plist_err_t on failure"]
pub fn plist_from_bin(
plist_bin: *const ::std::os::raw::c_char,
length: u32,
plist: *mut plist_t,
) -> plist_err_t;
}
extern "C" {
#[doc = " Import the #plist_t structure from JSON format."]
#[doc = ""]
#[doc = " @param json a pointer to the JSON buffer."]
#[doc = " @param length length of the buffer to read."]
#[doc = " @param plist a pointer to the imported plist."]
#[doc = " @return PLIST_ERR_SUCCESS on success or a #plist_err_t on failure"]
pub fn plist_from_json(
json: *const ::std::os::raw::c_char,
length: u32,
plist: *mut plist_t,
) -> plist_err_t;
}
extern "C" {
#[doc = " Import the #plist_t structure from memory data."]
#[doc = " This method will look at the first bytes of plist_data"]
#[doc = " to determine if plist_data contains a binary, JSON, or XML plist"]
#[doc = " and tries to parse the data in the appropriate format."]
#[doc = " @note This is just a convenience function and the format detection is"]
#[doc = " very basic. It checks with plist_is_binary() if the data supposedly"]
#[doc = " contains binary plist data, if not it checks if the first byte is"]
#[doc = " either '{' or '[' and assumes JSON format, otherwise it will try"]
#[doc = " to parse the data as XML."]
#[doc = ""]
#[doc = " @param plist_data a pointer to the memory buffer containing plist data."]
#[doc = " @param length length of the buffer to read."]
#[doc = " @param plist a pointer to the imported plist."]
#[doc = " @return PLIST_ERR_SUCCESS on success or a #plist_err_t on failure"]
pub fn plist_from_memory(
plist_data: *const ::std::os::raw::c_char,
length: u32,
plist: *mut plist_t,
) -> plist_err_t;
}
extern "C" {
#[doc = " Test if in-memory plist data is in binary format."]
#[doc = " This function will look at the first bytes of plist_data to determine"]
#[doc = " if it supposedly contains a binary plist."]
#[doc = " @note The function is not validating the whole memory buffer to check"]
#[doc = " if the content is truly a plist, it is only using some heuristic on"]
#[doc = " the first few bytes of plist_data."]
#[doc = ""]
#[doc = " @param plist_data a pointer to the memory buffer containing plist data."]
#[doc = " @param length length of the buffer to read."]
#[doc = " @return 1 if the buffer is a binary plist, 0 otherwise."]
pub fn plist_is_binary(
plist_data: *const ::std::os::raw::c_char,
length: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Get a node from its path. Each path element depends on the associated father node type."]
#[doc = " For Dictionaries, var args are casted to const char*, for arrays, var args are caster to uint32_t"]
#[doc = " Search is breath first order."]
#[doc = ""]
#[doc = " @param plist the node to access result from."]
#[doc = " @param length length of the path to access"]
#[doc = " @return the value to access."]
pub fn plist_access_path(plist: plist_t, length: u32, ...) -> plist_t;
}
extern "C" {
#[doc = " Variadic version of #plist_access_path."]
#[doc = ""]
#[doc = " @param plist the node to access result from."]
#[doc = " @param length length of the path to access"]
#[doc = " @param v list of array's index and dic'st key"]
#[doc = " @return the value to access."]
pub fn plist_access_pathv(plist: plist_t, length: u32, v: *mut __va_list_tag) -> plist_t;
}
extern "C" {
#[doc = " Compare two node values"]
#[doc = ""]
#[doc = " @param node_l left node to compare"]
#[doc = " @param node_r rigth node to compare"]
#[doc = " @return TRUE is type and value match, FALSE otherwise."]
pub fn plist_compare_node_value(node_l: plist_t, node_r: plist_t) -> ::std::os::raw::c_char;
}
extern "C" {
#[doc = " Helper function to check the value of a PLIST_BOOL node."]
#[doc = ""]
#[doc = " @param boolnode node of type PLIST_BOOL"]
#[doc = " @return 1 if the boolean node has a value of TRUE, 0 if FALSE,"]
#[doc = " or -1 if the node is not of type PLIST_BOOL"]
pub fn plist_bool_val_is_true(boolnode: plist_t) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Helper function to compare the value of a PLIST_UINT node against"]
#[doc = " a given value."]
#[doc = ""]
#[doc = " @param uintnode node of type PLIST_UINT"]
#[doc = " @param cmpval value to compare against"]
#[doc = " @return 0 if the node's value and cmpval are equal,"]
#[doc = " 1 if the node's value is greater than cmpval,"]
#[doc = " or -1 if the node's value is less than cmpval."]
pub fn plist_uint_val_compare(uintnode: plist_t, cmpval: u64) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Helper function to compare the value of a PLIST_UID node against"]
#[doc = " a given value."]
#[doc = ""]
#[doc = " @param uidnode node of type PLIST_UID"]
#[doc = " @param cmpval value to compare against"]
#[doc = " @return 0 if the node's value and cmpval are equal,"]
#[doc = " 1 if the node's value is greater than cmpval,"]
#[doc = " or -1 if the node's value is less than cmpval."]
pub fn plist_uid_val_compare(uidnode: plist_t, cmpval: u64) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Helper function to compare the value of a PLIST_REAL node against"]
#[doc = " a given value."]
#[doc = ""]
#[doc = " @note WARNING: Comparing floating point values can give inaccurate"]
#[doc = " results because of the nature of floating point values on computer"]
#[doc = " systems. While this function is designed to be as accurate as"]
#[doc = " possible, please don't rely on it too much."]
#[doc = ""]
#[doc = " @param realnode node of type PLIST_REAL"]
#[doc = " @param cmpval value to compare against"]
#[doc = " @return 0 if the node's value and cmpval are (almost) equal,"]
#[doc = " 1 if the node's value is greater than cmpval,"]
#[doc = " or -1 if the node's value is less than cmpval."]
pub fn plist_real_val_compare(realnode: plist_t, cmpval: f64) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Helper function to compare the value of a PLIST_DATE node against"]
#[doc = " a given set of seconds and fraction of a second since epoch."]
#[doc = ""]
#[doc = " @param datenode node of type PLIST_DATE"]
#[doc = " @param cmpsec number of seconds since epoch to compare against"]
#[doc = " @param cmpusec fraction of a second in microseconds to compare against"]
#[doc = " @return 0 if the node's date is equal to the supplied values,"]
#[doc = " 1 if the node's date is greater than the supplied values,"]
#[doc = " or -1 if the node's date is less than the supplied values."]
pub fn plist_date_val_compare(
datenode: plist_t,
cmpsec: i32,
cmpusec: i32,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Helper function to compare the value of a PLIST_STRING node against"]
#[doc = " a given value."]
#[doc = " This function basically behaves like strcmp."]
#[doc = ""]
#[doc = " @param strnode node of type PLIST_STRING"]
#[doc = " @param cmpval value to compare against"]
#[doc = " @return 0 if the node's value and cmpval are equal,"]
#[doc = " > 0 if the node's value is lexicographically greater than cmpval,"]
#[doc = " or < 0 if the node's value is lexicographically less than cmpval."]
pub fn plist_string_val_compare(
strnode: plist_t,
cmpval: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Helper function to compare the value of a PLIST_STRING node against"]
#[doc = " a given value, while not comparing more than n characters."]
#[doc = " This function basically behaves like strncmp."]
#[doc = ""]
#[doc = " @param strnode node of type PLIST_STRING"]
#[doc = " @param cmpval value to compare against"]
#[doc = " @param n maximum number of characters to compare"]
#[doc = " @return 0 if the node's value and cmpval are equal,"]
#[doc = " > 0 if the node's value is lexicographically greater than cmpval,"]
#[doc = " or < 0 if the node's value is lexicographically less than cmpval."]
pub fn plist_string_val_compare_with_size(
strnode: plist_t,
cmpval: *const ::std::os::raw::c_char,
n: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Helper function to match a given substring in the value of a"]
#[doc = " PLIST_STRING node."]
#[doc = ""]
#[doc = " @param strnode node of type PLIST_STRING"]
#[doc = " @param substr value to match"]
#[doc = " @return 1 if the node's value contains the given substring,"]
#[doc = " or 0 if not."]
pub fn plist_string_val_contains(
strnode: plist_t,
substr: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Helper function to compare the value of a PLIST_KEY node against"]
#[doc = " a given value."]
#[doc = " This function basically behaves like strcmp."]
#[doc = ""]
#[doc = " @param keynode node of type PLIST_KEY"]
#[doc = " @param cmpval value to compare against"]
#[doc = " @return 0 if the node's value and cmpval are equal,"]
#[doc = " > 0 if the node's value is lexicographically greater than cmpval,"]
#[doc = " or < 0 if the node's value is lexicographically less than cmpval."]
pub fn plist_key_val_compare(
keynode: plist_t,
cmpval: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Helper function to compare the value of a PLIST_KEY node against"]
#[doc = " a given value, while not comparing more than n characters."]
#[doc = " This function basically behaves like strncmp."]
#[doc = ""]
#[doc = " @param keynode node of type PLIST_KEY"]
#[doc = " @param cmpval value to compare against"]
#[doc = " @param n maximum number of characters to compare"]
#[doc = " @return 0 if the node's value and cmpval are equal,"]
#[doc = " > 0 if the node's value is lexicographically greater than cmpval,"]
#[doc = " or < 0 if the node's value is lexicographically less than cmpval."]
pub fn plist_key_val_compare_with_size(
keynode: plist_t,
cmpval: *const ::std::os::raw::c_char,
n: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Helper function to match a given substring in the value of a"]
#[doc = " PLIST_KEY node."]
#[doc = ""]
#[doc = " @param keynode node of type PLIST_KEY"]
#[doc = " @param substr value to match"]
#[doc = " @return 1 if the node's value contains the given substring,"]
#[doc = " or 0 if not."]
pub fn plist_key_val_contains(
keynode: plist_t,
substr: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Helper function to compare the data of a PLIST_DATA node against"]
#[doc = " a given blob and size."]
#[doc = " This function basically behaves like memcmp after making sure the"]
#[doc = " size of the node's data value is equal to the size of cmpval (n),"]
#[doc = " making this a \"full match\" comparison."]
#[doc = ""]
#[doc = " @param datanode node of type PLIST_DATA"]
#[doc = " @param cmpval data blob to compare against"]
#[doc = " @param n size of data blob passed in cmpval"]
#[doc = " @return 0 if the node's data blob and cmpval are equal,"]
#[doc = " > 0 if the node's value is lexicographically greater than cmpval,"]
#[doc = " or < 0 if the node's value is lexicographically less than cmpval."]
pub fn plist_data_val_compare(
datanode: plist_t,
cmpval: *const u8,
n: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Helper function to compare the data of a PLIST_DATA node against"]
#[doc = " a given blob and size, while no more than n bytes are compared."]
#[doc = " This function basically behaves like memcmp after making sure the"]
#[doc = " size of the node's data value is at least n, making this a"]
#[doc = " \"starts with\" comparison."]
#[doc = ""]
#[doc = " @param datanode node of type PLIST_DATA"]
#[doc = " @param cmpval data blob to compare against"]
#[doc = " @param n size of data blob passed in cmpval"]
#[doc = " @return 0 if the node's value and cmpval are equal,"]
#[doc = " > 0 if the node's value is lexicographically greater than cmpval,"]
#[doc = " or < 0 if the node's value is lexicographically less than cmpval."]
pub fn plist_data_val_compare_with_size(
datanode: plist_t,
cmpval: *const u8,
n: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Helper function to match a given data blob within the value of a"]
#[doc = " PLIST_DATA node."]
#[doc = ""]
#[doc = " @param datanode node of type PLIST_KEY"]
#[doc = " @param cmpval data blob to match"]
#[doc = " @param n size of data blob passed in cmpval"]
#[doc = " @return 1 if the node's value contains the given data blob"]
#[doc = " or 0 if not."]
pub fn plist_data_val_contains(
datanode: plist_t,
cmpval: *const u8,
n: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Free memory allocated by relevant libplist API calls:"]
#[doc = " - plist_to_xml()"]
#[doc = " - plist_to_bin()"]
#[doc = " - plist_get_key_val()"]
#[doc = " - plist_get_string_val()"]
#[doc = " - plist_get_data_val()"]
#[doc = ""]
#[doc = " @param ptr pointer to the memory to free"]
#[doc = ""]
#[doc = " @note Do not use this function to free plist_t nodes, use plist_free()"]
#[doc = " instead."]
pub fn plist_mem_free(ptr: *mut ::std::os::raw::c_void);
}
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __va_list_tag {
pub gp_offset: ::std::os::raw::c_uint,
pub fp_offset: ::std::os::raw::c_uint,
pub overflow_arg_area: *mut ::std::os::raw::c_void,
pub reg_save_area: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout___va_list_tag() {
assert_eq!(
::std::mem::size_of::<__va_list_tag>(),
24usize,
concat!("Size of: ", stringify!(__va_list_tag))
);
assert_eq!(
::std::mem::align_of::<__va_list_tag>(),
8usize,
concat!("Alignment of ", stringify!(__va_list_tag))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(gp_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(fp_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(overflow_arg_area)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(reg_save_area)
)
);
}