/* automatically generated by rust-bindgen 0.69.5 */
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 __WORDSIZE: u32 = 64;
pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
pub const __SYSCALL_WORDSIZE: u32 = 64;
pub const __TIMESIZE: u32 = 64;
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 __GLIBC_USE_C2X_STRTOL: u32 = 0;
pub const _STDC_PREDEF_H: u32 = 1;
pub const __STDC_IEC_559__: u32 = 1;
pub const __STDC_IEC_60559_BFP__: u32 = 201404;
pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
pub const __STDC_ISO_10646__: u32 = 201706;
pub const __GNU_LIBRARY__: u32 = 6;
pub const __GLIBC__: u32 = 2;
pub const __GLIBC_MINOR__: u32 = 39;
pub const _SYS_CDEFS_H: u32 = 1;
pub const __glibc_c99_flexarr_available: u32 = 1;
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_EXT: 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 _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 _BITS_STDINT_LEAST_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 _STDLIB_H: u32 = 1;
pub const WNOHANG: u32 = 1;
pub const WUNTRACED: u32 = 2;
pub const WSTOPPED: u32 = 2;
pub const WEXITED: u32 = 4;
pub const WCONTINUED: u32 = 8;
pub const WNOWAIT: u32 = 16777216;
pub const __WNOTHREAD: u32 = 536870912;
pub const __WALL: u32 = 1073741824;
pub const __WCLONE: u32 = 2147483648;
pub const __W_CONTINUED: u32 = 65535;
pub const __WCOREFLAG: u32 = 128;
pub const __HAVE_FLOAT128: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT128: u32 = 0;
pub const __HAVE_FLOAT64X: u32 = 1;
pub const __HAVE_FLOAT64X_LONG_DOUBLE: u32 = 1;
pub const __HAVE_FLOAT16: u32 = 0;
pub const __HAVE_FLOAT32: u32 = 1;
pub const __HAVE_FLOAT64: u32 = 1;
pub const __HAVE_FLOAT32X: u32 = 1;
pub const __HAVE_FLOAT128X: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT16: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT32: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT64: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT32X: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT64X: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT128X: u32 = 0;
pub const __HAVE_FLOATN_NOT_TYPEDEF: u32 = 0;
pub const __ldiv_t_defined: u32 = 1;
pub const __lldiv_t_defined: u32 = 1;
pub const RAND_MAX: u32 = 2147483647;
pub const EXIT_FAILURE: u32 = 1;
pub const EXIT_SUCCESS: u32 = 0;
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 _ALLOCA_H: u32 = 1;
pub type __u_char = libc::c_uchar;
pub type __u_short = libc::c_ushort;
pub type __u_int = libc::c_uint;
pub type __u_long = libc::c_ulong;
pub type __int8_t = libc::c_schar;
pub type __uint8_t = libc::c_uchar;
pub type __int16_t = libc::c_short;
pub type __uint16_t = libc::c_ushort;
pub type __int32_t = libc::c_int;
pub type __uint32_t = libc::c_uint;
pub type __int64_t = libc::c_long;
pub type __uint64_t = libc::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 = libc::c_long;
pub type __u_quad_t = libc::c_ulong;
pub type __intmax_t = libc::c_long;
pub type __uintmax_t = libc::c_ulong;
pub type __dev_t = libc::c_ulong;
pub type __uid_t = libc::c_uint;
pub type __gid_t = libc::c_uint;
pub type __ino_t = libc::c_ulong;
pub type __ino64_t = libc::c_ulong;
pub type __mode_t = libc::c_uint;
pub type __nlink_t = libc::c_ulong;
pub type __off_t = libc::c_long;
pub type __off64_t = libc::c_long;
pub type __pid_t = libc::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __fsid_t {
pub __val: [libc::c_int; 2usize],
}
#[test]
fn bindgen_test_layout___fsid_t() {
const UNINIT: ::std::mem::MaybeUninit<__fsid_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).__val) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__fsid_t),
"::",
stringify!(__val)
)
);
}
pub type __clock_t = libc::c_long;
pub type __rlim_t = libc::c_ulong;
pub type __rlim64_t = libc::c_ulong;
pub type __id_t = libc::c_uint;
pub type __time_t = libc::c_long;
pub type __useconds_t = libc::c_uint;
pub type __suseconds_t = libc::c_long;
pub type __suseconds64_t = libc::c_long;
pub type __daddr_t = libc::c_int;
pub type __key_t = libc::c_int;
pub type __clockid_t = libc::c_int;
pub type __timer_t = *mut libc::c_void;
pub type __blksize_t = libc::c_long;
pub type __blkcnt_t = libc::c_long;
pub type __blkcnt64_t = libc::c_long;
pub type __fsblkcnt_t = libc::c_ulong;
pub type __fsblkcnt64_t = libc::c_ulong;
pub type __fsfilcnt_t = libc::c_ulong;
pub type __fsfilcnt64_t = libc::c_ulong;
pub type __fsword_t = libc::c_long;
pub type __ssize_t = libc::c_long;
pub type __syscall_slong_t = libc::c_long;
pub type __syscall_ulong_t = libc::c_ulong;
pub type __loff_t = __off64_t;
pub type __caddr_t = *mut libc::c_char;
pub type __intptr_t = libc::c_long;
pub type __socklen_t = libc::c_uint;
pub type __sig_atomic_t = libc::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 = libc::c_schar;
pub type int_fast16_t = libc::c_long;
pub type int_fast32_t = libc::c_long;
pub type int_fast64_t = libc::c_long;
pub type uint_fast8_t = libc::c_uchar;
pub type uint_fast16_t = libc::c_ulong;
pub type uint_fast32_t = libc::c_ulong;
pub type uint_fast64_t = libc::c_ulong;
pub type intmax_t = __intmax_t;
pub type uintmax_t = __uintmax_t;
pub type wchar_t = libc::c_int;
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct max_align_t {
pub __clang_max_align_nonce1: libc::c_longlong,
pub __bindgen_padding_0: u64,
pub __clang_max_align_nonce2: u128,
}
#[test]
fn bindgen_test_layout_max_align_t() {
const UNINIT: ::std::mem::MaybeUninit<max_align_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<max_align_t>(),
32usize,
concat!("Size of: ", stringify!(max_align_t))
);
assert_eq!(
::std::mem::align_of::<max_align_t>(),
16usize,
concat!("Alignment of ", stringify!(max_align_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__clang_max_align_nonce1) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(max_align_t),
"::",
stringify!(__clang_max_align_nonce1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__clang_max_align_nonce2) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(max_align_t),
"::",
stringify!(__clang_max_align_nonce2)
)
);
}
pub type _Float32 = f32;
pub type _Float64 = f64;
pub type _Float32x = f64;
pub type _Float64x = u128;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct div_t {
pub quot: libc::c_int,
pub rem: libc::c_int,
}
#[test]
fn bindgen_test_layout_div_t() {
const UNINIT: ::std::mem::MaybeUninit<div_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<div_t>(),
8usize,
concat!("Size of: ", stringify!(div_t))
);
assert_eq!(
::std::mem::align_of::<div_t>(),
4usize,
concat!("Alignment of ", stringify!(div_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(div_t),
"::",
stringify!(quot)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(div_t),
"::",
stringify!(rem)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ldiv_t {
pub quot: libc::c_long,
pub rem: libc::c_long,
}
#[test]
fn bindgen_test_layout_ldiv_t() {
const UNINIT: ::std::mem::MaybeUninit<ldiv_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ldiv_t>(),
16usize,
concat!("Size of: ", stringify!(ldiv_t))
);
assert_eq!(
::std::mem::align_of::<ldiv_t>(),
8usize,
concat!("Alignment of ", stringify!(ldiv_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ldiv_t),
"::",
stringify!(quot)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ldiv_t),
"::",
stringify!(rem)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lldiv_t {
pub quot: libc::c_longlong,
pub rem: libc::c_longlong,
}
#[test]
fn bindgen_test_layout_lldiv_t() {
const UNINIT: ::std::mem::MaybeUninit<lldiv_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lldiv_t>(),
16usize,
concat!("Size of: ", stringify!(lldiv_t))
);
assert_eq!(
::std::mem::align_of::<lldiv_t>(),
8usize,
concat!("Alignment of ", stringify!(lldiv_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lldiv_t),
"::",
stringify!(quot)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lldiv_t),
"::",
stringify!(rem)
)
);
}
extern "C" {
pub fn __ctype_get_mb_cur_max() -> usize;
}
extern "C" {
pub fn atof(__nptr: *const libc::c_char) -> f64;
}
extern "C" {
pub fn atoi(__nptr: *const libc::c_char) -> libc::c_int;
}
extern "C" {
pub fn atol(__nptr: *const libc::c_char) -> libc::c_long;
}
extern "C" {
pub fn atoll(__nptr: *const libc::c_char) -> libc::c_longlong;
}
extern "C" {
pub fn strtod(__nptr: *const libc::c_char, __endptr: *mut *mut libc::c_char) -> f64;
}
extern "C" {
pub fn strtof(__nptr: *const libc::c_char, __endptr: *mut *mut libc::c_char) -> f32;
}
extern "C" {
pub fn strtold(__nptr: *const libc::c_char, __endptr: *mut *mut libc::c_char) -> u128;
}
extern "C" {
pub fn strtol(
__nptr: *const libc::c_char,
__endptr: *mut *mut libc::c_char,
__base: libc::c_int,
) -> libc::c_long;
}
extern "C" {
pub fn strtoul(
__nptr: *const libc::c_char,
__endptr: *mut *mut libc::c_char,
__base: libc::c_int,
) -> libc::c_ulong;
}
extern "C" {
pub fn strtoq(
__nptr: *const libc::c_char,
__endptr: *mut *mut libc::c_char,
__base: libc::c_int,
) -> libc::c_longlong;
}
extern "C" {
pub fn strtouq(
__nptr: *const libc::c_char,
__endptr: *mut *mut libc::c_char,
__base: libc::c_int,
) -> libc::c_ulonglong;
}
extern "C" {
pub fn strtoll(
__nptr: *const libc::c_char,
__endptr: *mut *mut libc::c_char,
__base: libc::c_int,
) -> libc::c_longlong;
}
extern "C" {
pub fn strtoull(
__nptr: *const libc::c_char,
__endptr: *mut *mut libc::c_char,
__base: libc::c_int,
) -> libc::c_ulonglong;
}
extern "C" {
pub fn l64a(__n: libc::c_long) -> *mut libc::c_char;
}
extern "C" {
pub fn a64l(__s: *const libc::c_char) -> libc::c_long;
}
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 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 ulong = libc::c_ulong;
pub type ushort = libc::c_ushort;
pub type uint = libc::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 = libc::c_long;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __sigset_t {
pub __val: [libc::c_ulong; 16usize],
}
#[test]
fn bindgen_test_layout___sigset_t() {
const UNINIT: ::std::mem::MaybeUninit<__sigset_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).__val) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<timeval> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(timeval),
"::",
stringify!(tv_sec)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_usec) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<timespec> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(timespec),
"::",
stringify!(tv_sec)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(timespec),
"::",
stringify!(tv_nsec)
)
);
}
pub type suseconds_t = __suseconds_t;
pub type __fd_mask = libc::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() {
const UNINIT: ::std::mem::MaybeUninit<fd_set> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).__fds_bits) as usize - ptr 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: libc::c_int,
__readfds: *mut fd_set,
__writefds: *mut fd_set,
__exceptfds: *mut fd_set,
__timeout: *mut timeval,
) -> libc::c_int;
}
extern "C" {
pub fn pselect(
__nfds: libc::c_int,
__readfds: *mut fd_set,
__writefds: *mut fd_set,
__exceptfds: *mut fd_set,
__timeout: *const timespec,
__sigmask: *const __sigset_t,
) -> libc::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(Copy, Clone)]
pub union __atomic_wide_counter {
pub __value64: libc::c_ulonglong,
pub __value32: __atomic_wide_counter__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __atomic_wide_counter__bindgen_ty_1 {
pub __low: libc::c_uint,
pub __high: libc::c_uint,
}
#[test]
fn bindgen_test_layout___atomic_wide_counter__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<__atomic_wide_counter__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__atomic_wide_counter__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(__atomic_wide_counter__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<__atomic_wide_counter__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(__atomic_wide_counter__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__low) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__atomic_wide_counter__bindgen_ty_1),
"::",
stringify!(__low)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__high) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__atomic_wide_counter__bindgen_ty_1),
"::",
stringify!(__high)
)
);
}
#[test]
fn bindgen_test_layout___atomic_wide_counter() {
const UNINIT: ::std::mem::MaybeUninit<__atomic_wide_counter> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__atomic_wide_counter>(),
8usize,
concat!("Size of: ", stringify!(__atomic_wide_counter))
);
assert_eq!(
::std::mem::align_of::<__atomic_wide_counter>(),
8usize,
concat!("Alignment of ", stringify!(__atomic_wide_counter))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__value64) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__atomic_wide_counter),
"::",
stringify!(__value64)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__value32) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__atomic_wide_counter),
"::",
stringify!(__value32)
)
);
}
#[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() {
const UNINIT: ::std::mem::MaybeUninit<__pthread_internal_list> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).__prev) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_list),
"::",
stringify!(__prev)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__next) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<__pthread_internal_slist> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).__next) as usize - ptr 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: libc::c_int,
pub __count: libc::c_uint,
pub __owner: libc::c_int,
pub __nusers: libc::c_uint,
pub __kind: libc::c_int,
pub __spins: libc::c_short,
pub __elision: libc::c_short,
pub __list: __pthread_list_t,
}
#[test]
fn bindgen_test_layout___pthread_mutex_s() {
const UNINIT: ::std::mem::MaybeUninit<__pthread_mutex_s> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).__lock) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__lock)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__count) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__owner) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__owner)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__nusers) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__nusers)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__kind) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__kind)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__spins) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__spins)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__elision) as usize - ptr as usize },
22usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__elision)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__list) as usize - ptr 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: libc::c_uint,
pub __writers: libc::c_uint,
pub __wrphase_futex: libc::c_uint,
pub __writers_futex: libc::c_uint,
pub __pad3: libc::c_uint,
pub __pad4: libc::c_uint,
pub __cur_writer: libc::c_int,
pub __shared: libc::c_int,
pub __rwelision: libc::c_schar,
pub __pad1: [libc::c_uchar; 7usize],
pub __pad2: libc::c_ulong,
pub __flags: libc::c_uint,
}
#[test]
fn bindgen_test_layout___pthread_rwlock_arch_t() {
const UNINIT: ::std::mem::MaybeUninit<__pthread_rwlock_arch_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).__readers) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__readers)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__writers) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__writers)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__wrphase_futex) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__wrphase_futex)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__writers_futex) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__writers_futex)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__pad3) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__pad3)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__pad4) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__pad4)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__cur_writer) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__cur_writer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__shared) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__shared)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__rwelision) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__rwelision)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__pad1) as usize - ptr as usize },
33usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__pad1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__pad2) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__pad2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__flags) as usize - ptr 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 __wseq: __atomic_wide_counter,
pub __g1_start: __atomic_wide_counter,
pub __g_refs: [libc::c_uint; 2usize],
pub __g_size: [libc::c_uint; 2usize],
pub __g1_orig_size: libc::c_uint,
pub __wrefs: libc::c_uint,
pub __g_signals: [libc::c_uint; 2usize],
}
#[test]
fn bindgen_test_layout___pthread_cond_s() {
const UNINIT: ::std::mem::MaybeUninit<__pthread_cond_s> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).__wseq) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__wseq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__g1_start) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g1_start)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__g_refs) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_refs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__g_size) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__g1_orig_size) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g1_orig_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__wrefs) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__wrefs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__g_signals) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_signals)
)
);
}
pub type __tss_t = libc::c_uint;
pub type __thrd_t = libc::c_ulong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __once_flag {
pub __data: libc::c_int,
}
#[test]
fn bindgen_test_layout___once_flag() {
const UNINIT: ::std::mem::MaybeUninit<__once_flag> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).__data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__once_flag),
"::",
stringify!(__data)
)
);
}
pub type pthread_t = libc::c_ulong;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_mutexattr_t {
pub __size: [libc::c_char; 4usize],
pub __align: libc::c_int,
}
#[test]
fn bindgen_test_layout_pthread_mutexattr_t() {
const UNINIT: ::std::mem::MaybeUninit<pthread_mutexattr_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutexattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr 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: [libc::c_char; 4usize],
pub __align: libc::c_int,
}
#[test]
fn bindgen_test_layout_pthread_condattr_t() {
const UNINIT: ::std::mem::MaybeUninit<pthread_condattr_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_condattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_condattr_t),
"::",
stringify!(__align)
)
);
}
pub type pthread_key_t = libc::c_uint;
pub type pthread_once_t = libc::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_attr_t {
pub __size: [libc::c_char; 56usize],
pub __align: libc::c_long,
}
#[test]
fn bindgen_test_layout_pthread_attr_t() {
const UNINIT: ::std::mem::MaybeUninit<pthread_attr_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_attr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr 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: [libc::c_char; 40usize],
pub __align: libc::c_long,
}
#[test]
fn bindgen_test_layout_pthread_mutex_t() {
const UNINIT: ::std::mem::MaybeUninit<pthread_mutex_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).__data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr 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: [libc::c_char; 48usize],
pub __align: libc::c_longlong,
}
#[test]
fn bindgen_test_layout_pthread_cond_t() {
const UNINIT: ::std::mem::MaybeUninit<pthread_cond_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).__data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr 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: [libc::c_char; 56usize],
pub __align: libc::c_long,
}
#[test]
fn bindgen_test_layout_pthread_rwlock_t() {
const UNINIT: ::std::mem::MaybeUninit<pthread_rwlock_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).__data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlock_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlock_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr 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: [libc::c_char; 8usize],
pub __align: libc::c_long,
}
#[test]
fn bindgen_test_layout_pthread_rwlockattr_t() {
const UNINIT: ::std::mem::MaybeUninit<pthread_rwlockattr_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlockattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlockattr_t),
"::",
stringify!(__align)
)
);
}
pub type pthread_spinlock_t = libc::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_barrier_t {
pub __size: [libc::c_char; 32usize],
pub __align: libc::c_long,
}
#[test]
fn bindgen_test_layout_pthread_barrier_t() {
const UNINIT: ::std::mem::MaybeUninit<pthread_barrier_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_barrier_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr 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: [libc::c_char; 4usize],
pub __align: libc::c_int,
}
#[test]
fn bindgen_test_layout_pthread_barrierattr_t() {
const UNINIT: ::std::mem::MaybeUninit<pthread_barrierattr_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_barrierattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_barrierattr_t),
"::",
stringify!(__align)
)
);
}
extern "C" {
pub fn random() -> libc::c_long;
}
extern "C" {
pub fn srandom(__seed: libc::c_uint);
}
extern "C" {
pub fn initstate(
__seed: libc::c_uint,
__statebuf: *mut libc::c_char,
__statelen: usize,
) -> *mut libc::c_char;
}
extern "C" {
pub fn setstate(__statebuf: *mut libc::c_char) -> *mut libc::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct random_data {
pub fptr: *mut i32,
pub rptr: *mut i32,
pub state: *mut i32,
pub rand_type: libc::c_int,
pub rand_deg: libc::c_int,
pub rand_sep: libc::c_int,
pub end_ptr: *mut i32,
}
#[test]
fn bindgen_test_layout_random_data() {
const UNINIT: ::std::mem::MaybeUninit<random_data> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<random_data>(),
48usize,
concat!("Size of: ", stringify!(random_data))
);
assert_eq!(
::std::mem::align_of::<random_data>(),
8usize,
concat!("Alignment of ", stringify!(random_data))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fptr) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(random_data),
"::",
stringify!(fptr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rptr) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(random_data),
"::",
stringify!(rptr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(random_data),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rand_type) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(random_data),
"::",
stringify!(rand_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rand_deg) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(random_data),
"::",
stringify!(rand_deg)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rand_sep) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(random_data),
"::",
stringify!(rand_sep)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).end_ptr) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(random_data),
"::",
stringify!(end_ptr)
)
);
}
extern "C" {
pub fn random_r(__buf: *mut random_data, __result: *mut i32) -> libc::c_int;
}
extern "C" {
pub fn srandom_r(__seed: libc::c_uint, __buf: *mut random_data) -> libc::c_int;
}
extern "C" {
pub fn initstate_r(
__seed: libc::c_uint,
__statebuf: *mut libc::c_char,
__statelen: usize,
__buf: *mut random_data,
) -> libc::c_int;
}
extern "C" {
pub fn setstate_r(__statebuf: *mut libc::c_char, __buf: *mut random_data) -> libc::c_int;
}
extern "C" {
pub fn rand() -> libc::c_int;
}
extern "C" {
pub fn srand(__seed: libc::c_uint);
}
extern "C" {
pub fn rand_r(__seed: *mut libc::c_uint) -> libc::c_int;
}
extern "C" {
pub fn drand48() -> f64;
}
extern "C" {
pub fn erand48(__xsubi: *mut libc::c_ushort) -> f64;
}
extern "C" {
pub fn lrand48() -> libc::c_long;
}
extern "C" {
pub fn nrand48(__xsubi: *mut libc::c_ushort) -> libc::c_long;
}
extern "C" {
pub fn mrand48() -> libc::c_long;
}
extern "C" {
pub fn jrand48(__xsubi: *mut libc::c_ushort) -> libc::c_long;
}
extern "C" {
pub fn srand48(__seedval: libc::c_long);
}
extern "C" {
pub fn seed48(__seed16v: *mut libc::c_ushort) -> *mut libc::c_ushort;
}
extern "C" {
pub fn lcong48(__param: *mut libc::c_ushort);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct drand48_data {
pub __x: [libc::c_ushort; 3usize],
pub __old_x: [libc::c_ushort; 3usize],
pub __c: libc::c_ushort,
pub __init: libc::c_ushort,
pub __a: libc::c_ulonglong,
}
#[test]
fn bindgen_test_layout_drand48_data() {
const UNINIT: ::std::mem::MaybeUninit<drand48_data> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<drand48_data>(),
24usize,
concat!("Size of: ", stringify!(drand48_data))
);
assert_eq!(
::std::mem::align_of::<drand48_data>(),
8usize,
concat!("Alignment of ", stringify!(drand48_data))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(drand48_data),
"::",
stringify!(__x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__old_x) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(drand48_data),
"::",
stringify!(__old_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__c) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(drand48_data),
"::",
stringify!(__c)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__init) as usize - ptr as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(drand48_data),
"::",
stringify!(__init)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__a) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(drand48_data),
"::",
stringify!(__a)
)
);
}
extern "C" {
pub fn drand48_r(__buffer: *mut drand48_data, __result: *mut f64) -> libc::c_int;
}
extern "C" {
pub fn erand48_r(
__xsubi: *mut libc::c_ushort,
__buffer: *mut drand48_data,
__result: *mut f64,
) -> libc::c_int;
}
extern "C" {
pub fn lrand48_r(__buffer: *mut drand48_data, __result: *mut libc::c_long) -> libc::c_int;
}
extern "C" {
pub fn nrand48_r(
__xsubi: *mut libc::c_ushort,
__buffer: *mut drand48_data,
__result: *mut libc::c_long,
) -> libc::c_int;
}
extern "C" {
pub fn mrand48_r(__buffer: *mut drand48_data, __result: *mut libc::c_long) -> libc::c_int;
}
extern "C" {
pub fn jrand48_r(
__xsubi: *mut libc::c_ushort,
__buffer: *mut drand48_data,
__result: *mut libc::c_long,
) -> libc::c_int;
}
extern "C" {
pub fn srand48_r(__seedval: libc::c_long, __buffer: *mut drand48_data) -> libc::c_int;
}
extern "C" {
pub fn seed48_r(__seed16v: *mut libc::c_ushort, __buffer: *mut drand48_data) -> libc::c_int;
}
extern "C" {
pub fn lcong48_r(__param: *mut libc::c_ushort, __buffer: *mut drand48_data) -> libc::c_int;
}
extern "C" {
pub fn arc4random() -> __uint32_t;
}
extern "C" {
pub fn arc4random_buf(__buf: *mut libc::c_void, __size: usize);
}
extern "C" {
pub fn arc4random_uniform(__upper_bound: __uint32_t) -> __uint32_t;
}
extern "C" {
pub fn malloc(__size: libc::c_ulong) -> *mut libc::c_void;
}
extern "C" {
pub fn calloc(__nmemb: libc::c_ulong, __size: libc::c_ulong) -> *mut libc::c_void;
}
extern "C" {
pub fn realloc(__ptr: *mut libc::c_void, __size: libc::c_ulong) -> *mut libc::c_void;
}
extern "C" {
pub fn free(__ptr: *mut libc::c_void);
}
extern "C" {
pub fn reallocarray(
__ptr: *mut libc::c_void,
__nmemb: usize,
__size: usize,
) -> *mut libc::c_void;
}
extern "C" {
pub fn alloca(__size: libc::c_ulong) -> *mut libc::c_void;
}
extern "C" {
pub fn valloc(__size: usize) -> *mut libc::c_void;
}
extern "C" {
pub fn posix_memalign(
__memptr: *mut *mut libc::c_void,
__alignment: usize,
__size: usize,
) -> libc::c_int;
}
extern "C" {
pub fn aligned_alloc(__alignment: libc::c_ulong, __size: libc::c_ulong) -> *mut libc::c_void;
}
extern "C" {
pub fn abort() -> !;
}
extern "C" {
pub fn atexit(__func: ::std::option::Option<unsafe extern "C" fn()>) -> libc::c_int;
}
extern "C" {
pub fn at_quick_exit(__func: ::std::option::Option<unsafe extern "C" fn()>) -> libc::c_int;
}
extern "C" {
pub fn on_exit(
__func: ::std::option::Option<
unsafe extern "C" fn(__status: libc::c_int, __arg: *mut libc::c_void),
>,
__arg: *mut libc::c_void,
) -> libc::c_int;
}
extern "C" {
pub fn exit(__status: libc::c_int) -> !;
}
extern "C" {
pub fn quick_exit(__status: libc::c_int) -> !;
}
extern "C" {
pub fn _Exit(__status: libc::c_int) -> !;
}
extern "C" {
pub fn getenv(__name: *const libc::c_char) -> *mut libc::c_char;
}
extern "C" {
pub fn putenv(__string: *mut libc::c_char) -> libc::c_int;
}
extern "C" {
pub fn setenv(
__name: *const libc::c_char,
__value: *const libc::c_char,
__replace: libc::c_int,
) -> libc::c_int;
}
extern "C" {
pub fn unsetenv(__name: *const libc::c_char) -> libc::c_int;
}
extern "C" {
pub fn clearenv() -> libc::c_int;
}
extern "C" {
pub fn mktemp(__template: *mut libc::c_char) -> *mut libc::c_char;
}
extern "C" {
pub fn mkstemp(__template: *mut libc::c_char) -> libc::c_int;
}
extern "C" {
pub fn mkstemps(__template: *mut libc::c_char, __suffixlen: libc::c_int) -> libc::c_int;
}
extern "C" {
pub fn mkdtemp(__template: *mut libc::c_char) -> *mut libc::c_char;
}
extern "C" {
pub fn system(__command: *const libc::c_char) -> libc::c_int;
}
extern "C" {
pub fn realpath(
__name: *const libc::c_char,
__resolved: *mut libc::c_char,
) -> *mut libc::c_char;
}
pub type __compar_fn_t = ::std::option::Option<
unsafe extern "C" fn(arg1: *const libc::c_void, arg2: *const libc::c_void) -> libc::c_int,
>;
extern "C" {
pub fn bsearch(
__key: *const libc::c_void,
__base: *const libc::c_void,
__nmemb: usize,
__size: usize,
__compar: __compar_fn_t,
) -> *mut libc::c_void;
}
extern "C" {
pub fn qsort(__base: *mut libc::c_void, __nmemb: usize, __size: usize, __compar: __compar_fn_t);
}
extern "C" {
pub fn abs(__x: libc::c_int) -> libc::c_int;
}
extern "C" {
pub fn labs(__x: libc::c_long) -> libc::c_long;
}
extern "C" {
pub fn llabs(__x: libc::c_longlong) -> libc::c_longlong;
}
extern "C" {
pub fn div(__numer: libc::c_int, __denom: libc::c_int) -> div_t;
}
extern "C" {
pub fn ldiv(__numer: libc::c_long, __denom: libc::c_long) -> ldiv_t;
}
extern "C" {
pub fn lldiv(__numer: libc::c_longlong, __denom: libc::c_longlong) -> lldiv_t;
}
extern "C" {
pub fn ecvt(
__value: f64,
__ndigit: libc::c_int,
__decpt: *mut libc::c_int,
__sign: *mut libc::c_int,
) -> *mut libc::c_char;
}
extern "C" {
pub fn fcvt(
__value: f64,
__ndigit: libc::c_int,
__decpt: *mut libc::c_int,
__sign: *mut libc::c_int,
) -> *mut libc::c_char;
}
extern "C" {
pub fn gcvt(__value: f64, __ndigit: libc::c_int, __buf: *mut libc::c_char)
-> *mut libc::c_char;
}
extern "C" {
pub fn qecvt(
__value: u128,
__ndigit: libc::c_int,
__decpt: *mut libc::c_int,
__sign: *mut libc::c_int,
) -> *mut libc::c_char;
}
extern "C" {
pub fn qfcvt(
__value: u128,
__ndigit: libc::c_int,
__decpt: *mut libc::c_int,
__sign: *mut libc::c_int,
) -> *mut libc::c_char;
}
extern "C" {
pub fn qgcvt(
__value: u128,
__ndigit: libc::c_int,
__buf: *mut libc::c_char,
) -> *mut libc::c_char;
}
extern "C" {
pub fn ecvt_r(
__value: f64,
__ndigit: libc::c_int,
__decpt: *mut libc::c_int,
__sign: *mut libc::c_int,
__buf: *mut libc::c_char,
__len: usize,
) -> libc::c_int;
}
extern "C" {
pub fn fcvt_r(
__value: f64,
__ndigit: libc::c_int,
__decpt: *mut libc::c_int,
__sign: *mut libc::c_int,
__buf: *mut libc::c_char,
__len: usize,
) -> libc::c_int;
}
extern "C" {
pub fn qecvt_r(
__value: u128,
__ndigit: libc::c_int,
__decpt: *mut libc::c_int,
__sign: *mut libc::c_int,
__buf: *mut libc::c_char,
__len: usize,
) -> libc::c_int;
}
extern "C" {
pub fn qfcvt_r(
__value: u128,
__ndigit: libc::c_int,
__decpt: *mut libc::c_int,
__sign: *mut libc::c_int,
__buf: *mut libc::c_char,
__len: usize,
) -> libc::c_int;
}
extern "C" {
pub fn mblen(__s: *const libc::c_char, __n: usize) -> libc::c_int;
}
extern "C" {
pub fn mbtowc(__pwc: *mut wchar_t, __s: *const libc::c_char, __n: usize) -> libc::c_int;
}
extern "C" {
pub fn wctomb(__s: *mut libc::c_char, __wchar: wchar_t) -> libc::c_int;
}
extern "C" {
pub fn mbstowcs(__pwcs: *mut wchar_t, __s: *const libc::c_char, __n: usize) -> usize;
}
extern "C" {
pub fn wcstombs(__s: *mut libc::c_char, __pwcs: *const wchar_t, __n: usize) -> usize;
}
extern "C" {
pub fn rpmatch(__response: *const libc::c_char) -> libc::c_int;
}
extern "C" {
pub fn getsubopt(
__optionp: *mut *mut libc::c_char,
__tokens: *const *mut libc::c_char,
__valuep: *mut *mut libc::c_char,
) -> libc::c_int;
}
extern "C" {
pub fn getloadavg(__loadavg: *mut f64, __nelem: libc::c_int) -> libc::c_int;
}
#[doc = " Auto–index for NULL keys. When enabled, passing NULL\n as the key to qmap_put generates auto-incrementing IDs."]
pub const qmap_flags_QM_AINDEX: qmap_flags = 1;
#[doc = " Create reverse-lookup (secondary) map. The mirror map\n handle is always primary_hd + 1 and swaps keys/values.\n\n QM_MIRROR is useful when you need bidirectional lookup (key→value\n and value→key) and is commonly used with file persistence.\n\n The mirror map is automatically closed when you close the primary\n map via qmap_close(hd)."]
pub const qmap_flags_QM_MIRROR: qmap_flags = 2;
#[doc = " For associated maps: default to obtaining primary keys\n instead of values. Used internally for mirror maps and\n essential for creating value→key secondary indexes.\n\n When a secondary map has QM_PGET, qmap_get() returns\n the primary key instead of the primary value. This allows\n secondary indexes to map from values back to keys."]
pub const qmap_flags_QM_PGET: qmap_flags = 4;
#[doc = " Enable sorted index support (B-tree search). Enables\n ordered iteration. Index is automatically rebuilt on\n modifications (put/del operations mark it dirty).\n\n Performance Note: The sorted index is rebuilt from scratch\n whenever it's marked dirty and iteration is requested.\n This makes the first iteration after modifications O(n log n)\n instead of O(n)."]
pub const qmap_flags_QM_SORTED: qmap_flags = 8;
#[doc = " Allow duplicate keys in sorted maps. Enables multi-value\n lookups where multiple entries can share the same key.\n\n REQUIRES QM_SORTED: This flag cannot be used without QM_SORTED.\n qmap_open() will return QM_MISS if QM_MULTIVALUE is set without\n QM_SORTED.\n\n Behavior:\n - qmap_put() with an existing key ADDS a new entry (does not replace)\n - qmap_get() returns the FIRST matching value\n - qmap_get_multi() returns cursor to iterate over ALL matching values\n - qmap_count() returns the number of entries for a key\n - qmap_del() deletes only the FIRST matching entry\n - qmap_del_all() deletes ALL entries with the specified key\n\n Use Case: Secondary indexes via qmap_assoc() where multiple primary\n entries map to the same secondary key."]
pub const qmap_flags_QM_MULTIVALUE: qmap_flags = 16;
#[doc = " Disable auto-grow. When set and the map reaches capacity,\n inserts return QM_MISS instead of growing the table.\n Use for memory-constrained environments or fixed-size tables."]
pub const qmap_flags_QM_NOGROW: qmap_flags = 32;
#[doc = " @brief QMap flags."]
pub type qmap_flags = libc::c_uint;
#[doc = " Pointer (hashed)."]
pub const qmap_tbi_QM_PTR: qmap_tbi = 0;
#[doc = " Opaque handle. Uses value directly as hash (no transformation)."]
pub const qmap_tbi_QM_HNDL: qmap_tbi = 1;
#[doc = " String contents hash and compare."]
pub const qmap_tbi_QM_STR: qmap_tbi = 2;
#[doc = " 32-bit unsigned integer (hash and mask)."]
pub const qmap_tbi_QM_U32: qmap_tbi = 3;
#[doc = " @brief Built-in type identifiers."]
pub type qmap_tbi = libc::c_uint;
#[doc = " Continue iteration even if key differs from the initial.\n Behavior depends on whether QM_SORTED was set on the map:\n - With QM_SORTED: performs ordered range scan from the\n starting key onwards (B-tree ordered iteration)\n - Without QM_SORTED: performs linear scan through the\n hash table, comparing keys with the initial key using\n the type's comparison function"]
pub const qmap_if_QM_RANGE: qmap_if = 1;
#[doc = " @brief Iterator flags."]
pub type qmap_if = libc::c_uint;
extern "C" {
#[doc = " @brief Open a database.\n\n Creates an in-memory map and registers its handle\n with the internal file cache, linking it to\n 'filename'. If a file exists, it loads the map\n data for the specified 'database'.\n\n @param[in] filename Path to file or cache key.\n NULL → in-memory only.\n @param[in] database Logical name within file.\n NULL → skip file association.\n @param[in] ktype Built-in or registered key\n type.\n @param[in] vtype Built-in or registered value\n type.\n @param[in] mask Must be 2ⁿ − 1; table size is\n (mask + 1).\n @param[in] flags Bitwise OR of QM_AINDEX,\n QM_MIRROR, QM_SORTED, etc.\n @return Map handle (hd).\n\n @note File Persistence: File-backed maps automatically load\n data from disk when opened, regardless of flags. The\n QM_MIRROR flag enables bidirectional lookup (creating a\n reverse map at handle hd + 1) which is useful for many\n persistence scenarios. The mirror map is automatically\n closed when closing the primary map.\n\n @note Multiple databases can share a single file. Each database\n is identified by a hash of its name (XXH32). Data is saved\n and loaded based on this database ID."]
pub fn qmap_open(
filename: *const libc::c_char,
database: *const libc::c_char,
ktype: u32,
vtype: u32,
mask: u32,
flags: u32,
) -> u32;
}
extern "C" {
#[doc = " @brief Write all file-backed maps to disk.\n\n Walks the internal cache, computes file sizes,\n and performs mmap/memcpy writes for maps\n associated with a file.\n\n @note This is automatically called at process exit.\n Explicit calls are only needed for mid-execution\n checkpointing or when you want to ensure data\n is persisted before continuing."]
pub fn qmap_save();
}
extern "C" {
#[doc = " @brief Close a map and free its resources.\n\n Deletes all entries, closes associated secondary maps,\n and frees internal structures. All open maps are\n automatically closed at process exit by the library\n destructor, but you can call this explicitly to free\n resources earlier.\n\n @param[in] hd Handle to close."]
pub fn qmap_close(hd: u32);
}
extern "C" {
#[doc = " @brief Retrieve a value by key.\n\n For maps with QM_MULTIVALUE flag, this returns the FIRST\n matching value only. To retrieve all values for a key, use\n qmap_get_multi() instead.\n\n @param[in] hd Map handle.\n @param[in] key Key to look up.\n @return Pointer to value or NULL if not found.\n For QM_MULTIVALUE maps, returns first match.\n See qmap_common for pointer ownership rules."]
pub fn qmap_get(hd: u32, key: *const libc::c_void) -> *const libc::c_void;
}
extern "C" {
#[doc = " @brief Insert or update a pair.\n\n Behavior depends on the QM_MULTIVALUE flag:\n - Without QM_MULTIVALUE: Replaces existing value if key exists\n - With QM_MULTIVALUE: Always adds a new entry (duplicates allowed)\n\n @param[in] hd Map handle.\n @param[in] key Key (NULL if QM_AINDEX).\n @param[in] value Value to store.\n @return Internal index for the entry. With QM_AINDEX,\n this is the generated key ID."]
pub fn qmap_put(hd: u32, key: *const libc::c_void, value: *const libc::c_void) -> u32;
}
extern "C" {
#[doc = " @brief Delete an entry by key.\n\n For maps with QM_MULTIVALUE flag, this only deletes the FIRST\n occurrence of the key. To delete all duplicates, call this\n function multiple times until the key no longer exists.\n\n @param[in] hd Map handle.\n @param[in] key Key to delete."]
pub fn qmap_del(hd: u32, key: *const libc::c_void);
}
extern "C" {
#[doc = " @brief Delete all entries with the specified key.\n\n For QM_MULTIVALUE maps, removes all duplicate entries. For regular maps,\n behaves identically to qmap_del().\n\n @param[in] hd Map handle.\n @param[in] key Key of entries to delete.\n\n @see qmap_del\n @see qmap_get_multi"]
pub fn qmap_del_all(hd: u32, key: *const libc::c_void);
}
extern "C" {
#[doc = " @brief Remove all entries from a map.\n\n @param[in] hd Map handle."]
pub fn qmap_drop(hd: u32);
}
#[doc = " @brief Association callback type.\n\n After association, future puts/dels on the\n primary will update the secondary.\n Deletes on the primary remove corresponding\n entries from the secondary.\n\n @param[out] skey Pointer to set secondary key.\n @param[in] pkey Primary key.\n @param[in] value Primary value."]
pub type qmap_assoc_t = ::std::option::Option<
unsafe extern "C" fn(
skey: *mut *const libc::c_void,
pkey: *const libc::c_void,
value: *const libc::c_void,
),
>;
extern "C" {
#[doc = " @brief Make an association between tables.\n\n Links a secondary (index) map to a primary map so that\n put/delete operations on the primary automatically update\n the secondary. The callback determines the secondary key.\n\n @param[in] hd Secondary (index) map handle.\n @param[in] link Primary (source) map handle.\n @param[in] cb Callback to produce secondary\n keys. NULL → use primary value.\n\n @note The secondary map stores (secondary_key, primary_value).\n To retrieve the primary KEY instead of the primary VALUE,\n the secondary map must be created with the QM_PGET flag.\n This is essential for creating value→key indexes.\n\n @code\n // Example: Create a secondary index from username -> user_id\n // Primary: user_id -> username\n uint32_t users = qmap_open(NULL, NULL, QM_U32, QM_STR, 0xFF, 0);\n\n // Secondary: username -> user_id\n // QM_PGET makes qmap_get return the primary key instead of value\n uint32_t by_name = qmap_open(NULL, NULL, QM_STR, QM_U32, 0xFF, QM_PGET);\n\n // Callback: use primary value (username) as secondary key\n static void value_to_key(const void **skey,\n const void *pkey,\n const void *value) {\n (void) pkey;\n *skey = value; // Use username as key\n }\n\n qmap_assoc(by_name, users, value_to_key);\n\n // Now puts to 'users' automatically update 'by_name'\n qmap_put(users, &(uint32_t){100}, \"alice\");\n // by_name now contains: \"alice\" -> 100\n @endcode"]
pub fn qmap_assoc(hd: u32, link: u32, cb: qmap_assoc_t);
}
extern "C" {
#[doc = " @brief Start iteration.\n\n Creates a cursor for iterating over map entries.\n Ordered ranges require QM_SORTED flag on the map.\n\n @param[in] hd Map handle.\n @param[in] key Starting key or NULL for all entries.\n @param[in] flags Iterator flags (QM_RANGE valid).\n - QM_RANGE with QM_SORTED: ordered scan\n - QM_RANGE without QM_SORTED: linear scan\n - No flags: iterate single key (or all if key is NULL)\n @return Cursor handle for use with qmap_next."]
pub fn qmap_iter(hd: u32, key: *const libc::c_void, flags: u32) -> u32;
}
extern "C" {
#[doc = " @brief Fetch next key/value.\n\n @param[out] key Pointer to key.\n @param[out] value Pointer to value.\n @param[in] cur_id Cursor handle.\n @return 1 if valid, 0 if done.\n See qmap_common for pointer ownership rules."]
pub fn qmap_next(
key: *mut *const libc::c_void,
value: *mut *const libc::c_void,
cur_id: u32,
) -> libc::c_int;
}
extern "C" {
#[doc = " @brief End iteration early.\n\n @param[in] cur_id Cursor handle."]
pub fn qmap_fin(cur_id: u32);
}
extern "C" {
#[doc = " @brief Start iteration over all values for a key.\n\n For maps with QM_MULTIVALUE flag, this returns a cursor that\n iterates over ALL values associated with the given key in\n sorted order. For maps without QM_MULTIVALUE, this behaves\n like a single-value iterator.\n\n @param[in] hd Map handle.\n @param[in] key Key to look up.\n @return Cursor handle for use with qmap_next(), or\n QM_MISS if key not found.\n\n Example:\n @code\n uint32_t cur = qmap_get_multi(hd, &key);\n if (cur != QM_MISS) {\n const void *k, *v;\n while (qmap_next(&k, &v, cur)) {\n // Process each value for this key\n }\n qmap_fin(cur);\n }\n @endcode\n\n @note Internally, this is equivalent to: qmap_iter(hd, key, 0)\n @note For single-value lookups, qmap_get() is more efficient\n @see qmap_del_all for deleting all duplicates at once\n @see qmap_count for counting entries without iteration"]
pub fn qmap_get_multi(hd: u32, key: *const libc::c_void) -> u32;
}
extern "C" {
#[doc = " @brief Count entries matching a key.\n\n @param[in] hd Map handle.\n @param[in] key Key to count. NULL counts total entries in map.\n @return Number of matching entries.\n\n @note For QM_MULTIVALUE maps, returns count of all duplicate values\n @note For normal maps, returns 0 or 1"]
pub fn qmap_count(hd: u32, key: *const libc::c_void) -> u32;
}
#[doc = " @brief Callback to measure variable-size keys.\n\n Keys of dynamic length need measurement when\n hashing/comparing beyond pointer equality.\n\n @param[in] data Pointer to key.\n @return Key size in bytes."]
pub type qmap_measure_t =
::std::option::Option<unsafe extern "C" fn(data: *const libc::c_void) -> usize>;
extern "C" {
#[doc = " @brief Register a fixed-length type.\n\n Registers a new custom type with a fixed byte length.\n The type will use the default hash (XXH32) and\n comparison (memcmp) functions.\n\n @param[in] len Length in bytes.\n @return Type ID for use in qmap_open, or\n QM_MISS if type limit is reached."]
pub fn qmap_reg(len: usize) -> u32;
}
#[doc = " @brief Comparison callback type.\n\n @param[in] a First object.\n @param[in] b Second object.\n @param[in] len Length in bytes.\n @return <0, 0, or >0."]
pub type qmap_cmp_t = ::std::option::Option<
unsafe extern "C" fn(a: *const libc::c_void, b: *const libc::c_void, len: usize) -> libc::c_int,
>;
extern "C" {
#[doc = " @brief Assign comparison function to a type.\n\n @param[in] ref Type ID.\n @param[in] cmp Comparison callback."]
pub fn qmap_cmp_set(ref_: u32, cmp: qmap_cmp_t);
}
extern "C" {
#[doc = " @brief Register a variable-length type.\n\n Registers a new custom type with variable length.\n A measurement callback is required to determine the\n size of each element. The type will use the default\n hash (XXH32) and comparison (memcmp) functions.\n\n @param[in] measure Size-measuring callback.\n @return Type ID for use in qmap_open, or\n QM_MISS if type limit is reached."]
pub fn qmap_mreg(measure: qmap_measure_t) -> u32;
}
extern "C" {
#[doc = " @brief Get the byte length of an element.\n\n @param[in] type_id Type ID.\n @param[in] data Element pointer.\n @return Size in bytes."]
pub fn qmap_len(type_id: u32, data: *const libc::c_void) -> usize;
}