pub const cTRUE: u32 = 1;
pub const cFALSE: u32 = 0;
pub const c_FEATURES_H: u32 = 1;
pub const c_DEFAULT_SOURCE: u32 = 1;
pub const c__GLIBC_USE_ISOC2X: u32 = 0;
pub const c__USE_ISOC11: u32 = 1;
pub const c__USE_ISOC99: u32 = 1;
pub const c__USE_ISOC95: u32 = 1;
pub const c__USE_POSIX_IMPLICITLY: u32 = 1;
pub const c_POSIX_SOURCE: u32 = 1;
pub const c_POSIX_C_SOURCE: u32 = 200809;
pub const c__USE_POSIX: u32 = 1;
pub const c__USE_POSIX2: u32 = 1;
pub const c__USE_POSIX199309: u32 = 1;
pub const c__USE_POSIX199506: u32 = 1;
pub const c__USE_XOPEN2K: u32 = 1;
pub const c__USE_XOPEN2K8: u32 = 1;
pub const c_ATFILE_SOURCE: u32 = 1;
pub const c__WORDSIZE: u32 = 64;
pub const c__WORDSIZE_TIME64_COMPAT32: u32 = 1;
pub const c__SYSCALL_WORDSIZE: u32 = 64;
pub const c__TIMESIZE: u32 = 64;
pub const c__USE_MISC: u32 = 1;
pub const c__USE_ATFILE: u32 = 1;
pub const c__USE_FORTIFY_LEVEL: u32 = 0;
pub const c__GLIBC_USE_DEPRECATED_GETS: u32 = 0;
pub const c__GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
pub const c_STDC_PREDEF_H: u32 = 1;
pub const c__STDC_IEC_559__: u32 = 1;
pub const c__STDC_IEC_60559_BFP__: u32 = 201404;
pub const c__STDC_IEC_559_COMPLEX__: u32 = 1;
pub const c__STDC_IEC_60559_COMPLEX__: u32 = 201404;
pub const c__STDC_ISO_10646__: u32 = 201706;
pub const c__GNU_LIBRARY__: u32 = 6;
pub const c__GLIBC__: u32 = 2;
pub const c__GLIBC_MINOR__: u32 = 36;
pub const c_SYS_CDEFS_H: u32 = 1;
pub const c__glibc_c99_flexarr_available: u32 = 1;
pub const c__LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
pub const c__HAVE_GENERIC_SELECTION: u32 = 1;
pub const c__GLIBC_USE_LIB_EXT2: u32 = 0;
pub const c__GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
pub const c__GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
pub const c__GLIBC_USE_IEC_60559_EXT: u32 = 0;
pub const c__GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
pub const c__GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
pub const c__GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
pub const c_STDLIB_H: u32 = 1;
pub const cWNOHANG: u32 = 1;
pub const cWUNTRACED: u32 = 2;
pub const cWSTOPPED: u32 = 2;
pub const cWEXITED: u32 = 4;
pub const cWCONTINUED: u32 = 8;
pub const cWNOWAIT: u32 = 16777216;
pub const c__WNOTHREAD: u32 = 536870912;
pub const c__WALL: u32 = 1073741824;
pub const c__WCLONE: u32 = 2147483648;
pub const c__W_CONTINUED: u32 = 65535;
pub const c__WCOREFLAG: u32 = 128;
pub const c__HAVE_FLOAT128: u32 = 0;
pub const c__HAVE_DISTINCT_FLOAT128: u32 = 0;
pub const c__HAVE_FLOAT64X: u32 = 1;
pub const c__HAVE_FLOAT64X_LONG_DOUBLE: u32 = 1;
pub const c__HAVE_FLOAT16: u32 = 0;
pub const c__HAVE_FLOAT32: u32 = 1;
pub const c__HAVE_FLOAT64: u32 = 1;
pub const c__HAVE_FLOAT32X: u32 = 1;
pub const c__HAVE_FLOAT128X: u32 = 0;
pub const c__HAVE_DISTINCT_FLOAT16: u32 = 0;
pub const c__HAVE_DISTINCT_FLOAT32: u32 = 0;
pub const c__HAVE_DISTINCT_FLOAT64: u32 = 0;
pub const c__HAVE_DISTINCT_FLOAT32X: u32 = 0;
pub const c__HAVE_DISTINCT_FLOAT64X: u32 = 0;
pub const c__HAVE_DISTINCT_FLOAT128X: u32 = 0;
pub const c__HAVE_FLOATN_NOT_TYPEDEF: u32 = 0;
pub const c__ldiv_t_defined: u32 = 1;
pub const c__lldiv_t_defined: u32 = 1;
pub const cRAND_MAX: u32 = 2147483647;
pub const cEXIT_FAILURE: u32 = 1;
pub const cEXIT_SUCCESS: u32 = 0;
pub const c_SYS_TYPES_H: u32 = 1;
pub const c_BITS_TYPES_H: u32 = 1;
pub const c_BITS_TYPESIZES_H: u32 = 1;
pub const c__OFF_T_MATCHES_OFF64_T: u32 = 1;
pub const c__INO_T_MATCHES_INO64_T: u32 = 1;
pub const c__RLIM_T_MATCHES_RLIM64_T: u32 = 1;
pub const c__STATFS_MATCHES_STATFS64: u32 = 1;
pub const c__KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
pub const c__FD_SETSIZE: u32 = 1024;
pub const c_BITS_TIME64_H: u32 = 1;
pub const c__clock_t_defined: u32 = 1;
pub const c__clockid_t_defined: u32 = 1;
pub const c__time_t_defined: u32 = 1;
pub const c__timer_t_defined: u32 = 1;
pub const c_BITS_STDINT_INTN_H: u32 = 1;
pub const c__BIT_TYPES_DEFINED__: u32 = 1;
pub const c_ENDIAN_H: u32 = 1;
pub const c_BITS_ENDIAN_H: u32 = 1;
pub const c__LITTLE_ENDIAN: u32 = 1234;
pub const c__BIG_ENDIAN: u32 = 4321;
pub const c__PDP_ENDIAN: u32 = 3412;
pub const c_BITS_ENDIANNESS_H: u32 = 1;
pub const c__BYTE_ORDER: u32 = 1234;
pub const c__FLOAT_WORD_ORDER: u32 = 1234;
pub const cLITTLE_ENDIAN: u32 = 1234;
pub const cBIG_ENDIAN: u32 = 4321;
pub const cPDP_ENDIAN: u32 = 3412;
pub const cBYTE_ORDER: u32 = 1234;
pub const c_BITS_BYTESWAP_H: u32 = 1;
pub const c_BITS_UINTN_IDENTITY_H: u32 = 1;
pub const c_SYS_SELECT_H: u32 = 1;
pub const c__sigset_t_defined: u32 = 1;
pub const c__timeval_defined: u32 = 1;
pub const c_STRUCT_TIMESPEC: u32 = 1;
pub const cFD_SETSIZE: u32 = 1024;
pub const c_BITS_PTHREADTYPES_COMMON_H: u32 = 1;
pub const c_THREAD_SHARED_TYPES_H: u32 = 1;
pub const c_BITS_PTHREADTYPES_ARCH_H: u32 = 1;
pub const c__SIZEOF_PTHREAD_MUTEX_T: u32 = 40;
pub const c__SIZEOF_PTHREAD_ATTR_T: u32 = 56;
pub const c__SIZEOF_PTHREAD_RWLOCK_T: u32 = 56;
pub const c__SIZEOF_PTHREAD_BARRIER_T: u32 = 32;
pub const c__SIZEOF_PTHREAD_MUTEXATTR_T: u32 = 4;
pub const c__SIZEOF_PTHREAD_COND_T: u32 = 48;
pub const c__SIZEOF_PTHREAD_CONDATTR_T: u32 = 4;
pub const c__SIZEOF_PTHREAD_RWLOCKATTR_T: u32 = 8;
pub const c__SIZEOF_PTHREAD_BARRIERATTR_T: u32 = 4;
pub const c_THREAD_MUTEX_INTERNAL_H: u32 = 1;
pub const c__PTHREAD_MUTEX_HAVE_PREV: u32 = 1;
pub const c__have_pthread_attr_t: u32 = 1;
pub const c_ALLOCA_H: u32 = 1;
pub const c_STRING_H: u32 = 1;
pub const c_BITS_TYPES_LOCALE_T_H: u32 = 1;
pub const c_BITS_TYPES___LOCALE_T_H: u32 = 1;
pub const c_STRINGS_H: u32 = 1;
pub const cBW_ERR_CODE_SUCCESS: u32 = 0;
pub const c_STDINT_H: u32 = 1;
pub const c_BITS_WCHAR_H: u32 = 1;
pub const c_BITS_STDINT_UINTN_H: u32 = 1;
pub const cINT8_MIN: i32 = -128;
pub const cINT16_MIN: i32 = -32768;
pub const cINT32_MIN: i32 = -2147483648;
pub const cINT8_MAX: u32 = 127;
pub const cINT16_MAX: u32 = 32767;
pub const cINT32_MAX: u32 = 2147483647;
pub const cUINT8_MAX: u32 = 255;
pub const cUINT16_MAX: u32 = 65535;
pub const cUINT32_MAX: u32 = 4294967295;
pub const cINT_LEAST8_MIN: i32 = -128;
pub const cINT_LEAST16_MIN: i32 = -32768;
pub const cINT_LEAST32_MIN: i32 = -2147483648;
pub const cINT_LEAST8_MAX: u32 = 127;
pub const cINT_LEAST16_MAX: u32 = 32767;
pub const cINT_LEAST32_MAX: u32 = 2147483647;
pub const cUINT_LEAST8_MAX: u32 = 255;
pub const cUINT_LEAST16_MAX: u32 = 65535;
pub const cUINT_LEAST32_MAX: u32 = 4294967295;
pub const cINT_FAST8_MIN: i32 = -128;
pub const cINT_FAST16_MIN: i64 = -9223372036854775808;
pub const cINT_FAST32_MIN: i64 = -9223372036854775808;
pub const cINT_FAST8_MAX: u32 = 127;
pub const cINT_FAST16_MAX: u64 = 9223372036854775807;
pub const cINT_FAST32_MAX: u64 = 9223372036854775807;
pub const cUINT_FAST8_MAX: u32 = 255;
pub const cUINT_FAST16_MAX: i32 = -1;
pub const cUINT_FAST32_MAX: i32 = -1;
pub const cINTPTR_MIN: i64 = -9223372036854775808;
pub const cINTPTR_MAX: u64 = 9223372036854775807;
pub const cUINTPTR_MAX: i32 = -1;
pub const cPTRDIFF_MIN: i64 = -9223372036854775808;
pub const cPTRDIFF_MAX: u64 = 9223372036854775807;
pub const cSIG_ATOMIC_MIN: i32 = -2147483648;
pub const cSIG_ATOMIC_MAX: u32 = 2147483647;
pub const cSIZE_MAX: i32 = -1;
pub const cWINT_MIN: u32 = 0;
pub const cWINT_MAX: u32 = 4294967295;
pub const c_ASSERT_H: u32 = 1;
pub const c_STDIO_H: u32 = 1;
pub const c__GNUC_VA_LIST: u32 = 1;
pub const c_____fpos_t_defined: u32 = 1;
pub const c____mbstate_t_defined: u32 = 1;
pub const c_____fpos64_t_defined: u32 = 1;
pub const c____FILE_defined: u32 = 1;
pub const c__FILE_defined: u32 = 1;
pub const c__struct_FILE_defined: u32 = 1;
pub const c_IO_EOF_SEEN: u32 = 16;
pub const c_IO_ERR_SEEN: u32 = 32;
pub const c_IO_USER_LOCK: u32 = 32768;
pub const c_IOFBF: u32 = 0;
pub const c_IOLBF: u32 = 1;
pub const c_IONBF: u32 = 2;
pub const cBUFSIZ: u32 = 8192;
pub const cEOF: i32 = -1;
pub const cSEEK_SET: u32 = 0;
pub const cSEEK_CUR: u32 = 1;
pub const cSEEK_END: u32 = 2;
pub const cP_tmpdir: &[u8; 5] = b"/tmp\0";
pub const c_BITS_STDIO_LIM_H: u32 = 1;
pub const cL_tmpnam: u32 = 20;
pub const cTMP_MAX: u32 = 238328;
pub const cFILENAME_MAX: u32 = 4096;
pub const cL_ctermid: u32 = 9;
pub const cFOPEN_MAX: u32 = 16;
pub const ctrue: u32 = 1;
pub const cfalse: u32 = 0;
pub const c__bool_true_false_are_defined: u32 = 1;
pub type cBOOL = ::std::os::raw::c_int;
pub type cwchar_t = ::std::os::raw::c_int;
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct cmax_align_t {
pub __clang_max_align_nonce1: ::std::os::raw::c_longlong,
pub __bindgen_padding_0: u64,
pub __clang_max_align_nonce2: u128,
}
#[test]
fn bindgen_test_layout_cmax_align_t() {
const UNINIT: ::std::mem::MaybeUninit<cmax_align_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cmax_align_t>(),
32usize,
concat!("Size of: ", stringify!(cmax_align_t))
);
assert_eq!(
::std::mem::align_of::<cmax_align_t>(),
16usize,
concat!("Alignment of ", stringify!(cmax_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!(cmax_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!(cmax_align_t),
"::",
stringify!(__clang_max_align_nonce2)
)
);
}
#[doc = " A 'string slice'\n Points to a mutable, non-zero-terminated, UTF-8 encoded string.\n Using rust's string's memory layout."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_StrSlice {
pub len: usize,
pub data: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_cbw_StrSlice() {
const UNINIT: ::std::mem::MaybeUninit<cbw_StrSlice> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_StrSlice>(),
16usize,
concat!("Size of: ", stringify!(cbw_StrSlice))
);
assert_eq!(
::std::mem::align_of::<cbw_StrSlice>(),
8usize,
concat!("Alignment of ", stringify!(cbw_StrSlice))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_StrSlice),
"::",
stringify!(len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(cbw_StrSlice),
"::",
stringify!(data)
)
);
}
#[doc = " A 'const string slice'\n Points to a immutable, non-zero-terminated, UTF-8 encoded string.\n Using rust's string's memory layout."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_CStrSlice {
pub len: usize,
pub data: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_cbw_CStrSlice() {
const UNINIT: ::std::mem::MaybeUninit<cbw_CStrSlice> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_CStrSlice>(),
16usize,
concat!("Size of: ", stringify!(cbw_CStrSlice))
);
assert_eq!(
::std::mem::align_of::<cbw_CStrSlice>(),
8usize,
concat!("Alignment of ", stringify!(cbw_CStrSlice))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_CStrSlice),
"::",
stringify!(len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(cbw_CStrSlice),
"::",
stringify!(data)
)
);
}
extern "C" {
#[doc = " Copies the string from the given `bw_CStrSlice` to a C compatible, nul-terminated string."]
#[link_name = "\u{1}bw_string_copyAsNewCstr"]
pub fn cbw_string_copyAsNewCstr(str_: cbw_CStrSlice) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[doc = " Frees the string allocated with any of the functions of this module."]
#[link_name = "\u{1}bw_string_freeCstr"]
pub fn cbw_string_freeCstr(str_: *mut ::std::os::raw::c_char);
}
extern "C" {
#[link_name = "\u{1}bw_string_free"]
pub fn cbw_string_free(str_: cbw_StrSlice);
}
extern "C" {
#[link_name = "\u{1}bw_string_freeC"]
pub fn cbw_string_freeC(str_: cbw_CStrSlice);
}
pub type cbw_ApplicationDispatchFn = ::std::option::Option<
unsafe extern "C" fn(app: *mut cbw_Application, data: *mut ::std::os::raw::c_void),
>;
pub type cbw_ApplicationReadyFn = cbw_ApplicationDispatchFn;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_ApplicationImpl {}
#[test]
fn bindgen_test_layout_cbw_ApplicationImpl() {
assert_eq!(
::std::mem::size_of::<cbw_ApplicationImpl>(),
0usize,
concat!("Size of: ", stringify!(cbw_ApplicationImpl))
);
assert_eq!(
::std::mem::align_of::<cbw_ApplicationImpl>(),
1usize,
concat!("Alignment of ", stringify!(cbw_ApplicationImpl))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_ApplicationEngineImpl {}
#[test]
fn bindgen_test_layout_cbw_ApplicationEngineImpl() {
assert_eq!(
::std::mem::size_of::<cbw_ApplicationEngineImpl>(),
0usize,
concat!("Size of: ", stringify!(cbw_ApplicationEngineImpl))
);
assert_eq!(
::std::mem::align_of::<cbw_ApplicationEngineImpl>(),
1usize,
concat!("Alignment of ", stringify!(cbw_ApplicationEngineImpl))
);
}
pub type c_Float32 = f32;
pub type c_Float64 = f64;
pub type c_Float32x = f64;
pub type c_Float64x = u128;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cdiv_t {
pub quot: ::std::os::raw::c_int,
pub rem: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_cdiv_t() {
const UNINIT: ::std::mem::MaybeUninit<cdiv_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cdiv_t>(),
8usize,
concat!("Size of: ", stringify!(cdiv_t))
);
assert_eq!(
::std::mem::align_of::<cdiv_t>(),
4usize,
concat!("Alignment of ", stringify!(cdiv_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cdiv_t),
"::",
stringify!(quot)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(cdiv_t),
"::",
stringify!(rem)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cldiv_t {
pub quot: ::std::os::raw::c_long,
pub rem: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_cldiv_t() {
const UNINIT: ::std::mem::MaybeUninit<cldiv_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cldiv_t>(),
16usize,
concat!("Size of: ", stringify!(cldiv_t))
);
assert_eq!(
::std::mem::align_of::<cldiv_t>(),
8usize,
concat!("Alignment of ", stringify!(cldiv_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cldiv_t),
"::",
stringify!(quot)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(cldiv_t),
"::",
stringify!(rem)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct clldiv_t {
pub quot: ::std::os::raw::c_longlong,
pub rem: ::std::os::raw::c_longlong,
}
#[test]
fn bindgen_test_layout_clldiv_t() {
const UNINIT: ::std::mem::MaybeUninit<clldiv_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<clldiv_t>(),
16usize,
concat!("Size of: ", stringify!(clldiv_t))
);
assert_eq!(
::std::mem::align_of::<clldiv_t>(),
8usize,
concat!("Alignment of ", stringify!(clldiv_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(clldiv_t),
"::",
stringify!(quot)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(clldiv_t),
"::",
stringify!(rem)
)
);
}
extern "C" {
#[link_name = "\u{1}__ctype_get_mb_cur_max"]
pub fn c__ctype_get_mb_cur_max() -> usize;
}
extern "C" {
#[link_name = "\u{1}atof"]
pub fn catof(__nptr: *const ::std::os::raw::c_char) -> f64;
}
extern "C" {
#[link_name = "\u{1}atoi"]
pub fn catoi(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}atol"]
pub fn catol(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
}
extern "C" {
#[link_name = "\u{1}atoll"]
pub fn catoll(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_longlong;
}
extern "C" {
#[link_name = "\u{1}strtod"]
pub fn cstrtod(
__nptr: *const ::std::os::raw::c_char, __endptr: *mut *mut ::std::os::raw::c_char,
) -> f64;
}
extern "C" {
#[link_name = "\u{1}strtof"]
pub fn cstrtof(
__nptr: *const ::std::os::raw::c_char, __endptr: *mut *mut ::std::os::raw::c_char,
) -> f32;
}
extern "C" {
#[link_name = "\u{1}strtold"]
pub fn cstrtold(
__nptr: *const ::std::os::raw::c_char, __endptr: *mut *mut ::std::os::raw::c_char,
) -> u128;
}
extern "C" {
#[link_name = "\u{1}strtol"]
pub fn cstrtol(
__nptr: *const ::std::os::raw::c_char, __endptr: *mut *mut ::std::os::raw::c_char,
__base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_long;
}
extern "C" {
#[link_name = "\u{1}strtoul"]
pub fn cstrtoul(
__nptr: *const ::std::os::raw::c_char, __endptr: *mut *mut ::std::os::raw::c_char,
__base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
#[link_name = "\u{1}strtoq"]
pub fn cstrtoq(
__nptr: *const ::std::os::raw::c_char, __endptr: *mut *mut ::std::os::raw::c_char,
__base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
#[link_name = "\u{1}strtouq"]
pub fn cstrtouq(
__nptr: *const ::std::os::raw::c_char, __endptr: *mut *mut ::std::os::raw::c_char,
__base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
#[link_name = "\u{1}strtoll"]
pub fn cstrtoll(
__nptr: *const ::std::os::raw::c_char, __endptr: *mut *mut ::std::os::raw::c_char,
__base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
#[link_name = "\u{1}strtoull"]
pub fn cstrtoull(
__nptr: *const ::std::os::raw::c_char, __endptr: *mut *mut ::std::os::raw::c_char,
__base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
#[link_name = "\u{1}l64a"]
pub fn cl64a(__n: ::std::os::raw::c_long) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}a64l"]
pub fn ca64l(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
}
pub type c__u_char = ::std::os::raw::c_uchar;
pub type c__u_short = ::std::os::raw::c_ushort;
pub type c__u_int = ::std::os::raw::c_uint;
pub type c__u_long = ::std::os::raw::c_ulong;
pub type c__int8_t = ::std::os::raw::c_schar;
pub type c__uint8_t = ::std::os::raw::c_uchar;
pub type c__int16_t = ::std::os::raw::c_short;
pub type c__uint16_t = ::std::os::raw::c_ushort;
pub type c__int32_t = ::std::os::raw::c_int;
pub type c__uint32_t = ::std::os::raw::c_uint;
pub type c__int64_t = ::std::os::raw::c_long;
pub type c__uint64_t = ::std::os::raw::c_ulong;
pub type c__int_least8_t = c__int8_t;
pub type c__uint_least8_t = c__uint8_t;
pub type c__int_least16_t = c__int16_t;
pub type c__uint_least16_t = c__uint16_t;
pub type c__int_least32_t = c__int32_t;
pub type c__uint_least32_t = c__uint32_t;
pub type c__int_least64_t = c__int64_t;
pub type c__uint_least64_t = c__uint64_t;
pub type c__quad_t = ::std::os::raw::c_long;
pub type c__u_quad_t = ::std::os::raw::c_ulong;
pub type c__intmax_t = ::std::os::raw::c_long;
pub type c__uintmax_t = ::std::os::raw::c_ulong;
pub type c__dev_t = ::std::os::raw::c_ulong;
pub type c__uid_t = ::std::os::raw::c_uint;
pub type c__gid_t = ::std::os::raw::c_uint;
pub type c__ino_t = ::std::os::raw::c_ulong;
pub type c__ino64_t = ::std::os::raw::c_ulong;
pub type c__mode_t = ::std::os::raw::c_uint;
pub type c__nlink_t = ::std::os::raw::c_ulong;
pub type c__off_t = ::std::os::raw::c_long;
pub type c__off64_t = ::std::os::raw::c_long;
pub type c__pid_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct c__fsid_t {
pub __val: [::std::os::raw::c_int; 2usize],
}
#[test]
fn bindgen_test_layout_c__fsid_t() {
const UNINIT: ::std::mem::MaybeUninit<c__fsid_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<c__fsid_t>(),
8usize,
concat!("Size of: ", stringify!(c__fsid_t))
);
assert_eq!(
::std::mem::align_of::<c__fsid_t>(),
4usize,
concat!("Alignment of ", stringify!(c__fsid_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c__fsid_t),
"::",
stringify!(__val)
)
);
}
pub type c__clock_t = ::std::os::raw::c_long;
pub type c__rlim_t = ::std::os::raw::c_ulong;
pub type c__rlim64_t = ::std::os::raw::c_ulong;
pub type c__id_t = ::std::os::raw::c_uint;
pub type c__time_t = ::std::os::raw::c_long;
pub type c__useconds_t = ::std::os::raw::c_uint;
pub type c__suseconds_t = ::std::os::raw::c_long;
pub type c__suseconds64_t = ::std::os::raw::c_long;
pub type c__daddr_t = ::std::os::raw::c_int;
pub type c__key_t = ::std::os::raw::c_int;
pub type c__clockid_t = ::std::os::raw::c_int;
pub type c__timer_t = *mut ::std::os::raw::c_void;
pub type c__blksize_t = ::std::os::raw::c_long;
pub type c__blkcnt_t = ::std::os::raw::c_long;
pub type c__blkcnt64_t = ::std::os::raw::c_long;
pub type c__fsblkcnt_t = ::std::os::raw::c_ulong;
pub type c__fsblkcnt64_t = ::std::os::raw::c_ulong;
pub type c__fsfilcnt_t = ::std::os::raw::c_ulong;
pub type c__fsfilcnt64_t = ::std::os::raw::c_ulong;
pub type c__fsword_t = ::std::os::raw::c_long;
pub type c__ssize_t = ::std::os::raw::c_long;
pub type c__syscall_slong_t = ::std::os::raw::c_long;
pub type c__syscall_ulong_t = ::std::os::raw::c_ulong;
pub type c__loff_t = c__off64_t;
pub type c__caddr_t = *mut ::std::os::raw::c_char;
pub type c__intptr_t = ::std::os::raw::c_long;
pub type c__socklen_t = ::std::os::raw::c_uint;
pub type c__sig_atomic_t = ::std::os::raw::c_int;
pub type cu_char = c__u_char;
pub type cu_short = c__u_short;
pub type cu_int = c__u_int;
pub type cu_long = c__u_long;
pub type cquad_t = c__quad_t;
pub type cu_quad_t = c__u_quad_t;
pub type cfsid_t = c__fsid_t;
pub type cloff_t = c__loff_t;
pub type cino_t = c__ino_t;
pub type cdev_t = c__dev_t;
pub type cgid_t = c__gid_t;
pub type cmode_t = c__mode_t;
pub type cnlink_t = c__nlink_t;
pub type cuid_t = c__uid_t;
pub type coff_t = c__off_t;
pub type cpid_t = c__pid_t;
pub type cid_t = c__id_t;
pub type cdaddr_t = c__daddr_t;
pub type ccaddr_t = c__caddr_t;
pub type ckey_t = c__key_t;
pub type cclock_t = c__clock_t;
pub type cclockid_t = c__clockid_t;
pub type ctime_t = c__time_t;
pub type ctimer_t = c__timer_t;
pub type culong = ::std::os::raw::c_ulong;
pub type cushort = ::std::os::raw::c_ushort;
pub type cuint = ::std::os::raw::c_uint;
pub type cu_int8_t = c__uint8_t;
pub type cu_int16_t = c__uint16_t;
pub type cu_int32_t = c__uint32_t;
pub type cu_int64_t = c__uint64_t;
pub type cregister_t = ::std::os::raw::c_long;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct c__sigset_t {
pub __val: [::std::os::raw::c_ulong; 16usize],
}
#[test]
fn bindgen_test_layout_c__sigset_t() {
const UNINIT: ::std::mem::MaybeUninit<c__sigset_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<c__sigset_t>(),
128usize,
concat!("Size of: ", stringify!(c__sigset_t))
);
assert_eq!(
::std::mem::align_of::<c__sigset_t>(),
8usize,
concat!("Alignment of ", stringify!(c__sigset_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c__sigset_t),
"::",
stringify!(__val)
)
);
}
pub type csigset_t = c__sigset_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ctimeval {
pub tv_sec: c__time_t,
pub tv_usec: c__suseconds_t,
}
#[test]
fn bindgen_test_layout_ctimeval() {
const UNINIT: ::std::mem::MaybeUninit<ctimeval> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ctimeval>(),
16usize,
concat!("Size of: ", stringify!(ctimeval))
);
assert_eq!(
::std::mem::align_of::<ctimeval>(),
8usize,
concat!("Alignment of ", stringify!(ctimeval))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ctimeval),
"::",
stringify!(tv_sec)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_usec) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ctimeval),
"::",
stringify!(tv_usec)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ctimespec {
pub tv_sec: c__time_t,
pub tv_nsec: c__syscall_slong_t,
}
#[test]
fn bindgen_test_layout_ctimespec() {
const UNINIT: ::std::mem::MaybeUninit<ctimespec> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ctimespec>(),
16usize,
concat!("Size of: ", stringify!(ctimespec))
);
assert_eq!(
::std::mem::align_of::<ctimespec>(),
8usize,
concat!("Alignment of ", stringify!(ctimespec))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ctimespec),
"::",
stringify!(tv_sec)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ctimespec),
"::",
stringify!(tv_nsec)
)
);
}
pub type csuseconds_t = c__suseconds_t;
pub type c__fd_mask = ::std::os::raw::c_long;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cfd_set {
pub __fds_bits: [c__fd_mask; 16usize],
}
#[test]
fn bindgen_test_layout_cfd_set() {
const UNINIT: ::std::mem::MaybeUninit<cfd_set> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cfd_set>(),
128usize,
concat!("Size of: ", stringify!(cfd_set))
);
assert_eq!(
::std::mem::align_of::<cfd_set>(),
8usize,
concat!("Alignment of ", stringify!(cfd_set))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__fds_bits) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cfd_set),
"::",
stringify!(__fds_bits)
)
);
}
pub type cfd_mask = c__fd_mask;
extern "C" {
#[link_name = "\u{1}select"]
pub fn cselect(
__nfds: ::std::os::raw::c_int, __readfds: *mut cfd_set, __writefds: *mut cfd_set,
__exceptfds: *mut cfd_set, __timeout: *mut ctimeval,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}pselect"]
pub fn cpselect(
__nfds: ::std::os::raw::c_int, __readfds: *mut cfd_set, __writefds: *mut cfd_set,
__exceptfds: *mut cfd_set, __timeout: *const ctimespec, __sigmask: *const c__sigset_t,
) -> ::std::os::raw::c_int;
}
pub type cblksize_t = c__blksize_t;
pub type cblkcnt_t = c__blkcnt_t;
pub type cfsblkcnt_t = c__fsblkcnt_t;
pub type cfsfilcnt_t = c__fsfilcnt_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub union c__atomic_wide_counter {
pub __value64: ::std::os::raw::c_ulonglong,
pub __value32: c__atomic_wide_counter__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct c__atomic_wide_counter__bindgen_ty_1 {
pub __low: ::std::os::raw::c_uint,
pub __high: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_c__atomic_wide_counter__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<c__atomic_wide_counter__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<c__atomic_wide_counter__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(c__atomic_wide_counter__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<c__atomic_wide_counter__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(c__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!(c__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!(c__atomic_wide_counter__bindgen_ty_1),
"::",
stringify!(__high)
)
);
}
#[test]
fn bindgen_test_layout_c__atomic_wide_counter() {
const UNINIT: ::std::mem::MaybeUninit<c__atomic_wide_counter> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<c__atomic_wide_counter>(),
8usize,
concat!("Size of: ", stringify!(c__atomic_wide_counter))
);
assert_eq!(
::std::mem::align_of::<c__atomic_wide_counter>(),
8usize,
concat!("Alignment of ", stringify!(c__atomic_wide_counter))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__value64) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c__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!(c__atomic_wide_counter),
"::",
stringify!(__value32)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct c__pthread_internal_list {
pub __prev: *mut c__pthread_internal_list,
pub __next: *mut c__pthread_internal_list,
}
#[test]
fn bindgen_test_layout_c__pthread_internal_list() {
const UNINIT: ::std::mem::MaybeUninit<c__pthread_internal_list> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<c__pthread_internal_list>(),
16usize,
concat!("Size of: ", stringify!(c__pthread_internal_list))
);
assert_eq!(
::std::mem::align_of::<c__pthread_internal_list>(),
8usize,
concat!("Alignment of ", stringify!(c__pthread_internal_list))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__prev) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c__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!(c__pthread_internal_list),
"::",
stringify!(__next)
)
);
}
pub type c__pthread_list_t = c__pthread_internal_list;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct c__pthread_internal_slist {
pub __next: *mut c__pthread_internal_slist,
}
#[test]
fn bindgen_test_layout_c__pthread_internal_slist() {
const UNINIT: ::std::mem::MaybeUninit<c__pthread_internal_slist> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<c__pthread_internal_slist>(),
8usize,
concat!("Size of: ", stringify!(c__pthread_internal_slist))
);
assert_eq!(
::std::mem::align_of::<c__pthread_internal_slist>(),
8usize,
concat!("Alignment of ", stringify!(c__pthread_internal_slist))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_internal_slist),
"::",
stringify!(__next)
)
);
}
pub type c__pthread_slist_t = c__pthread_internal_slist;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct c__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: c__pthread_list_t,
}
#[test]
fn bindgen_test_layout_c__pthread_mutex_s() {
const UNINIT: ::std::mem::MaybeUninit<c__pthread_mutex_s> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<c__pthread_mutex_s>(),
40usize,
concat!("Size of: ", stringify!(c__pthread_mutex_s))
);
assert_eq!(
::std::mem::align_of::<c__pthread_mutex_s>(),
8usize,
concat!("Alignment of ", stringify!(c__pthread_mutex_s))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__lock) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c__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!(c__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!(c__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!(c__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!(c__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!(c__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!(c__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!(c__pthread_mutex_s),
"::",
stringify!(__list)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct c__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_c__pthread_rwlock_arch_t() {
const UNINIT: ::std::mem::MaybeUninit<c__pthread_rwlock_arch_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<c__pthread_rwlock_arch_t>(),
56usize,
concat!("Size of: ", stringify!(c__pthread_rwlock_arch_t))
);
assert_eq!(
::std::mem::align_of::<c__pthread_rwlock_arch_t>(),
8usize,
concat!("Alignment of ", stringify!(c__pthread_rwlock_arch_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__readers) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c__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!(c__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!(c__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!(c__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!(c__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!(c__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!(c__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!(c__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!(c__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!(c__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!(c__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!(c__pthread_rwlock_arch_t),
"::",
stringify!(__flags)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct c__pthread_cond_s {
pub __wseq: c__atomic_wide_counter,
pub __g1_start: c__atomic_wide_counter,
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],
}
#[test]
fn bindgen_test_layout_c__pthread_cond_s() {
const UNINIT: ::std::mem::MaybeUninit<c__pthread_cond_s> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<c__pthread_cond_s>(),
48usize,
concat!("Size of: ", stringify!(c__pthread_cond_s))
);
assert_eq!(
::std::mem::align_of::<c__pthread_cond_s>(),
8usize,
concat!("Alignment of ", stringify!(c__pthread_cond_s))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__wseq) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c__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!(c__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!(c__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!(c__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!(c__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!(c__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!(c__pthread_cond_s),
"::",
stringify!(__g_signals)
)
);
}
pub type c__tss_t = ::std::os::raw::c_uint;
pub type c__thrd_t = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct c__once_flag {
pub __data: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_c__once_flag() {
const UNINIT: ::std::mem::MaybeUninit<c__once_flag> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<c__once_flag>(),
4usize,
concat!("Size of: ", stringify!(c__once_flag))
);
assert_eq!(
::std::mem::align_of::<c__once_flag>(),
4usize,
concat!("Alignment of ", stringify!(c__once_flag))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c__once_flag),
"::",
stringify!(__data)
)
);
}
pub type cpthread_t = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Copy, Clone)]
pub union cpthread_mutexattr_t {
pub __size: [::std::os::raw::c_char; 4usize],
pub __align: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_cpthread_mutexattr_t() {
const UNINIT: ::std::mem::MaybeUninit<cpthread_mutexattr_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cpthread_mutexattr_t>(),
4usize,
concat!("Size of: ", stringify!(cpthread_mutexattr_t))
);
assert_eq!(
::std::mem::align_of::<cpthread_mutexattr_t>(),
4usize,
concat!("Alignment of ", stringify!(cpthread_mutexattr_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_mutexattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_mutexattr_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union cpthread_condattr_t {
pub __size: [::std::os::raw::c_char; 4usize],
pub __align: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_cpthread_condattr_t() {
const UNINIT: ::std::mem::MaybeUninit<cpthread_condattr_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cpthread_condattr_t>(),
4usize,
concat!("Size of: ", stringify!(cpthread_condattr_t))
);
assert_eq!(
::std::mem::align_of::<cpthread_condattr_t>(),
4usize,
concat!("Alignment of ", stringify!(cpthread_condattr_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_condattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_condattr_t),
"::",
stringify!(__align)
)
);
}
pub type cpthread_key_t = ::std::os::raw::c_uint;
pub type cpthread_once_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub union cpthread_attr_t {
pub __size: [::std::os::raw::c_char; 56usize],
pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_cpthread_attr_t() {
const UNINIT: ::std::mem::MaybeUninit<cpthread_attr_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cpthread_attr_t>(),
56usize,
concat!("Size of: ", stringify!(cpthread_attr_t))
);
assert_eq!(
::std::mem::align_of::<cpthread_attr_t>(),
8usize,
concat!("Alignment of ", stringify!(cpthread_attr_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_attr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_attr_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union cpthread_mutex_t {
pub __data: c__pthread_mutex_s,
pub __size: [::std::os::raw::c_char; 40usize],
pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_cpthread_mutex_t() {
const UNINIT: ::std::mem::MaybeUninit<cpthread_mutex_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cpthread_mutex_t>(),
40usize,
concat!("Size of: ", stringify!(cpthread_mutex_t))
);
assert_eq!(
::std::mem::align_of::<cpthread_mutex_t>(),
8usize,
concat!("Alignment of ", stringify!(cpthread_mutex_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_mutex_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_mutex_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_mutex_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union cpthread_cond_t {
pub __data: c__pthread_cond_s,
pub __size: [::std::os::raw::c_char; 48usize],
pub __align: ::std::os::raw::c_longlong,
}
#[test]
fn bindgen_test_layout_cpthread_cond_t() {
const UNINIT: ::std::mem::MaybeUninit<cpthread_cond_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cpthread_cond_t>(),
48usize,
concat!("Size of: ", stringify!(cpthread_cond_t))
);
assert_eq!(
::std::mem::align_of::<cpthread_cond_t>(),
8usize,
concat!("Alignment of ", stringify!(cpthread_cond_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_cond_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_cond_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_cond_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union cpthread_rwlock_t {
pub __data: c__pthread_rwlock_arch_t,
pub __size: [::std::os::raw::c_char; 56usize],
pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_cpthread_rwlock_t() {
const UNINIT: ::std::mem::MaybeUninit<cpthread_rwlock_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cpthread_rwlock_t>(),
56usize,
concat!("Size of: ", stringify!(cpthread_rwlock_t))
);
assert_eq!(
::std::mem::align_of::<cpthread_rwlock_t>(),
8usize,
concat!("Alignment of ", stringify!(cpthread_rwlock_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_rwlock_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_rwlock_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_rwlock_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union cpthread_rwlockattr_t {
pub __size: [::std::os::raw::c_char; 8usize],
pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_cpthread_rwlockattr_t() {
const UNINIT: ::std::mem::MaybeUninit<cpthread_rwlockattr_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cpthread_rwlockattr_t>(),
8usize,
concat!("Size of: ", stringify!(cpthread_rwlockattr_t))
);
assert_eq!(
::std::mem::align_of::<cpthread_rwlockattr_t>(),
8usize,
concat!("Alignment of ", stringify!(cpthread_rwlockattr_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_rwlockattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_rwlockattr_t),
"::",
stringify!(__align)
)
);
}
pub type cpthread_spinlock_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub union cpthread_barrier_t {
pub __size: [::std::os::raw::c_char; 32usize],
pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_cpthread_barrier_t() {
const UNINIT: ::std::mem::MaybeUninit<cpthread_barrier_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cpthread_barrier_t>(),
32usize,
concat!("Size of: ", stringify!(cpthread_barrier_t))
);
assert_eq!(
::std::mem::align_of::<cpthread_barrier_t>(),
8usize,
concat!("Alignment of ", stringify!(cpthread_barrier_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_barrier_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_barrier_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union cpthread_barrierattr_t {
pub __size: [::std::os::raw::c_char; 4usize],
pub __align: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_cpthread_barrierattr_t() {
const UNINIT: ::std::mem::MaybeUninit<cpthread_barrierattr_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cpthread_barrierattr_t>(),
4usize,
concat!("Size of: ", stringify!(cpthread_barrierattr_t))
);
assert_eq!(
::std::mem::align_of::<cpthread_barrierattr_t>(),
4usize,
concat!("Alignment of ", stringify!(cpthread_barrierattr_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_barrierattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_barrierattr_t),
"::",
stringify!(__align)
)
);
}
extern "C" {
#[link_name = "\u{1}random"]
pub fn crandom() -> ::std::os::raw::c_long;
}
extern "C" {
#[link_name = "\u{1}srandom"]
pub fn csrandom(__seed: ::std::os::raw::c_uint);
}
extern "C" {
#[link_name = "\u{1}initstate"]
pub fn cinitstate(
__seed: ::std::os::raw::c_uint, __statebuf: *mut ::std::os::raw::c_char, __statelen: usize,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}setstate"]
pub fn csetstate(__statebuf: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct crandom_data {
pub fptr: *mut i32,
pub rptr: *mut i32,
pub state: *mut i32,
pub rand_type: ::std::os::raw::c_int,
pub rand_deg: ::std::os::raw::c_int,
pub rand_sep: ::std::os::raw::c_int,
pub end_ptr: *mut i32,
}
#[test]
fn bindgen_test_layout_crandom_data() {
const UNINIT: ::std::mem::MaybeUninit<crandom_data> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<crandom_data>(),
48usize,
concat!("Size of: ", stringify!(crandom_data))
);
assert_eq!(
::std::mem::align_of::<crandom_data>(),
8usize,
concat!("Alignment of ", stringify!(crandom_data))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fptr) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(crandom_data),
"::",
stringify!(fptr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rptr) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(crandom_data),
"::",
stringify!(rptr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(crandom_data),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rand_type) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(crandom_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!(crandom_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!(crandom_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!(crandom_data),
"::",
stringify!(end_ptr)
)
);
}
extern "C" {
#[link_name = "\u{1}random_r"]
pub fn crandom_r(__buf: *mut crandom_data, __result: *mut i32) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}srandom_r"]
pub fn csrandom_r(
__seed: ::std::os::raw::c_uint, __buf: *mut crandom_data,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}initstate_r"]
pub fn cinitstate_r(
__seed: ::std::os::raw::c_uint, __statebuf: *mut ::std::os::raw::c_char, __statelen: usize,
__buf: *mut crandom_data,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}setstate_r"]
pub fn csetstate_r(
__statebuf: *mut ::std::os::raw::c_char, __buf: *mut crandom_data,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}rand"]
pub fn crand() -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}srand"]
pub fn csrand(__seed: ::std::os::raw::c_uint);
}
extern "C" {
#[link_name = "\u{1}rand_r"]
pub fn crand_r(__seed: *mut ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}drand48"]
pub fn cdrand48() -> f64;
}
extern "C" {
#[link_name = "\u{1}erand48"]
pub fn cerand48(__xsubi: *mut ::std::os::raw::c_ushort) -> f64;
}
extern "C" {
#[link_name = "\u{1}lrand48"]
pub fn clrand48() -> ::std::os::raw::c_long;
}
extern "C" {
#[link_name = "\u{1}nrand48"]
pub fn cnrand48(__xsubi: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
}
extern "C" {
#[link_name = "\u{1}mrand48"]
pub fn cmrand48() -> ::std::os::raw::c_long;
}
extern "C" {
#[link_name = "\u{1}jrand48"]
pub fn cjrand48(__xsubi: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
}
extern "C" {
#[link_name = "\u{1}srand48"]
pub fn csrand48(__seedval: ::std::os::raw::c_long);
}
extern "C" {
#[link_name = "\u{1}seed48"]
pub fn cseed48(__seed16v: *mut ::std::os::raw::c_ushort) -> *mut ::std::os::raw::c_ushort;
}
extern "C" {
#[link_name = "\u{1}lcong48"]
pub fn clcong48(__param: *mut ::std::os::raw::c_ushort);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cdrand48_data {
pub __x: [::std::os::raw::c_ushort; 3usize],
pub __old_x: [::std::os::raw::c_ushort; 3usize],
pub __c: ::std::os::raw::c_ushort,
pub __init: ::std::os::raw::c_ushort,
pub __a: ::std::os::raw::c_ulonglong,
}
#[test]
fn bindgen_test_layout_cdrand48_data() {
const UNINIT: ::std::mem::MaybeUninit<cdrand48_data> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cdrand48_data>(),
24usize,
concat!("Size of: ", stringify!(cdrand48_data))
);
assert_eq!(
::std::mem::align_of::<cdrand48_data>(),
8usize,
concat!("Alignment of ", stringify!(cdrand48_data))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cdrand48_data),
"::",
stringify!(__x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__old_x) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(cdrand48_data),
"::",
stringify!(__old_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__c) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(cdrand48_data),
"::",
stringify!(__c)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__init) as usize - ptr as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(cdrand48_data),
"::",
stringify!(__init)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__a) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(cdrand48_data),
"::",
stringify!(__a)
)
);
}
extern "C" {
#[link_name = "\u{1}drand48_r"]
pub fn cdrand48_r(__buffer: *mut cdrand48_data, __result: *mut f64) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}erand48_r"]
pub fn cerand48_r(
__xsubi: *mut ::std::os::raw::c_ushort, __buffer: *mut cdrand48_data, __result: *mut f64,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}lrand48_r"]
pub fn clrand48_r(
__buffer: *mut cdrand48_data, __result: *mut ::std::os::raw::c_long,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}nrand48_r"]
pub fn cnrand48_r(
__xsubi: *mut ::std::os::raw::c_ushort, __buffer: *mut cdrand48_data,
__result: *mut ::std::os::raw::c_long,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}mrand48_r"]
pub fn cmrand48_r(
__buffer: *mut cdrand48_data, __result: *mut ::std::os::raw::c_long,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}jrand48_r"]
pub fn cjrand48_r(
__xsubi: *mut ::std::os::raw::c_ushort, __buffer: *mut cdrand48_data,
__result: *mut ::std::os::raw::c_long,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}srand48_r"]
pub fn csrand48_r(
__seedval: ::std::os::raw::c_long, __buffer: *mut cdrand48_data,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}seed48_r"]
pub fn cseed48_r(
__seed16v: *mut ::std::os::raw::c_ushort, __buffer: *mut cdrand48_data,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}lcong48_r"]
pub fn clcong48_r(
__param: *mut ::std::os::raw::c_ushort, __buffer: *mut cdrand48_data,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}arc4random"]
pub fn carc4random() -> c__uint32_t;
}
extern "C" {
#[link_name = "\u{1}arc4random_buf"]
pub fn carc4random_buf(__buf: *mut ::std::os::raw::c_void, __size: usize);
}
extern "C" {
#[link_name = "\u{1}arc4random_uniform"]
pub fn carc4random_uniform(__upper_bound: c__uint32_t) -> c__uint32_t;
}
extern "C" {
#[link_name = "\u{1}malloc"]
pub fn cmalloc(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
}
extern "C" {
#[link_name = "\u{1}calloc"]
pub fn ccalloc(
__nmemb: ::std::os::raw::c_ulong, __size: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
#[link_name = "\u{1}realloc"]
pub fn crealloc(
__ptr: *mut ::std::os::raw::c_void, __size: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
#[link_name = "\u{1}free"]
pub fn cfree(__ptr: *mut ::std::os::raw::c_void);
}
extern "C" {
#[link_name = "\u{1}reallocarray"]
pub fn creallocarray(
__ptr: *mut ::std::os::raw::c_void, __nmemb: usize, __size: usize,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
#[link_name = "\u{1}alloca"]
pub fn calloca(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
}
extern "C" {
#[link_name = "\u{1}valloc"]
pub fn cvalloc(__size: usize) -> *mut ::std::os::raw::c_void;
}
extern "C" {
#[link_name = "\u{1}posix_memalign"]
pub fn cposix_memalign(
__memptr: *mut *mut ::std::os::raw::c_void, __alignment: usize, __size: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}aligned_alloc"]
pub fn caligned_alloc(
__alignment: ::std::os::raw::c_ulong, __size: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
#[link_name = "\u{1}abort"]
pub fn cabort() -> !;
}
extern "C" {
#[link_name = "\u{1}atexit"]
pub fn catexit(__func: ::std::option::Option<unsafe extern "C" fn()>) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}at_quick_exit"]
pub fn cat_quick_exit(
__func: ::std::option::Option<unsafe extern "C" fn()>,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}on_exit"]
pub fn con_exit(
__func: ::std::option::Option<
unsafe extern "C" fn(
__status: ::std::os::raw::c_int,
__arg: *mut ::std::os::raw::c_void,
),
>,
__arg: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}exit"]
pub fn cexit(__status: ::std::os::raw::c_int) -> !;
}
extern "C" {
#[link_name = "\u{1}quick_exit"]
pub fn cquick_exit(__status: ::std::os::raw::c_int) -> !;
}
extern "C" {
#[link_name = "\u{1}_Exit"]
pub fn c_Exit(__status: ::std::os::raw::c_int) -> !;
}
extern "C" {
#[link_name = "\u{1}getenv"]
pub fn cgetenv(__name: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}putenv"]
pub fn cputenv(__string: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}setenv"]
pub fn csetenv(
__name: *const ::std::os::raw::c_char, __value: *const ::std::os::raw::c_char,
__replace: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}unsetenv"]
pub fn cunsetenv(__name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}clearenv"]
pub fn cclearenv() -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}mktemp"]
pub fn cmktemp(__template: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}mkstemp"]
pub fn cmkstemp(__template: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}mkstemps"]
pub fn cmkstemps(
__template: *mut ::std::os::raw::c_char, __suffixlen: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}mkdtemp"]
pub fn cmkdtemp(__template: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}system"]
pub fn csystem(__command: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}realpath"]
pub fn crealpath(
__name: *const ::std::os::raw::c_char, __resolved: *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
pub type c__compar_fn_t = ::std::option::Option<
unsafe extern "C" fn(
arg1: *const ::std::os::raw::c_void,
arg2: *const ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
extern "C" {
#[link_name = "\u{1}bsearch"]
pub fn cbsearch(
__key: *const ::std::os::raw::c_void, __base: *const ::std::os::raw::c_void,
__nmemb: usize, __size: usize, __compar: c__compar_fn_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
#[link_name = "\u{1}qsort"]
pub fn cqsort(
__base: *mut ::std::os::raw::c_void, __nmemb: usize, __size: usize,
__compar: c__compar_fn_t,
);
}
extern "C" {
#[link_name = "\u{1}abs"]
pub fn cabs(__x: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}labs"]
pub fn clabs(__x: ::std::os::raw::c_long) -> ::std::os::raw::c_long;
}
extern "C" {
#[link_name = "\u{1}llabs"]
pub fn cllabs(__x: ::std::os::raw::c_longlong) -> ::std::os::raw::c_longlong;
}
extern "C" {
#[link_name = "\u{1}div"]
pub fn cdiv(__numer: ::std::os::raw::c_int, __denom: ::std::os::raw::c_int) -> cdiv_t;
}
extern "C" {
#[link_name = "\u{1}ldiv"]
pub fn cldiv(__numer: ::std::os::raw::c_long, __denom: ::std::os::raw::c_long) -> cldiv_t;
}
extern "C" {
#[link_name = "\u{1}lldiv"]
pub fn clldiv(
__numer: ::std::os::raw::c_longlong, __denom: ::std::os::raw::c_longlong,
) -> clldiv_t;
}
extern "C" {
#[link_name = "\u{1}ecvt"]
pub fn cecvt(
__value: f64, __ndigit: ::std::os::raw::c_int, __decpt: *mut ::std::os::raw::c_int,
__sign: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}fcvt"]
pub fn cfcvt(
__value: f64, __ndigit: ::std::os::raw::c_int, __decpt: *mut ::std::os::raw::c_int,
__sign: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}gcvt"]
pub fn cgcvt(
__value: f64, __ndigit: ::std::os::raw::c_int, __buf: *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}qecvt"]
pub fn cqecvt(
__value: u128, __ndigit: ::std::os::raw::c_int, __decpt: *mut ::std::os::raw::c_int,
__sign: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}qfcvt"]
pub fn cqfcvt(
__value: u128, __ndigit: ::std::os::raw::c_int, __decpt: *mut ::std::os::raw::c_int,
__sign: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}qgcvt"]
pub fn cqgcvt(
__value: u128, __ndigit: ::std::os::raw::c_int, __buf: *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}ecvt_r"]
pub fn cecvt_r(
__value: f64, __ndigit: ::std::os::raw::c_int, __decpt: *mut ::std::os::raw::c_int,
__sign: *mut ::std::os::raw::c_int, __buf: *mut ::std::os::raw::c_char, __len: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}fcvt_r"]
pub fn cfcvt_r(
__value: f64, __ndigit: ::std::os::raw::c_int, __decpt: *mut ::std::os::raw::c_int,
__sign: *mut ::std::os::raw::c_int, __buf: *mut ::std::os::raw::c_char, __len: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}qecvt_r"]
pub fn cqecvt_r(
__value: u128, __ndigit: ::std::os::raw::c_int, __decpt: *mut ::std::os::raw::c_int,
__sign: *mut ::std::os::raw::c_int, __buf: *mut ::std::os::raw::c_char, __len: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}qfcvt_r"]
pub fn cqfcvt_r(
__value: u128, __ndigit: ::std::os::raw::c_int, __decpt: *mut ::std::os::raw::c_int,
__sign: *mut ::std::os::raw::c_int, __buf: *mut ::std::os::raw::c_char, __len: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}mblen"]
pub fn cmblen(__s: *const ::std::os::raw::c_char, __n: usize) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}mbtowc"]
pub fn cmbtowc(
__pwc: *mut cwchar_t, __s: *const ::std::os::raw::c_char, __n: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}wctomb"]
pub fn cwctomb(__s: *mut ::std::os::raw::c_char, __wchar: cwchar_t) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}mbstowcs"]
pub fn cmbstowcs(
__pwcs: *mut cwchar_t, __s: *const ::std::os::raw::c_char, __n: usize,
) -> usize;
}
extern "C" {
#[link_name = "\u{1}wcstombs"]
pub fn cwcstombs(
__s: *mut ::std::os::raw::c_char, __pwcs: *const cwchar_t, __n: usize,
) -> usize;
}
extern "C" {
#[link_name = "\u{1}rpmatch"]
pub fn crpmatch(__response: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}getsubopt"]
pub fn cgetsubopt(
__optionp: *mut *mut ::std::os::raw::c_char, __tokens: *const *mut ::std::os::raw::c_char,
__valuep: *mut *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}getloadavg"]
pub fn cgetloadavg(
__loadavg: *mut f64, __nelem: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}memcpy"]
pub fn cmemcpy(
__dest: *mut ::std::os::raw::c_void, __src: *const ::std::os::raw::c_void,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
#[link_name = "\u{1}memmove"]
pub fn cmemmove(
__dest: *mut ::std::os::raw::c_void, __src: *const ::std::os::raw::c_void,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
#[link_name = "\u{1}memccpy"]
pub fn cmemccpy(
__dest: *mut ::std::os::raw::c_void, __src: *const ::std::os::raw::c_void,
__c: ::std::os::raw::c_int, __n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
#[link_name = "\u{1}memset"]
pub fn cmemset(
__s: *mut ::std::os::raw::c_void, __c: ::std::os::raw::c_int, __n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
#[link_name = "\u{1}memcmp"]
pub fn cmemcmp(
__s1: *const ::std::os::raw::c_void, __s2: *const ::std::os::raw::c_void,
__n: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__memcmpeq"]
pub fn c__memcmpeq(
__s1: *const ::std::os::raw::c_void, __s2: *const ::std::os::raw::c_void, __n: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}memchr"]
pub fn cmemchr(
__s: *const ::std::os::raw::c_void, __c: ::std::os::raw::c_int,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
#[link_name = "\u{1}strcpy"]
pub fn cstrcpy(
__dest: *mut ::std::os::raw::c_char, __src: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}strncpy"]
pub fn cstrncpy(
__dest: *mut ::std::os::raw::c_char, __src: *const ::std::os::raw::c_char,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}strcat"]
pub fn cstrcat(
__dest: *mut ::std::os::raw::c_char, __src: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}strncat"]
pub fn cstrncat(
__dest: *mut ::std::os::raw::c_char, __src: *const ::std::os::raw::c_char,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}strcmp"]
pub fn cstrcmp(
__s1: *const ::std::os::raw::c_char, __s2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}strncmp"]
pub fn cstrncmp(
__s1: *const ::std::os::raw::c_char, __s2: *const ::std::os::raw::c_char,
__n: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}strcoll"]
pub fn cstrcoll(
__s1: *const ::std::os::raw::c_char, __s2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}strxfrm"]
pub fn cstrxfrm(
__dest: *mut ::std::os::raw::c_char, __src: *const ::std::os::raw::c_char,
__n: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_ulong;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct c__locale_struct {
pub __locales: [*mut c__locale_data; 13usize],
pub __ctype_b: *const ::std::os::raw::c_ushort,
pub __ctype_tolower: *const ::std::os::raw::c_int,
pub __ctype_toupper: *const ::std::os::raw::c_int,
pub __names: [*const ::std::os::raw::c_char; 13usize],
}
#[test]
fn bindgen_test_layout_c__locale_struct() {
const UNINIT: ::std::mem::MaybeUninit<c__locale_struct> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<c__locale_struct>(),
232usize,
concat!("Size of: ", stringify!(c__locale_struct))
);
assert_eq!(
::std::mem::align_of::<c__locale_struct>(),
8usize,
concat!("Alignment of ", stringify!(c__locale_struct))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__locales) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c__locale_struct),
"::",
stringify!(__locales)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__ctype_b) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(c__locale_struct),
"::",
stringify!(__ctype_b)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__ctype_tolower) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(c__locale_struct),
"::",
stringify!(__ctype_tolower)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__ctype_toupper) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(c__locale_struct),
"::",
stringify!(__ctype_toupper)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__names) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(c__locale_struct),
"::",
stringify!(__names)
)
);
}
pub type c__locale_t = *mut c__locale_struct;
pub type clocale_t = c__locale_t;
extern "C" {
#[link_name = "\u{1}strcoll_l"]
pub fn cstrcoll_l(
__s1: *const ::std::os::raw::c_char, __s2: *const ::std::os::raw::c_char, __l: clocale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}strxfrm_l"]
pub fn cstrxfrm_l(
__dest: *mut ::std::os::raw::c_char, __src: *const ::std::os::raw::c_char, __n: usize,
__l: clocale_t,
) -> usize;
}
extern "C" {
#[link_name = "\u{1}strdup"]
pub fn cstrdup(__s: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}strndup"]
pub fn cstrndup(
__string: *const ::std::os::raw::c_char, __n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}strchr"]
pub fn cstrchr(
__s: *const ::std::os::raw::c_char, __c: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}strrchr"]
pub fn cstrrchr(
__s: *const ::std::os::raw::c_char, __c: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}strcspn"]
pub fn cstrcspn(
__s: *const ::std::os::raw::c_char, __reject: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
#[link_name = "\u{1}strspn"]
pub fn cstrspn(
__s: *const ::std::os::raw::c_char, __accept: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
#[link_name = "\u{1}strpbrk"]
pub fn cstrpbrk(
__s: *const ::std::os::raw::c_char, __accept: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}strstr"]
pub fn cstrstr(
__haystack: *const ::std::os::raw::c_char, __needle: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}strtok"]
pub fn cstrtok(
__s: *mut ::std::os::raw::c_char, __delim: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}__strtok_r"]
pub fn c__strtok_r(
__s: *mut ::std::os::raw::c_char, __delim: *const ::std::os::raw::c_char,
__save_ptr: *mut *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}strtok_r"]
pub fn cstrtok_r(
__s: *mut ::std::os::raw::c_char, __delim: *const ::std::os::raw::c_char,
__save_ptr: *mut *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}strlen"]
pub fn cstrlen(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_ulong;
}
extern "C" {
#[link_name = "\u{1}strnlen"]
pub fn cstrnlen(__string: *const ::std::os::raw::c_char, __maxlen: usize) -> usize;
}
extern "C" {
#[link_name = "\u{1}strerror"]
pub fn cstrerror(__errnum: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}__xpg_strerror_r"]
pub fn cstrerror_r(
__errnum: ::std::os::raw::c_int, __buf: *mut ::std::os::raw::c_char, __buflen: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}strerror_l"]
pub fn cstrerror_l(
__errnum: ::std::os::raw::c_int, __l: clocale_t,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}bcmp"]
pub fn cbcmp(
__s1: *const ::std::os::raw::c_void, __s2: *const ::std::os::raw::c_void,
__n: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}bcopy"]
pub fn cbcopy(
__src: *const ::std::os::raw::c_void, __dest: *mut ::std::os::raw::c_void, __n: usize,
);
}
extern "C" {
#[link_name = "\u{1}bzero"]
pub fn cbzero(__s: *mut ::std::os::raw::c_void, __n: ::std::os::raw::c_ulong);
}
extern "C" {
#[link_name = "\u{1}index"]
pub fn cindex(
__s: *const ::std::os::raw::c_char, __c: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}rindex"]
pub fn crindex(
__s: *const ::std::os::raw::c_char, __c: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}ffs"]
pub fn cffs(__i: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}ffsl"]
pub fn cffsl(__l: ::std::os::raw::c_long) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}ffsll"]
pub fn cffsll(__ll: ::std::os::raw::c_longlong) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}strcasecmp"]
pub fn cstrcasecmp(
__s1: *const ::std::os::raw::c_char, __s2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}strncasecmp"]
pub fn cstrncasecmp(
__s1: *const ::std::os::raw::c_char, __s2: *const ::std::os::raw::c_char,
__n: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}strcasecmp_l"]
pub fn cstrcasecmp_l(
__s1: *const ::std::os::raw::c_char, __s2: *const ::std::os::raw::c_char, __loc: clocale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}strncasecmp_l"]
pub fn cstrncasecmp_l(
__s1: *const ::std::os::raw::c_char, __s2: *const ::std::os::raw::c_char, __n: usize,
__loc: clocale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}explicit_bzero"]
pub fn cexplicit_bzero(__s: *mut ::std::os::raw::c_void, __n: usize);
}
extern "C" {
#[link_name = "\u{1}strsep"]
pub fn cstrsep(
__stringp: *mut *mut ::std::os::raw::c_char, __delim: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}strsignal"]
pub fn cstrsignal(__sig: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}__stpcpy"]
pub fn c__stpcpy(
__dest: *mut ::std::os::raw::c_char, __src: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}stpcpy"]
pub fn cstpcpy(
__dest: *mut ::std::os::raw::c_char, __src: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}__stpncpy"]
pub fn c__stpncpy(
__dest: *mut ::std::os::raw::c_char, __src: *const ::std::os::raw::c_char, __n: usize,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}stpncpy"]
pub fn cstpncpy(
__dest: *mut ::std::os::raw::c_char, __src: *const ::std::os::raw::c_char,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_char;
}
pub type cbw_ErrCode = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_Err {
pub code: cbw_ErrCode,
pub data: *const ::std::os::raw::c_void,
pub alloc_message: ::std::option::Option<
unsafe extern "C" fn(
code: cbw_ErrCode,
data: *const ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_char,
>,
}
#[test]
fn bindgen_test_layout_cbw_Err() {
const UNINIT: ::std::mem::MaybeUninit<cbw_Err> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_Err>(),
24usize,
concat!("Size of: ", stringify!(cbw_Err))
);
assert_eq!(
::std::mem::align_of::<cbw_Err>(),
8usize,
concat!("Alignment of ", stringify!(cbw_Err))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).code) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_Err),
"::",
stringify!(code)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(cbw_Err),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alloc_message) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(cbw_Err),
"::",
stringify!(alloc_message)
)
);
}
extern "C" {
#[link_name = "\u{1}bw_Err_msg_success"]
pub fn cbw_Err_msg_success(
arg1: cbw_ErrCode, arg2: *const ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}bw_Err_msg_string"]
pub fn cbw_Err_msg_string(
arg1: cbw_ErrCode, arg2: *const ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}bw_Err_free"]
pub fn cbw_Err_free(err: *mut cbw_Err);
}
extern "C" {
#[link_name = "\u{1}bw_Err_new_with_msg"]
pub fn cbw_Err_new_with_msg(code: cbw_ErrCode, msg: *const ::std::os::raw::c_char) -> cbw_Err;
}
extern "C" {
#[link_name = "\u{1}bw_Err_message"]
pub fn cbw_Err_message(error: *const cbw_Err) -> *mut ::std::os::raw::c_char;
}
pub type cint_least8_t = c__int_least8_t;
pub type cint_least16_t = c__int_least16_t;
pub type cint_least32_t = c__int_least32_t;
pub type cint_least64_t = c__int_least64_t;
pub type cuint_least8_t = c__uint_least8_t;
pub type cuint_least16_t = c__uint_least16_t;
pub type cuint_least32_t = c__uint_least32_t;
pub type cuint_least64_t = c__uint_least64_t;
pub type cint_fast8_t = ::std::os::raw::c_schar;
pub type cint_fast16_t = ::std::os::raw::c_long;
pub type cint_fast32_t = ::std::os::raw::c_long;
pub type cint_fast64_t = ::std::os::raw::c_long;
pub type cuint_fast8_t = ::std::os::raw::c_uchar;
pub type cuint_fast16_t = ::std::os::raw::c_ulong;
pub type cuint_fast32_t = ::std::os::raw::c_ulong;
pub type cuint_fast64_t = ::std::os::raw::c_ulong;
pub type cintmax_t = c__intmax_t;
pub type cuintmax_t = c__uintmax_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_Application {
pub windows_alive: ::std::os::raw::c_uint,
pub is_running: cBOOL,
pub is_done: cBOOL,
pub impl_: cbw_ApplicationImpl,
pub engine_impl: cbw_ApplicationEngineImpl,
}
#[test]
fn bindgen_test_layout_cbw_Application() {
const UNINIT: ::std::mem::MaybeUninit<cbw_Application> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_Application>(),
12usize,
concat!("Size of: ", stringify!(cbw_Application))
);
assert_eq!(
::std::mem::align_of::<cbw_Application>(),
4usize,
concat!("Alignment of ", stringify!(cbw_Application))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).windows_alive) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_Application),
"::",
stringify!(windows_alive)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_running) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(cbw_Application),
"::",
stringify!(is_running)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_done) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(cbw_Application),
"::",
stringify!(is_done)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(cbw_Application),
"::",
stringify!(impl_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).engine_impl) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(cbw_Application),
"::",
stringify!(engine_impl)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_ApplicationEngineData {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_ApplicationDispatchData {
pub func: cbw_ApplicationDispatchFn,
pub data: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_cbw_ApplicationDispatchData() {
const UNINIT: ::std::mem::MaybeUninit<cbw_ApplicationDispatchData> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_ApplicationDispatchData>(),
16usize,
concat!("Size of: ", stringify!(cbw_ApplicationDispatchData))
);
assert_eq!(
::std::mem::align_of::<cbw_ApplicationDispatchData>(),
8usize,
concat!("Alignment of ", stringify!(cbw_ApplicationDispatchData))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).func) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_ApplicationDispatchData),
"::",
stringify!(func)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(cbw_ApplicationDispatchData),
"::",
stringify!(data)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_ApplicationSettings {
pub engine_seperate_executable_path: cbw_CStrSlice,
pub remote_debugging_port: u16,
pub resource_dir: cbw_CStrSlice,
}
#[test]
fn bindgen_test_layout_cbw_ApplicationSettings() {
const UNINIT: ::std::mem::MaybeUninit<cbw_ApplicationSettings> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_ApplicationSettings>(),
40usize,
concat!("Size of: ", stringify!(cbw_ApplicationSettings))
);
assert_eq!(
::std::mem::align_of::<cbw_ApplicationSettings>(),
8usize,
concat!("Alignment of ", stringify!(cbw_ApplicationSettings))
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).engine_seperate_executable_path) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_ApplicationSettings),
"::",
stringify!(engine_seperate_executable_path)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).remote_debugging_port) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(cbw_ApplicationSettings),
"::",
stringify!(remote_debugging_port)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).resource_dir) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(cbw_ApplicationSettings),
"::",
stringify!(resource_dir)
)
);
}
extern "C" {
#[doc = " Safety check that makes sure the given application handle is used on the correct thread.\n Does nothing in release mode."]
#[link_name = "\u{1}bw_Application_assertCorrectThread"]
pub fn cbw_Application_assertCorrectThread(arg1: *const cbw_Application);
}
extern "C" {
#[doc = " Exits the main loop, returning execution to the function that invoked the run call.\n The exit_code will be returned by bw_Application_run."]
#[link_name = "\u{1}bw_Application_exit"]
pub fn cbw_Application_exit(app: *mut cbw_Application, exit_code: ::std::os::raw::c_int);
}
extern "C" {
#[doc = " Same as bw_Application_exit, but guaranteed to be thread-safe\n The exit_code will be returned by bw_Application_run."]
#[link_name = "\u{1}bw_Application_exitAsync"]
pub fn cbw_Application_exitAsync(app: *mut cbw_Application, exit_code: ::std::os::raw::c_int);
}
extern "C" {
#[doc = " Dispatches the given function to be executed on the thread this application instance has been created on,\n and passes the given data to it.\n This function is thread safe.\n\n # Returns\n An indication of whether or not the function was able to be dispatched.\n Dispatching a function fails when the application has already been terminated."]
#[link_name = "\u{1}bw_Application_dispatch"]
pub fn cbw_Application_dispatch(
app: *mut cbw_Application, func: cbw_ApplicationDispatchFn,
data: *mut ::std::os::raw::c_void,
) -> cBOOL;
}
extern "C" {
#[doc = " Shuts down the applcation runtime & frees it's memory."]
#[link_name = "\u{1}bw_Application_free"]
pub fn cbw_Application_free(app: *mut cbw_Application);
}
extern "C" {
#[doc = " Initializes browser window.\n Starts up browser engine process(es).\n Returns an application handle."]
#[link_name = "\u{1}bw_Application_initialize"]
pub fn cbw_Application_initialize(
application: *mut *mut cbw_Application, argc: ::std::os::raw::c_int,
argv: *mut *mut ::std::os::raw::c_char, settings: *const cbw_ApplicationSettings,
) -> cbw_Err;
}
extern "C" {
#[link_name = "\u{1}bw_Application_isRunning"]
pub fn cbw_Application_isRunning(app: *const cbw_Application) -> cBOOL;
}
extern "C" {
#[link_name = "\u{1}bw_Application_markAsDone"]
pub fn cbw_Application_markAsDone(app: *mut cbw_Application);
}
extern "C" {
#[doc = " Runs the event loop.\n Calls the `on_ready` callback when `app` can be used."]
#[link_name = "\u{1}bw_Application_run"]
pub fn cbw_Application_run(
app: *mut cbw_Application, on_ready: cbw_ApplicationReadyFn,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Executes the given closure after the specified delay."]
#[link_name = "\u{1}bw_Application_dispatchDelayed"]
pub fn cbw_Application_dispatchDelayed(
app: *mut cbw_Application, func: cbw_ApplicationDispatchFn,
user_data: *mut ::std::os::raw::c_void, milliseconds: u64,
) -> cBOOL;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_BrowserWindowImpl {}
#[test]
fn bindgen_test_layout_cbw_BrowserWindowImpl() {
assert_eq!(
::std::mem::size_of::<cbw_BrowserWindowImpl>(),
0usize,
concat!("Size of: ", stringify!(cbw_BrowserWindowImpl))
);
assert_eq!(
::std::mem::align_of::<cbw_BrowserWindowImpl>(),
1usize,
concat!("Alignment of ", stringify!(cbw_BrowserWindowImpl))
);
}
pub type cbw_EventCallbackFn = ::std::option::Option<
unsafe extern "C" fn(
arg: *mut ::std::os::raw::c_void,
event_data: *mut ::std::os::raw::c_void,
) -> cBOOL,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_Event {
pub callback: cbw_EventCallbackFn,
pub data: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_cbw_Event() {
const UNINIT: ::std::mem::MaybeUninit<cbw_Event> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_Event>(),
16usize,
concat!("Size of: ", stringify!(cbw_Event))
);
assert_eq!(
::std::mem::align_of::<cbw_Event>(),
8usize,
concat!("Alignment of ", stringify!(cbw_Event))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).callback) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_Event),
"::",
stringify!(callback)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(cbw_Event),
"::",
stringify!(data)
)
);
}
extern "C" {
#[link_name = "\u{1}bw_Event_fire"]
pub fn cbw_Event_fire(event: *mut cbw_Event, data: *mut ::std::os::raw::c_void) -> cBOOL;
}
extern "C" {
#[link_name = "\u{1}__assert_fail"]
pub fn c__assert_fail(
__assertion: *const ::std::os::raw::c_char, __file: *const ::std::os::raw::c_char,
__line: ::std::os::raw::c_uint, __function: *const ::std::os::raw::c_char,
) -> !;
}
extern "C" {
#[link_name = "\u{1}__assert_perror_fail"]
pub fn c__assert_perror_fail(
__errnum: ::std::os::raw::c_int, __file: *const ::std::os::raw::c_char,
__line: ::std::os::raw::c_uint, __function: *const ::std::os::raw::c_char,
) -> !;
}
extern "C" {
#[link_name = "\u{1}__assert"]
pub fn c__assert(
__assertion: *const ::std::os::raw::c_char, __file: *const ::std::os::raw::c_char,
__line: ::std::os::raw::c_int,
) -> !;
}
pub type cva_list = c__builtin_va_list;
pub type c__gnuc_va_list = c__builtin_va_list;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct c__mbstate_t {
pub __count: ::std::os::raw::c_int,
pub __value: c__mbstate_t__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union c__mbstate_t__bindgen_ty_1 {
pub __wch: ::std::os::raw::c_uint,
pub __wchb: [::std::os::raw::c_char; 4usize],
}
#[test]
fn bindgen_test_layout_c__mbstate_t__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<c__mbstate_t__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<c__mbstate_t__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(c__mbstate_t__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<c__mbstate_t__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(c__mbstate_t__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__wch) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c__mbstate_t__bindgen_ty_1),
"::",
stringify!(__wch)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__wchb) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c__mbstate_t__bindgen_ty_1),
"::",
stringify!(__wchb)
)
);
}
#[test]
fn bindgen_test_layout_c__mbstate_t() {
const UNINIT: ::std::mem::MaybeUninit<c__mbstate_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<c__mbstate_t>(),
8usize,
concat!("Size of: ", stringify!(c__mbstate_t))
);
assert_eq!(
::std::mem::align_of::<c__mbstate_t>(),
4usize,
concat!("Alignment of ", stringify!(c__mbstate_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__count) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c__mbstate_t),
"::",
stringify!(__count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__value) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(c__mbstate_t),
"::",
stringify!(__value)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct c_G_fpos_t {
pub __pos: c__off_t,
pub __state: c__mbstate_t,
}
#[test]
fn bindgen_test_layout_c_G_fpos_t() {
const UNINIT: ::std::mem::MaybeUninit<c_G_fpos_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<c_G_fpos_t>(),
16usize,
concat!("Size of: ", stringify!(c_G_fpos_t))
);
assert_eq!(
::std::mem::align_of::<c_G_fpos_t>(),
8usize,
concat!("Alignment of ", stringify!(c_G_fpos_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__pos) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c_G_fpos_t),
"::",
stringify!(__pos)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__state) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(c_G_fpos_t),
"::",
stringify!(__state)
)
);
}
pub type c__fpos_t = c_G_fpos_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct c_G_fpos64_t {
pub __pos: c__off64_t,
pub __state: c__mbstate_t,
}
#[test]
fn bindgen_test_layout_c_G_fpos64_t() {
const UNINIT: ::std::mem::MaybeUninit<c_G_fpos64_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<c_G_fpos64_t>(),
16usize,
concat!("Size of: ", stringify!(c_G_fpos64_t))
);
assert_eq!(
::std::mem::align_of::<c_G_fpos64_t>(),
8usize,
concat!("Alignment of ", stringify!(c_G_fpos64_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__pos) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c_G_fpos64_t),
"::",
stringify!(__pos)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__state) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(c_G_fpos64_t),
"::",
stringify!(__state)
)
);
}
pub type c__fpos64_t = c_G_fpos64_t;
pub type c__FILE = c_IO_FILE;
pub type cFILE = c_IO_FILE;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct c_IO_marker {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct c_IO_codecvt {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct c_IO_wide_data {
_unused: [u8; 0],
}
pub type c_IO_lock_t = ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct c_IO_FILE {
pub _flags: ::std::os::raw::c_int,
pub _IO_read_ptr: *mut ::std::os::raw::c_char,
pub _IO_read_end: *mut ::std::os::raw::c_char,
pub _IO_read_base: *mut ::std::os::raw::c_char,
pub _IO_write_base: *mut ::std::os::raw::c_char,
pub _IO_write_ptr: *mut ::std::os::raw::c_char,
pub _IO_write_end: *mut ::std::os::raw::c_char,
pub _IO_buf_base: *mut ::std::os::raw::c_char,
pub _IO_buf_end: *mut ::std::os::raw::c_char,
pub _IO_save_base: *mut ::std::os::raw::c_char,
pub _IO_backup_base: *mut ::std::os::raw::c_char,
pub _IO_save_end: *mut ::std::os::raw::c_char,
pub _markers: *mut c_IO_marker,
pub _chain: *mut c_IO_FILE,
pub _fileno: ::std::os::raw::c_int,
pub _flags2: ::std::os::raw::c_int,
pub _old_offset: c__off_t,
pub _cur_column: ::std::os::raw::c_ushort,
pub _vtable_offset: ::std::os::raw::c_schar,
pub _shortbuf: [::std::os::raw::c_char; 1usize],
pub _lock: *mut c_IO_lock_t,
pub _offset: c__off64_t,
pub _codecvt: *mut c_IO_codecvt,
pub _wide_data: *mut c_IO_wide_data,
pub _freeres_list: *mut c_IO_FILE,
pub _freeres_buf: *mut ::std::os::raw::c_void,
pub __pad5: usize,
pub _mode: ::std::os::raw::c_int,
pub _unused2: [::std::os::raw::c_char; 20usize],
}
#[test]
fn bindgen_test_layout_c_IO_FILE() {
const UNINIT: ::std::mem::MaybeUninit<c_IO_FILE> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<c_IO_FILE>(),
216usize,
concat!("Size of: ", stringify!(c_IO_FILE))
);
assert_eq!(
::std::mem::align_of::<c_IO_FILE>(),
8usize,
concat!("Alignment of ", stringify!(c_IO_FILE))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._flags) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_ptr) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_read_ptr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_end) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_read_end)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_base) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_read_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_base) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_write_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_ptr) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_write_ptr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_end) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_write_end)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_buf_base) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_buf_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_buf_end) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_buf_end)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_save_base) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_save_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_backup_base) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_backup_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_save_end) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_save_end)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._markers) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_markers)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._chain) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_chain)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._fileno) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_fileno)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._flags2) as usize - ptr as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_flags2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._old_offset) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_old_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._cur_column) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_cur_column)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._vtable_offset) as usize - ptr as usize },
130usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_vtable_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._shortbuf) as usize - ptr as usize },
131usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_shortbuf)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._lock) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_lock)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._offset) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._codecvt) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_codecvt)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._wide_data) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_wide_data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._freeres_list) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_freeres_list)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._freeres_buf) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_freeres_buf)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__pad5) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(__pad5)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._mode) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._unused2) as usize - ptr as usize },
196usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_unused2)
)
);
}
pub type cfpos_t = c__fpos_t;
extern "C" {
#[link_name = "\u{1}stdin"]
pub static mut cstdin: *mut cFILE;
}
extern "C" {
#[link_name = "\u{1}stdout"]
pub static mut cstdout: *mut cFILE;
}
extern "C" {
#[link_name = "\u{1}stderr"]
pub static mut cstderr: *mut cFILE;
}
extern "C" {
#[link_name = "\u{1}remove"]
pub fn cremove(__filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}rename"]
pub fn crename(
__old: *const ::std::os::raw::c_char, __new: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}renameat"]
pub fn crenameat(
__oldfd: ::std::os::raw::c_int, __old: *const ::std::os::raw::c_char,
__newfd: ::std::os::raw::c_int, __new: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}fclose"]
pub fn cfclose(__stream: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}tmpfile"]
pub fn ctmpfile() -> *mut cFILE;
}
extern "C" {
#[link_name = "\u{1}tmpnam"]
pub fn ctmpnam(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}tmpnam_r"]
pub fn ctmpnam_r(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}tempnam"]
pub fn ctempnam(
__dir: *const ::std::os::raw::c_char, __pfx: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}fflush"]
pub fn cfflush(__stream: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}fflush_unlocked"]
pub fn cfflush_unlocked(__stream: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}fopen"]
pub fn cfopen(
__filename: *const ::std::os::raw::c_char, __modes: *const ::std::os::raw::c_char,
) -> *mut cFILE;
}
extern "C" {
#[link_name = "\u{1}freopen"]
pub fn cfreopen(
__filename: *const ::std::os::raw::c_char, __modes: *const ::std::os::raw::c_char,
__stream: *mut cFILE,
) -> *mut cFILE;
}
extern "C" {
#[link_name = "\u{1}fdopen"]
pub fn cfdopen(
__fd: ::std::os::raw::c_int, __modes: *const ::std::os::raw::c_char,
) -> *mut cFILE;
}
extern "C" {
#[link_name = "\u{1}fmemopen"]
pub fn cfmemopen(
__s: *mut ::std::os::raw::c_void, __len: usize, __modes: *const ::std::os::raw::c_char,
) -> *mut cFILE;
}
extern "C" {
#[link_name = "\u{1}open_memstream"]
pub fn copen_memstream(
__bufloc: *mut *mut ::std::os::raw::c_char, __sizeloc: *mut usize,
) -> *mut cFILE;
}
extern "C" {
#[link_name = "\u{1}setbuf"]
pub fn csetbuf(__stream: *mut cFILE, __buf: *mut ::std::os::raw::c_char);
}
extern "C" {
#[link_name = "\u{1}setvbuf"]
pub fn csetvbuf(
__stream: *mut cFILE, __buf: *mut ::std::os::raw::c_char, __modes: ::std::os::raw::c_int,
__n: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}setbuffer"]
pub fn csetbuffer(__stream: *mut cFILE, __buf: *mut ::std::os::raw::c_char, __size: usize);
}
extern "C" {
#[link_name = "\u{1}setlinebuf"]
pub fn csetlinebuf(__stream: *mut cFILE);
}
extern "C" {
#[link_name = "\u{1}fprintf"]
pub fn cfprintf(
__stream: *mut cFILE, __format: *const ::std::os::raw::c_char, ...
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}printf"]
pub fn cprintf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}sprintf"]
pub fn csprintf(
__s: *mut ::std::os::raw::c_char, __format: *const ::std::os::raw::c_char, ...
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}vfprintf"]
pub fn cvfprintf(
__s: *mut cFILE, __format: *const ::std::os::raw::c_char, __arg: *mut c__va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}vprintf"]
pub fn cvprintf(
__format: *const ::std::os::raw::c_char, __arg: *mut c__va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}vsprintf"]
pub fn cvsprintf(
__s: *mut ::std::os::raw::c_char, __format: *const ::std::os::raw::c_char,
__arg: *mut c__va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}snprintf"]
pub fn csnprintf(
__s: *mut ::std::os::raw::c_char, __maxlen: ::std::os::raw::c_ulong,
__format: *const ::std::os::raw::c_char, ...
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}vsnprintf"]
pub fn cvsnprintf(
__s: *mut ::std::os::raw::c_char, __maxlen: ::std::os::raw::c_ulong,
__format: *const ::std::os::raw::c_char, __arg: *mut c__va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}vdprintf"]
pub fn cvdprintf(
__fd: ::std::os::raw::c_int, __fmt: *const ::std::os::raw::c_char,
__arg: *mut c__va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}dprintf"]
pub fn cdprintf(
__fd: ::std::os::raw::c_int, __fmt: *const ::std::os::raw::c_char, ...
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}fscanf"]
pub fn cfscanf(
__stream: *mut cFILE, __format: *const ::std::os::raw::c_char, ...
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}scanf"]
pub fn cscanf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}sscanf"]
pub fn csscanf(
__s: *const ::std::os::raw::c_char, __format: *const ::std::os::raw::c_char, ...
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_fscanf"]
pub fn cfscanf1(
__stream: *mut cFILE, __format: *const ::std::os::raw::c_char, ...
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_scanf"]
pub fn cscanf1(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_sscanf"]
pub fn csscanf1(
__s: *const ::std::os::raw::c_char, __format: *const ::std::os::raw::c_char, ...
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}vfscanf"]
pub fn cvfscanf(
__s: *mut cFILE, __format: *const ::std::os::raw::c_char, __arg: *mut c__va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}vscanf"]
pub fn cvscanf(
__format: *const ::std::os::raw::c_char, __arg: *mut c__va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}vsscanf"]
pub fn cvsscanf(
__s: *const ::std::os::raw::c_char, __format: *const ::std::os::raw::c_char,
__arg: *mut c__va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_vfscanf"]
pub fn cvfscanf1(
__s: *mut cFILE, __format: *const ::std::os::raw::c_char, __arg: *mut c__va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_vscanf"]
pub fn cvscanf1(
__format: *const ::std::os::raw::c_char, __arg: *mut c__va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_vsscanf"]
pub fn cvsscanf1(
__s: *const ::std::os::raw::c_char, __format: *const ::std::os::raw::c_char,
__arg: *mut c__va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}fgetc"]
pub fn cfgetc(__stream: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}getc"]
pub fn cgetc(__stream: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}getchar"]
pub fn cgetchar() -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}getc_unlocked"]
pub fn cgetc_unlocked(__stream: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}getchar_unlocked"]
pub fn cgetchar_unlocked() -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}fgetc_unlocked"]
pub fn cfgetc_unlocked(__stream: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}fputc"]
pub fn cfputc(__c: ::std::os::raw::c_int, __stream: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}putc"]
pub fn cputc(__c: ::std::os::raw::c_int, __stream: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}putchar"]
pub fn cputchar(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}fputc_unlocked"]
pub fn cfputc_unlocked(
__c: ::std::os::raw::c_int, __stream: *mut cFILE,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}putc_unlocked"]
pub fn cputc_unlocked(
__c: ::std::os::raw::c_int, __stream: *mut cFILE,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}putchar_unlocked"]
pub fn cputchar_unlocked(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}getw"]
pub fn cgetw(__stream: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}putw"]
pub fn cputw(__w: ::std::os::raw::c_int, __stream: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}fgets"]
pub fn cfgets(
__s: *mut ::std::os::raw::c_char, __n: ::std::os::raw::c_int, __stream: *mut cFILE,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}__getdelim"]
pub fn c__getdelim(
__lineptr: *mut *mut ::std::os::raw::c_char, __n: *mut usize,
__delimiter: ::std::os::raw::c_int, __stream: *mut cFILE,
) -> c__ssize_t;
}
extern "C" {
#[link_name = "\u{1}getdelim"]
pub fn cgetdelim(
__lineptr: *mut *mut ::std::os::raw::c_char, __n: *mut usize,
__delimiter: ::std::os::raw::c_int, __stream: *mut cFILE,
) -> c__ssize_t;
}
extern "C" {
#[link_name = "\u{1}getline"]
pub fn cgetline(
__lineptr: *mut *mut ::std::os::raw::c_char, __n: *mut usize, __stream: *mut cFILE,
) -> c__ssize_t;
}
extern "C" {
#[link_name = "\u{1}fputs"]
pub fn cfputs(
__s: *const ::std::os::raw::c_char, __stream: *mut cFILE,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}puts"]
pub fn cputs(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}ungetc"]
pub fn cungetc(__c: ::std::os::raw::c_int, __stream: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}fread"]
pub fn cfread(
__ptr: *mut ::std::os::raw::c_void, __size: ::std::os::raw::c_ulong,
__n: ::std::os::raw::c_ulong, __stream: *mut cFILE,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
#[link_name = "\u{1}fwrite"]
pub fn cfwrite(
__ptr: *const ::std::os::raw::c_void, __size: ::std::os::raw::c_ulong,
__n: ::std::os::raw::c_ulong, __s: *mut cFILE,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
#[link_name = "\u{1}fread_unlocked"]
pub fn cfread_unlocked(
__ptr: *mut ::std::os::raw::c_void, __size: usize, __n: usize, __stream: *mut cFILE,
) -> usize;
}
extern "C" {
#[link_name = "\u{1}fwrite_unlocked"]
pub fn cfwrite_unlocked(
__ptr: *const ::std::os::raw::c_void, __size: usize, __n: usize, __stream: *mut cFILE,
) -> usize;
}
extern "C" {
#[link_name = "\u{1}fseek"]
pub fn cfseek(
__stream: *mut cFILE, __off: ::std::os::raw::c_long, __whence: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}ftell"]
pub fn cftell(__stream: *mut cFILE) -> ::std::os::raw::c_long;
}
extern "C" {
#[link_name = "\u{1}rewind"]
pub fn crewind(__stream: *mut cFILE);
}
extern "C" {
#[link_name = "\u{1}fseeko"]
pub fn cfseeko(
__stream: *mut cFILE, __off: c__off_t, __whence: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}ftello"]
pub fn cftello(__stream: *mut cFILE) -> c__off_t;
}
extern "C" {
#[link_name = "\u{1}fgetpos"]
pub fn cfgetpos(__stream: *mut cFILE, __pos: *mut cfpos_t) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}fsetpos"]
pub fn cfsetpos(__stream: *mut cFILE, __pos: *const cfpos_t) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}clearerr"]
pub fn cclearerr(__stream: *mut cFILE);
}
extern "C" {
#[link_name = "\u{1}feof"]
pub fn cfeof(__stream: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}ferror"]
pub fn cferror(__stream: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}clearerr_unlocked"]
pub fn cclearerr_unlocked(__stream: *mut cFILE);
}
extern "C" {
#[link_name = "\u{1}feof_unlocked"]
pub fn cfeof_unlocked(__stream: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}ferror_unlocked"]
pub fn cferror_unlocked(__stream: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}perror"]
pub fn cperror(__s: *const ::std::os::raw::c_char);
}
extern "C" {
#[link_name = "\u{1}fileno"]
pub fn cfileno(__stream: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}fileno_unlocked"]
pub fn cfileno_unlocked(__stream: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}pclose"]
pub fn cpclose(__stream: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}popen"]
pub fn cpopen(
__command: *const ::std::os::raw::c_char, __modes: *const ::std::os::raw::c_char,
) -> *mut cFILE;
}
extern "C" {
#[link_name = "\u{1}ctermid"]
pub fn cctermid(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}flockfile"]
pub fn cflockfile(__stream: *mut cFILE);
}
extern "C" {
#[link_name = "\u{1}ftrylockfile"]
pub fn cftrylockfile(__stream: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}funlockfile"]
pub fn cfunlockfile(__stream: *mut cFILE);
}
extern "C" {
#[link_name = "\u{1}__uflow"]
pub fn c__uflow(arg1: *mut cFILE) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__overflow"]
pub fn c__overflow(arg1: *mut cFILE, arg2: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_Dims2D {
pub width: u16,
pub height: u16,
}
#[test]
fn bindgen_test_layout_cbw_Dims2D() {
const UNINIT: ::std::mem::MaybeUninit<cbw_Dims2D> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_Dims2D>(),
4usize,
concat!("Size of: ", stringify!(cbw_Dims2D))
);
assert_eq!(
::std::mem::align_of::<cbw_Dims2D>(),
2usize,
concat!("Alignment of ", stringify!(cbw_Dims2D))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_Dims2D),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(cbw_Dims2D),
"::",
stringify!(height)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_Pos2D {
pub x: u16,
pub y: u16,
}
#[test]
fn bindgen_test_layout_cbw_Pos2D() {
const UNINIT: ::std::mem::MaybeUninit<cbw_Pos2D> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_Pos2D>(),
4usize,
concat!("Size of: ", stringify!(cbw_Pos2D))
);
assert_eq!(
::std::mem::align_of::<cbw_Pos2D>(),
2usize,
concat!("Alignment of ", stringify!(cbw_Pos2D))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_Pos2D),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(cbw_Pos2D),
"::",
stringify!(y)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_WindowOptions {
pub borders: bool,
pub minimizable: bool,
pub resizable: bool,
}
#[test]
fn bindgen_test_layout_cbw_WindowOptions() {
const UNINIT: ::std::mem::MaybeUninit<cbw_WindowOptions> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_WindowOptions>(),
3usize,
concat!("Size of: ", stringify!(cbw_WindowOptions))
);
assert_eq!(
::std::mem::align_of::<cbw_WindowOptions>(),
1usize,
concat!("Alignment of ", stringify!(cbw_WindowOptions))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).borders) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_WindowOptions),
"::",
stringify!(borders)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minimizable) as usize - ptr as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(cbw_WindowOptions),
"::",
stringify!(minimizable)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).resizable) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(cbw_WindowOptions),
"::",
stringify!(resizable)
)
);
}
pub type cbw_WindowDispatchFn = ::std::option::Option<
unsafe extern "C" fn(window: *mut cbw_Window, data: *mut ::std::os::raw::c_void),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_WindowDispatchData {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_WindowImpl {}
#[test]
fn bindgen_test_layout_cbw_WindowImpl() {
assert_eq!(
::std::mem::size_of::<cbw_WindowImpl>(),
0usize,
concat!("Size of: ", stringify!(cbw_WindowImpl))
);
assert_eq!(
::std::mem::align_of::<cbw_WindowImpl>(),
1usize,
concat!("Alignment of ", stringify!(cbw_WindowImpl))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_Window {
pub app: *mut cbw_Application,
pub parent: *const cbw_Window,
pub closed: bool,
pub dropped: bool,
pub user_data: *mut ::std::os::raw::c_void,
pub impl_: cbw_WindowImpl,
}
#[test]
fn bindgen_test_layout_cbw_Window() {
const UNINIT: ::std::mem::MaybeUninit<cbw_Window> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_Window>(),
32usize,
concat!("Size of: ", stringify!(cbw_Window))
);
assert_eq!(
::std::mem::align_of::<cbw_Window>(),
8usize,
concat!("Alignment of ", stringify!(cbw_Window))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).app) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_Window),
"::",
stringify!(app)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(cbw_Window),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).closed) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(cbw_Window),
"::",
stringify!(closed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dropped) as usize - ptr as usize },
17usize,
concat!(
"Offset of field: ",
stringify!(cbw_Window),
"::",
stringify!(dropped)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).user_data) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(cbw_Window),
"::",
stringify!(user_data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(cbw_Window),
"::",
stringify!(impl_)
)
);
}
extern "C" {
#[doc = " Hides the window and frees the user data"]
#[link_name = "\u{1}bw_Window_close"]
pub fn cbw_Window_close(window: *mut cbw_Window);
}
extern "C" {
#[doc = " Invalidates the window handle."]
#[link_name = "\u{1}bw_Window_free"]
pub fn cbw_Window_free(window: *mut cbw_Window);
}
extern "C" {
#[doc = " Frees the user data that was attached to this window."]
#[link_name = "\u{1}bw_Window_freeUserData"]
pub fn cbw_Window_freeUserData(window: *mut cbw_Window);
}
extern "C" {
#[doc = " Gets the width and height of the usable area inside the window."]
#[link_name = "\u{1}bw_Window_getContentDimensions"]
pub fn cbw_Window_getContentDimensions(window: *mut cbw_Window) -> cbw_Dims2D;
}
extern "C" {
#[doc = " Gets the opacity of the window as a value from 0 to 255."]
#[link_name = "\u{1}bw_Window_getOpacity"]
pub fn cbw_Window_getOpacity(window: *mut cbw_Window) -> u8;
}
extern "C" {
#[doc = " Gets the X and Y coordinates of the window position relative to the desktop screen."]
#[link_name = "\u{1}bw_Window_getPosition"]
pub fn cbw_Window_getPosition(window: *mut cbw_Window) -> cbw_Pos2D;
}
extern "C" {
#[doc = " Copies as many bytes into `title` that fit in there.\n Returns the number of characters the title actually has."]
#[link_name = "\u{1}bw_Window_getTitle"]
pub fn cbw_Window_getTitle(
window: *mut cbw_Window, title: *mut *mut ::std::os::raw::c_char,
) -> usize;
}
extern "C" {
#[doc = " Gets the width and height of the window including the title bar and borders."]
#[link_name = "\u{1}bw_Window_getWindowDimensions"]
pub fn cbw_Window_getWindowDimensions(window: *mut cbw_Window) -> cbw_Dims2D;
}
extern "C" {
#[link_name = "\u{1}bw_Window_hide"]
pub fn cbw_Window_hide(window: *mut cbw_Window);
}
extern "C" {
#[doc = " Returns whether or not the window is not hidden.\n `bw_Window_show` and `bw_Window_hide` change the visibility."]
#[link_name = "\u{1}bw_Window_isVisible"]
pub fn cbw_Window_isVisible(window: *const cbw_Window) -> bool;
}
extern "C" {
#[doc = " Creates a new (empty) window\n The returned pointer is a handler for the window.\n bw_Window_drop needs to be called on it after it is done being used,\n otherwise the window is never actually destroyed and memory leakes happen."]
#[link_name = "\u{1}bw_Window_new"]
pub fn cbw_Window_new(
app: *mut cbw_Application, parent: *const cbw_Window, _title: cbw_CStrSlice,
width: ::std::os::raw::c_int, height: ::std::os::raw::c_int,
options: *const cbw_WindowOptions,
) -> *mut cbw_Window;
}
extern "C" {
#[link_name = "\u{1}bw_Window_setContentDimensions"]
pub fn cbw_Window_setContentDimensions(window: *mut cbw_Window, dimensions: cbw_Dims2D);
}
extern "C" {
#[link_name = "\u{1}bw_Window_setOpacity"]
pub fn cbw_Window_setOpacity(window: *mut cbw_Window, opacity: u8);
}
extern "C" {
#[link_name = "\u{1}bw_Window_setPosition"]
pub fn cbw_Window_setPosition(window: *mut cbw_Window, position: cbw_Pos2D);
}
extern "C" {
#[link_name = "\u{1}bw_Window_setUserData"]
pub fn cbw_Window_setUserData(bw: *mut cbw_Window, user_data: *mut ::std::os::raw::c_void);
}
extern "C" {
#[doc = " Applies the given title;"]
#[link_name = "\u{1}bw_Window_setTitle"]
pub fn cbw_Window_setTitle(window: *mut cbw_Window, title: cbw_CStrSlice);
}
extern "C" {
#[link_name = "\u{1}bw_Window_setWindowDimensions"]
pub fn cbw_Window_setWindowDimensions(window: *mut cbw_Window, dimensions: cbw_Dims2D);
}
extern "C" {
#[doc = " Shows the window if it was previously hidden\n Is generally called after window creation."]
#[link_name = "\u{1}bw_Window_show"]
pub fn cbw_Window_show(window: *mut cbw_Window);
}
extern "C" {
#[link_name = "\u{1}bw_Window_triggerClose"]
pub fn cbw_Window_triggerClose(window: *mut cbw_Window);
}
extern "C" {
#[link_name = "\u{1}_bw_Window_onResize"]
pub fn c_bw_Window_onResize(
window: *const cbw_Window, width: ::std::os::raw::c_uint, height: ::std::os::raw::c_uint,
);
}
pub type cbw_BrowserWindowCreationCallbackFn = ::std::option::Option<
unsafe extern "C" fn(window: *mut cbw_BrowserWindow, data: *mut ::std::os::raw::c_void),
>;
pub type cbw_BrowserWindowHandlerFn = ::std::option::Option<
unsafe extern "C" fn(
window: *mut cbw_BrowserWindow,
cmd: cbw_CStrSlice,
args: *mut cbw_CStrSlice,
arg_count: usize,
),
>;
pub type cbw_BrowserWindowJsCallbackFn = ::std::option::Option<
unsafe extern "C" fn(
window: *mut cbw_BrowserWindow,
user_data: *mut ::std::os::raw::c_void,
result: *const ::std::os::raw::c_char,
err: *const cbw_Err,
),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_BrowserWindowEvents {
pub on_address_changed: cbw_Event,
pub on_console_message: cbw_Event,
pub on_favicon_changed: cbw_Event,
pub on_fullscreen_mode_changed: cbw_Event,
pub on_loading_progress_changed: cbw_Event,
pub on_message: cbw_Event,
pub on_navigation_start: cbw_Event,
pub on_navigation_end: cbw_Event,
pub on_page_title_changed: cbw_Event,
pub on_status_message: cbw_Event,
pub on_tooltip: cbw_Event,
}
#[test]
fn bindgen_test_layout_cbw_BrowserWindowEvents() {
const UNINIT: ::std::mem::MaybeUninit<cbw_BrowserWindowEvents> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_BrowserWindowEvents>(),
176usize,
concat!("Size of: ", stringify!(cbw_BrowserWindowEvents))
);
assert_eq!(
::std::mem::align_of::<cbw_BrowserWindowEvents>(),
8usize,
concat!("Alignment of ", stringify!(cbw_BrowserWindowEvents))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).on_address_changed) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowEvents),
"::",
stringify!(on_address_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).on_console_message) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowEvents),
"::",
stringify!(on_console_message)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).on_favicon_changed) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowEvents),
"::",
stringify!(on_favicon_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).on_fullscreen_mode_changed) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowEvents),
"::",
stringify!(on_fullscreen_mode_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).on_loading_progress_changed) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowEvents),
"::",
stringify!(on_loading_progress_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).on_message) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowEvents),
"::",
stringify!(on_message)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).on_navigation_start) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowEvents),
"::",
stringify!(on_navigation_start)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).on_navigation_end) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowEvents),
"::",
stringify!(on_navigation_end)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).on_page_title_changed) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowEvents),
"::",
stringify!(on_page_title_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).on_status_message) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowEvents),
"::",
stringify!(on_status_message)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).on_tooltip) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowEvents),
"::",
stringify!(on_tooltip)
)
);
}
#[doc = " `cmd` is always a string. The arguments are JS values in the form of a string."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_BrowserWindowMessageArgs {
pub cmd: cbw_CStrSlice,
pub arg_count: usize,
pub args: *mut cbw_CStrSlice,
}
#[test]
fn bindgen_test_layout_cbw_BrowserWindowMessageArgs() {
const UNINIT: ::std::mem::MaybeUninit<cbw_BrowserWindowMessageArgs> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_BrowserWindowMessageArgs>(),
32usize,
concat!("Size of: ", stringify!(cbw_BrowserWindowMessageArgs))
);
assert_eq!(
::std::mem::align_of::<cbw_BrowserWindowMessageArgs>(),
8usize,
concat!("Alignment of ", stringify!(cbw_BrowserWindowMessageArgs))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cmd) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowMessageArgs),
"::",
stringify!(cmd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).arg_count) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowMessageArgs),
"::",
stringify!(arg_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).args) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowMessageArgs),
"::",
stringify!(args)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_BrowserWindowOptions {
pub dev_tools: cBOOL,
pub resource_path: cbw_CStrSlice,
}
#[test]
fn bindgen_test_layout_cbw_BrowserWindowOptions() {
const UNINIT: ::std::mem::MaybeUninit<cbw_BrowserWindowOptions> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_BrowserWindowOptions>(),
24usize,
concat!("Size of: ", stringify!(cbw_BrowserWindowOptions))
);
assert_eq!(
::std::mem::align_of::<cbw_BrowserWindowOptions>(),
8usize,
concat!("Alignment of ", stringify!(cbw_BrowserWindowOptions))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dev_tools) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowOptions),
"::",
stringify!(dev_tools)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).resource_path) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowOptions),
"::",
stringify!(resource_path)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_BrowserWindowSource {
pub data: cbw_CStrSlice,
pub is_html: cBOOL,
}
#[test]
fn bindgen_test_layout_cbw_BrowserWindowSource() {
const UNINIT: ::std::mem::MaybeUninit<cbw_BrowserWindowSource> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_BrowserWindowSource>(),
24usize,
concat!("Size of: ", stringify!(cbw_BrowserWindowSource))
);
assert_eq!(
::std::mem::align_of::<cbw_BrowserWindowSource>(),
8usize,
concat!("Alignment of ", stringify!(cbw_BrowserWindowSource))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowSource),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_html) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowSource),
"::",
stringify!(is_html)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_BrowserWindow {
pub window: *mut cbw_Window,
pub impl_: cbw_BrowserWindowImpl,
pub events: cbw_BrowserWindowEvents,
}
#[test]
fn bindgen_test_layout_cbw_BrowserWindow() {
const UNINIT: ::std::mem::MaybeUninit<cbw_BrowserWindow> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_BrowserWindow>(),
184usize,
concat!("Size of: ", stringify!(cbw_BrowserWindow))
);
assert_eq!(
::std::mem::align_of::<cbw_BrowserWindow>(),
8usize,
concat!("Alignment of ", stringify!(cbw_BrowserWindow))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindow),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindow),
"::",
stringify!(impl_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).events) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindow),
"::",
stringify!(events)
)
);
}
extern "C" {
#[doc = " Executes the given JavaScript and calls the given callback (on the GUI thread) to provide the result."]
#[link_name = "\u{1}bw_BrowserWindow_evalJs"]
pub fn cbw_BrowserWindow_evalJs(
bw: *mut cbw_BrowserWindow, js: cbw_CStrSlice, callback: cbw_BrowserWindowJsCallbackFn,
cb_data: *mut ::std::os::raw::c_void,
);
}
extern "C" {
#[link_name = "\u{1}bw_BrowserWindow_evalJsThreaded"]
pub fn cbw_BrowserWindow_evalJsThreaded(
bw: *mut cbw_BrowserWindow, js: cbw_CStrSlice, callback: cbw_BrowserWindowJsCallbackFn,
cb_data: *mut ::std::os::raw::c_void,
);
}
extern "C" {
#[link_name = "\u{1}bw_BrowserWindow_free"]
pub fn cbw_BrowserWindow_free(bw: *mut cbw_BrowserWindow);
}
extern "C" {
#[link_name = "\u{1}bw_BrowserWindow_getApp"]
pub fn cbw_BrowserWindow_getApp(bw: *mut cbw_BrowserWindow) -> *mut cbw_Application;
}
extern "C" {
#[link_name = "\u{1}bw_BrowserWindow_getUserData"]
pub fn cbw_BrowserWindow_getUserData(bw: *mut cbw_BrowserWindow)
-> *mut ::std::os::raw::c_void;
}
extern "C" {
#[link_name = "\u{1}bw_BrowserWindow_getUrl"]
pub fn cbw_BrowserWindow_getUrl(bw: *mut cbw_BrowserWindow, url: *mut cbw_StrSlice) -> cBOOL;
}
extern "C" {
#[link_name = "\u{1}bw_BrowserWindow_getWindow"]
pub fn cbw_BrowserWindow_getWindow(bw: *mut cbw_BrowserWindow) -> *mut cbw_Window;
}
extern "C" {
#[link_name = "\u{1}bw_BrowserWindow_navigate"]
pub fn cbw_BrowserWindow_navigate(bw: *mut cbw_BrowserWindow, url: cbw_CStrSlice) -> cbw_Err;
}
extern "C" {
#[doc = " Allocates a browser window and creates the window for it.\n Call `bw_BrowserWindow_create` on it to add the actual browser framework to this window."]
#[link_name = "\u{1}bw_BrowserWindow_new"]
pub fn cbw_BrowserWindow_new(
app: *mut cbw_Application, parent: *const cbw_Window, title: cbw_CStrSlice,
width: ::std::os::raw::c_int, height: ::std::os::raw::c_int,
window_options: *const cbw_WindowOptions,
) -> *mut cbw_BrowserWindow;
}
extern "C" {
#[doc = " Adds the browser framework to the browser window.\n Should be called right after `bw_BrowserWindow_new`."]
#[link_name = "\u{1}bw_BrowserWindow_create"]
pub fn cbw_BrowserWindow_create(
bw: *mut cbw_BrowserWindow, width: ::std::os::raw::c_int, height: ::std::os::raw::c_int,
source: cbw_BrowserWindowSource, browser_window_options: *const cbw_BrowserWindowOptions,
callback: cbw_BrowserWindowCreationCallbackFn, callback_data: *mut ::std::os::raw::c_void,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_CookieImpl {
pub __: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_cbw_CookieImpl() {
const UNINIT: ::std::mem::MaybeUninit<cbw_CookieImpl> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_CookieImpl>(),
8usize,
concat!("Size of: ", stringify!(cbw_CookieImpl))
);
assert_eq!(
::std::mem::align_of::<cbw_CookieImpl>(),
8usize,
concat!("Alignment of ", stringify!(cbw_CookieImpl))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_CookieImpl),
"::",
stringify!(__)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_CookieIteratorImpl {
pub __: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_cbw_CookieIteratorImpl() {
const UNINIT: ::std::mem::MaybeUninit<cbw_CookieIteratorImpl> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_CookieIteratorImpl>(),
8usize,
concat!("Size of: ", stringify!(cbw_CookieIteratorImpl))
);
assert_eq!(
::std::mem::align_of::<cbw_CookieIteratorImpl>(),
8usize,
concat!("Alignment of ", stringify!(cbw_CookieIteratorImpl))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_CookieIteratorImpl),
"::",
stringify!(__)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_CookieJarImpl {
pub __: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_cbw_CookieJarImpl() {
const UNINIT: ::std::mem::MaybeUninit<cbw_CookieJarImpl> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_CookieJarImpl>(),
8usize,
concat!("Size of: ", stringify!(cbw_CookieJarImpl))
);
assert_eq!(
::std::mem::align_of::<cbw_CookieJarImpl>(),
8usize,
concat!("Alignment of ", stringify!(cbw_CookieJarImpl))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_CookieJarImpl),
"::",
stringify!(__)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_Cookie {
pub impl_: cbw_CookieImpl,
}
#[test]
fn bindgen_test_layout_cbw_Cookie() {
const UNINIT: ::std::mem::MaybeUninit<cbw_Cookie> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_Cookie>(),
8usize,
concat!("Size of: ", stringify!(cbw_Cookie))
);
assert_eq!(
::std::mem::align_of::<cbw_Cookie>(),
8usize,
concat!("Alignment of ", stringify!(cbw_Cookie))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_Cookie),
"::",
stringify!(impl_)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_CookieJar {
pub impl_: cbw_CookieJarImpl,
}
#[test]
fn bindgen_test_layout_cbw_CookieJar() {
const UNINIT: ::std::mem::MaybeUninit<cbw_CookieJar> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_CookieJar>(),
8usize,
concat!("Size of: ", stringify!(cbw_CookieJar))
);
assert_eq!(
::std::mem::align_of::<cbw_CookieJar>(),
8usize,
concat!("Alignment of ", stringify!(cbw_CookieJar))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_CookieJar),
"::",
stringify!(impl_)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_CookieIterator {
pub impl_: cbw_CookieIteratorImpl,
}
#[test]
fn bindgen_test_layout_cbw_CookieIterator() {
const UNINIT: ::std::mem::MaybeUninit<cbw_CookieIterator> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cbw_CookieIterator>(),
8usize,
concat!("Size of: ", stringify!(cbw_CookieIterator))
);
assert_eq!(
::std::mem::align_of::<cbw_CookieIterator>(),
8usize,
concat!("Alignment of ", stringify!(cbw_CookieIterator))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_CookieIterator),
"::",
stringify!(impl_)
)
);
}
pub type cbw_CookieJarStorageCallbackFn = ::std::option::Option<
unsafe extern "C" fn(cj: *mut cbw_CookieJar, data: *mut ::std::os::raw::c_void, error: cbw_Err),
>;
pub type cbw_CookieIteratorNextCallbackFn = ::std::option::Option<
unsafe extern "C" fn(
ci: *mut cbw_CookieIterator,
data: *mut ::std::os::raw::c_void,
cookie: *mut cbw_Cookie,
),
>;
pub type cbw_CookieJarDeleteCallbackFn = ::std::option::Option<
unsafe extern "C" fn(
cj: *mut cbw_CookieJar,
data: *mut ::std::os::raw::c_void,
deleted: ::std::os::raw::c_uint,
),
>;
extern "C" {
#[link_name = "\u{1}bw_Cookie_free"]
pub fn cbw_Cookie_free(cookie: *mut cbw_Cookie);
}
extern "C" {
#[link_name = "\u{1}bw_Cookie_new"]
pub fn cbw_Cookie_new(name: cbw_CStrSlice, value: cbw_CStrSlice) -> *mut cbw_Cookie;
}
extern "C" {
#[link_name = "\u{1}bw_Cookie_getCreationTime"]
pub fn cbw_Cookie_getCreationTime(cookie: *const cbw_Cookie) -> u64;
}
extern "C" {
#[link_name = "\u{1}bw_Cookie_setCreationTime"]
pub fn cbw_Cookie_setCreationTime(cookie: *mut cbw_Cookie, time: u64);
}
extern "C" {
#[link_name = "\u{1}bw_Cookie_getDomain"]
pub fn cbw_Cookie_getDomain(cookie: *const cbw_Cookie, domain: *mut cbw_StrSlice) -> cBOOL;
}
extern "C" {
#[link_name = "\u{1}bw_Cookie_setDomain"]
pub fn cbw_Cookie_setDomain(cookie: *mut cbw_Cookie, domain: cbw_CStrSlice);
}
extern "C" {
#[link_name = "\u{1}bw_Cookie_getExpires"]
pub fn cbw_Cookie_getExpires(cookie: *const cbw_Cookie) -> u64;
}
extern "C" {
#[link_name = "\u{1}bw_Cookie_setExpires"]
pub fn cbw_Cookie_setExpires(cookie: *mut cbw_Cookie, time: u64);
}
extern "C" {
#[link_name = "\u{1}bw_Cookie_getName"]
pub fn cbw_Cookie_getName(cookie: *const cbw_Cookie, name: *mut cbw_StrSlice) -> cBOOL;
}
extern "C" {
#[link_name = "\u{1}bw_Cookie_setName"]
pub fn cbw_Cookie_setName(cookie: *mut cbw_Cookie, name: cbw_CStrSlice);
}
extern "C" {
#[link_name = "\u{1}bw_Cookie_getPath"]
pub fn cbw_Cookie_getPath(cookie: *const cbw_Cookie, path: *mut cbw_StrSlice) -> cBOOL;
}
extern "C" {
#[link_name = "\u{1}bw_Cookie_setPath"]
pub fn cbw_Cookie_setPath(cookie: *mut cbw_Cookie, path: cbw_CStrSlice);
}
extern "C" {
#[link_name = "\u{1}bw_Cookie_getValue"]
pub fn cbw_Cookie_getValue(cookie: *const cbw_Cookie, value: *mut cbw_StrSlice) -> cBOOL;
}
extern "C" {
#[link_name = "\u{1}bw_Cookie_setValue"]
pub fn cbw_Cookie_setValue(cookie: *mut cbw_Cookie, value: cbw_CStrSlice);
}
extern "C" {
#[link_name = "\u{1}bw_Cookie_isHttpOnly"]
pub fn cbw_Cookie_isHttpOnly(cookie: *const cbw_Cookie) -> cBOOL;
}
extern "C" {
#[link_name = "\u{1}bw_Cookie_makeHttpOnly"]
pub fn cbw_Cookie_makeHttpOnly(cookie: *mut cbw_Cookie);
}
extern "C" {
#[link_name = "\u{1}bw_Cookie_isSecure"]
pub fn cbw_Cookie_isSecure(cookie: *const cbw_Cookie) -> cBOOL;
}
extern "C" {
#[link_name = "\u{1}bw_Cookie_makeSecure"]
pub fn cbw_Cookie_makeSecure(cookie: *mut cbw_Cookie);
}
extern "C" {
#[link_name = "\u{1}bw_CookieJar_delete"]
pub fn cbw_CookieJar_delete(
jar: *mut cbw_CookieJar, url: cbw_CStrSlice, name: cbw_CStrSlice,
cb: cbw_CookieJarDeleteCallbackFn, cb_data: *mut ::std::os::raw::c_void,
);
}
extern "C" {
#[link_name = "\u{1}bw_CookieJar_free"]
pub fn cbw_CookieJar_free(jar: *mut cbw_CookieJar);
}
extern "C" {
#[link_name = "\u{1}bw_CookieJar_iterator"]
pub fn cbw_CookieJar_iterator(
jar: *mut cbw_CookieJar, iterator: *mut *mut cbw_CookieIterator, include_http_only: cBOOL,
url: cbw_CStrSlice,
);
}
extern "C" {
#[link_name = "\u{1}bw_CookieJar_iteratorAll"]
pub fn cbw_CookieJar_iteratorAll(
jar: *mut cbw_CookieJar, iterator: *mut *mut cbw_CookieIterator,
);
}
extern "C" {
#[link_name = "\u{1}bw_CookieJar_newGlobal"]
pub fn cbw_CookieJar_newGlobal() -> *mut cbw_CookieJar;
}
extern "C" {
#[link_name = "\u{1}bw_CookieJar_store"]
pub fn cbw_CookieJar_store(
jar: *mut cbw_CookieJar, url: cbw_CStrSlice, cookie: *const cbw_Cookie,
cb: cbw_CookieJarStorageCallbackFn, cb_data: *mut ::std::os::raw::c_void,
) -> cbw_Err;
}
extern "C" {
#[link_name = "\u{1}bw_CookieIterator_free"]
pub fn cbw_CookieIterator_free(iterator: *mut cbw_CookieIterator);
}
extern "C" {
#[link_name = "\u{1}bw_CookieIterator_next"]
pub fn cbw_CookieIterator_next(
iterator: *mut cbw_CookieIterator, on_next: cbw_CookieIteratorNextCallbackFn,
cb_data: *mut ::std::os::raw::c_void,
) -> cBOOL;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct c__locale_data {
pub _address: u8,
}
pub type c__builtin_va_list = [c__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct c__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_c__va_list_tag() {
const UNINIT: ::std::mem::MaybeUninit<c__va_list_tag> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<c__va_list_tag>(),
24usize,
concat!("Size of: ", stringify!(c__va_list_tag))
);
assert_eq!(
::std::mem::align_of::<c__va_list_tag>(),
8usize,
concat!("Alignment of ", stringify!(c__va_list_tag))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).gp_offset) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c__va_list_tag),
"::",
stringify!(gp_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fp_offset) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(c__va_list_tag),
"::",
stringify!(fp_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).overflow_arg_area) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(c__va_list_tag),
"::",
stringify!(overflow_arg_area)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reg_save_area) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(c__va_list_tag),
"::",
stringify!(reg_save_area)
)
);
}