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__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_559_COMPLEX__: u32 = 1;
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 = 31;
pub const c_SYS_CDEFS_H: u32 = 1;
pub const c__glibc_c99_flexarr_available: 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__LONG_DOUBLE_USES_FLOAT128: 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_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__ENUM_IDTYPE_T: u32 = 1;
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__TIMESIZE: u32 = 64;
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__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__FD_ZERO_STOS: &'static [u8; 6usize] = b"stosq\0";
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_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: &'static [u8; 5usize] = 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 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 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 csize_t = ::std::os::raw::c_ulong;
pub type cwchar_t = ::std::os::raw::c_int;
pub type cmax_align_t = u128;
#[doc = " A 'string slice'"]
#[doc = " Points to a mutable, non-zero-terminated, UTF-8 encoded string."]
#[doc = " Using rust's string's memory layout."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_StrSlice {
pub len: csize_t,
pub data: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_cbw_StrSlice() {
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::null::<cbw_StrSlice>())).len as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_StrSlice),
"::",
stringify!(len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_StrSlice>())).data as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(cbw_StrSlice),
"::",
stringify!(data)
)
);
}
#[doc = " A 'const string slice'"]
#[doc = " Points to a immutable, non-zero-terminated, UTF-8 encoded string."]
#[doc = " Using rust's string's memory layout."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_CStrSlice {
pub len: csize_t,
pub data: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_cbw_CStrSlice() {
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::null::<cbw_CStrSlice>())).len as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_CStrSlice),
"::",
stringify!(len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_CStrSlice>())).data as *const _ 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);
}
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))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_Application {
pub windows_alive: ::std::os::raw::c_uint,
pub impl_: cbw_ApplicationImpl,
pub engine_impl: cbw_ApplicationEngineImpl,
}
#[test]
fn bindgen_test_layout_cbw_Application() {
assert_eq!(
::std::mem::size_of::<cbw_Application>(),
4usize,
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::null::<cbw_Application>())).windows_alive as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_Application),
"::",
stringify!(windows_alive)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_Application>())).impl_ as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(cbw_Application),
"::",
stringify!(impl_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_Application>())).engine_impl as *const _ as usize },
4usize,
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() {
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::null::<cbw_ApplicationDispatchData>())).func as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_ApplicationDispatchData),
"::",
stringify!(func)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<cbw_ApplicationDispatchData>())).data as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(cbw_ApplicationDispatchData),
"::",
stringify!(data)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_ApplicationSettings {
pub resource_dir: cbw_CStrSlice,
}
#[test]
fn bindgen_test_layout_cbw_ApplicationSettings() {
assert_eq!(
::std::mem::size_of::<cbw_ApplicationSettings>(),
16usize,
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::null::<cbw_ApplicationSettings>())).resource_dir as *const _ as usize
},
0usize,
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."]
#[doc = " 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."]
#[doc = " 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"]
#[doc = " 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,"]
#[doc = " and passes the given data to it."]
#[doc = " This function is thread safe."]
#[doc = ""]
#[doc = " # Returns"]
#[doc = " An indication of whether or not the function was able to be dispatched."]
#[doc = " 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 all application processes and performs necessary clean-up code."]
#[link_name = "\u{1}_bw_Application_finish"]
pub fn cbw_Application_finish(app: *mut cbw_Application);
}
extern "C" {
#[doc = " Frees memory for the application handle."]
#[doc = " Call `bw_Application_finish` before you call this function."]
#[doc = " Freeing the application handle is generally not necessary, as all memory in use by the process gets released anyway after shutdown."]
#[link_name = "\u{1}_bw_Application_free"]
pub fn cbw_Application_free(app: *mut cbw_Application);
}
extern "C" {
#[doc = " Initializes browser window."]
#[doc = " Starts up browser engine process(es)."]
#[doc = " Returns an application handle."]
#[link_name = "\u{1}_bw_Application_initialize"]
pub fn cbw_Application_initialize(
argc: ::std::os::raw::c_int,
argv: *mut *mut ::std::os::raw::c_char,
settings: *const cbw_ApplicationSettings,
) -> *mut cbw_Application;
}
extern "C" {
#[link_name = "\u{1}_bw_Application_isRunning"]
pub fn cbw_Application_isRunning(app: *const cbw_Application) -> cBOOL;
}
extern "C" {
#[doc = " Runs the event loop."]
#[doc = " 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;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbw_BrowserWindowImpl {
pub cef_ptr: *mut ::std::os::raw::c_void,
pub resource_path: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_cbw_BrowserWindowImpl() {
assert_eq!(
::std::mem::size_of::<cbw_BrowserWindowImpl>(),
16usize,
concat!("Size of: ", stringify!(cbw_BrowserWindowImpl))
);
assert_eq!(
::std::mem::align_of::<cbw_BrowserWindowImpl>(),
8usize,
concat!("Alignment of ", stringify!(cbw_BrowserWindowImpl))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_BrowserWindowImpl>())).cef_ptr as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowImpl),
"::",
stringify!(cef_ptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<cbw_BrowserWindowImpl>())).resource_path as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowImpl),
"::",
stringify!(resource_path)
)
);
}
pub const cidtype_t_P_ALL: cidtype_t = 0;
pub const cidtype_t_P_PID: cidtype_t = 1;
pub const cidtype_t_P_PGID: cidtype_t = 2;
pub type cidtype_t = ::std::os::raw::c_uint;
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() {
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::null::<cdiv_t>())).quot as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cdiv_t),
"::",
stringify!(quot)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cdiv_t>())).rem as *const _ 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() {
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::null::<cldiv_t>())).quot as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cldiv_t),
"::",
stringify!(quot)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cldiv_t>())).rem as *const _ 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() {
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::null::<clldiv_t>())).quot as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(clldiv_t),
"::",
stringify!(quot)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<clldiv_t>())).rem as *const _ 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() -> csize_t;
}
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() {
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::null::<c__fsid_t>())).__val as *const _ 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__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 cssize_t = c__ssize_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() {
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::null::<c__sigset_t>())).__val as *const _ 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() {
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::null::<ctimeval>())).tv_sec as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ctimeval),
"::",
stringify!(tv_sec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ctimeval>())).tv_usec as *const _ 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() {
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::null::<ctimespec>())).tv_sec as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ctimespec),
"::",
stringify!(tv_sec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ctimespec>())).tv_nsec as *const _ 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() {
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::null::<cfd_set>())).__fds_bits as *const _ 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(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() {
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::null::<c__pthread_internal_list>())).__prev as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_internal_list),
"::",
stringify!(__prev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c__pthread_internal_list>())).__next as *const _ 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() {
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::null::<c__pthread_internal_slist>())).__next as *const _ 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() {
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::null::<c__pthread_mutex_s>())).__lock as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_mutex_s),
"::",
stringify!(__lock)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c__pthread_mutex_s>())).__count as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_mutex_s),
"::",
stringify!(__count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c__pthread_mutex_s>())).__owner as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_mutex_s),
"::",
stringify!(__owner)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c__pthread_mutex_s>())).__nusers as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_mutex_s),
"::",
stringify!(__nusers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c__pthread_mutex_s>())).__kind as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_mutex_s),
"::",
stringify!(__kind)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c__pthread_mutex_s>())).__spins as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_mutex_s),
"::",
stringify!(__spins)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c__pthread_mutex_s>())).__elision as *const _ as usize },
22usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_mutex_s),
"::",
stringify!(__elision)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c__pthread_mutex_s>())).__list as *const _ 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() {
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::null::<c__pthread_rwlock_arch_t>())).__readers as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_rwlock_arch_t),
"::",
stringify!(__readers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<c__pthread_rwlock_arch_t>())).__writers as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_rwlock_arch_t),
"::",
stringify!(__writers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<c__pthread_rwlock_arch_t>())).__wrphase_futex as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_rwlock_arch_t),
"::",
stringify!(__wrphase_futex)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<c__pthread_rwlock_arch_t>())).__writers_futex as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_rwlock_arch_t),
"::",
stringify!(__writers_futex)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c__pthread_rwlock_arch_t>())).__pad3 as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_rwlock_arch_t),
"::",
stringify!(__pad3)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c__pthread_rwlock_arch_t>())).__pad4 as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_rwlock_arch_t),
"::",
stringify!(__pad4)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<c__pthread_rwlock_arch_t>())).__cur_writer as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_rwlock_arch_t),
"::",
stringify!(__cur_writer)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<c__pthread_rwlock_arch_t>())).__shared as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_rwlock_arch_t),
"::",
stringify!(__shared)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<c__pthread_rwlock_arch_t>())).__rwelision as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_rwlock_arch_t),
"::",
stringify!(__rwelision)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c__pthread_rwlock_arch_t>())).__pad1 as *const _ as usize },
33usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_rwlock_arch_t),
"::",
stringify!(__pad1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c__pthread_rwlock_arch_t>())).__pad2 as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_rwlock_arch_t),
"::",
stringify!(__pad2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<c__pthread_rwlock_arch_t>())).__flags as *const _ 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 __bindgen_anon_1: c__pthread_cond_s__bindgen_ty_1,
pub __bindgen_anon_2: c__pthread_cond_s__bindgen_ty_2,
pub __g_refs: [::std::os::raw::c_uint; 2usize],
pub __g_size: [::std::os::raw::c_uint; 2usize],
pub __g1_orig_size: ::std::os::raw::c_uint,
pub __wrefs: ::std::os::raw::c_uint,
pub __g_signals: [::std::os::raw::c_uint; 2usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union c__pthread_cond_s__bindgen_ty_1 {
pub __wseq: ::std::os::raw::c_ulonglong,
pub __wseq32: c__pthread_cond_s__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct c__pthread_cond_s__bindgen_ty_1__bindgen_ty_1 {
pub __low: ::std::os::raw::c_uint,
pub __high: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_c__pthread_cond_s__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<c__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(c__pthread_cond_s__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<c__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(c__pthread_cond_s__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<c__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>())).__low
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_cond_s__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(__low)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<c__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>())).__high
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_cond_s__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(__high)
)
);
}
#[test]
fn bindgen_test_layout_c__pthread_cond_s__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<c__pthread_cond_s__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(c__pthread_cond_s__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<c__pthread_cond_s__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(c__pthread_cond_s__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<c__pthread_cond_s__bindgen_ty_1>())).__wseq as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_cond_s__bindgen_ty_1),
"::",
stringify!(__wseq)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<c__pthread_cond_s__bindgen_ty_1>())).__wseq32 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_cond_s__bindgen_ty_1),
"::",
stringify!(__wseq32)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union c__pthread_cond_s__bindgen_ty_2 {
pub __g1_start: ::std::os::raw::c_ulonglong,
pub __g1_start32: c__pthread_cond_s__bindgen_ty_2__bindgen_ty_1,
_bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct c__pthread_cond_s__bindgen_ty_2__bindgen_ty_1 {
pub __low: ::std::os::raw::c_uint,
pub __high: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_c__pthread_cond_s__bindgen_ty_2__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<c__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(c__pthread_cond_s__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<c__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(c__pthread_cond_s__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<c__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>())).__low
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_cond_s__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(__low)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<c__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>())).__high
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_cond_s__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(__high)
)
);
}
#[test]
fn bindgen_test_layout_c__pthread_cond_s__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<c__pthread_cond_s__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(c__pthread_cond_s__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<c__pthread_cond_s__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(c__pthread_cond_s__bindgen_ty_2))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<c__pthread_cond_s__bindgen_ty_2>())).__g1_start as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_cond_s__bindgen_ty_2),
"::",
stringify!(__g1_start)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<c__pthread_cond_s__bindgen_ty_2>())).__g1_start32 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_cond_s__bindgen_ty_2),
"::",
stringify!(__g1_start32)
)
);
}
#[test]
fn bindgen_test_layout_c__pthread_cond_s() {
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::null::<c__pthread_cond_s>())).__g_refs as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_cond_s),
"::",
stringify!(__g_refs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c__pthread_cond_s>())).__g_size as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_cond_s),
"::",
stringify!(__g_size)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<c__pthread_cond_s>())).__g1_orig_size as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_cond_s),
"::",
stringify!(__g1_orig_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c__pthread_cond_s>())).__wrefs as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_cond_s),
"::",
stringify!(__wrefs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c__pthread_cond_s>())).__g_signals as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(c__pthread_cond_s),
"::",
stringify!(__g_signals)
)
);
}
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,
_bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout_cpthread_mutexattr_t() {
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::null::<cpthread_mutexattr_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_mutexattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cpthread_mutexattr_t>())).__align as *const _ 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,
_bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout_cpthread_condattr_t() {
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::null::<cpthread_condattr_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_condattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cpthread_condattr_t>())).__align as *const _ 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,
_bindgen_union_align: [u64; 7usize],
}
#[test]
fn bindgen_test_layout_cpthread_attr_t() {
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::null::<cpthread_attr_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_attr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cpthread_attr_t>())).__align as *const _ 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,
_bindgen_union_align: [u64; 5usize],
}
#[test]
fn bindgen_test_layout_cpthread_mutex_t() {
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::null::<cpthread_mutex_t>())).__data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_mutex_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cpthread_mutex_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_mutex_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cpthread_mutex_t>())).__align as *const _ 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,
_bindgen_union_align: [u64; 6usize],
}
#[test]
fn bindgen_test_layout_cpthread_cond_t() {
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::null::<cpthread_cond_t>())).__data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_cond_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cpthread_cond_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_cond_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cpthread_cond_t>())).__align as *const _ 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,
_bindgen_union_align: [u64; 7usize],
}
#[test]
fn bindgen_test_layout_cpthread_rwlock_t() {
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::null::<cpthread_rwlock_t>())).__data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_rwlock_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cpthread_rwlock_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_rwlock_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cpthread_rwlock_t>())).__align as *const _ 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,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_cpthread_rwlockattr_t() {
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::null::<cpthread_rwlockattr_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_rwlockattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cpthread_rwlockattr_t>())).__align as *const _ 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,
_bindgen_union_align: [u64; 4usize],
}
#[test]
fn bindgen_test_layout_cpthread_barrier_t() {
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::null::<cpthread_barrier_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_barrier_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cpthread_barrier_t>())).__align as *const _ 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,
_bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout_cpthread_barrierattr_t() {
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::null::<cpthread_barrierattr_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpthread_barrierattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cpthread_barrierattr_t>())).__align as *const _ 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: csize_t,
) -> *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() {
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::null::<crandom_data>())).fptr as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(crandom_data),
"::",
stringify!(fptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<crandom_data>())).rptr as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(crandom_data),
"::",
stringify!(rptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<crandom_data>())).state as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(crandom_data),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<crandom_data>())).rand_type as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(crandom_data),
"::",
stringify!(rand_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<crandom_data>())).rand_deg as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(crandom_data),
"::",
stringify!(rand_deg)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<crandom_data>())).rand_sep as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(crandom_data),
"::",
stringify!(rand_sep)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<crandom_data>())).end_ptr as *const _ 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: csize_t,
__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() {
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::null::<cdrand48_data>())).__x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cdrand48_data),
"::",
stringify!(__x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cdrand48_data>())).__old_x as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(cdrand48_data),
"::",
stringify!(__old_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cdrand48_data>())).__c as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(cdrand48_data),
"::",
stringify!(__c)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cdrand48_data>())).__init as *const _ as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(cdrand48_data),
"::",
stringify!(__init)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cdrand48_data>())).__a as *const _ 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}_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}_reallocarray"]
pub fn creallocarray(
__ptr: *mut ::std::os::raw::c_void,
__nmemb: csize_t,
__size: csize_t,
) -> *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}_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: csize_t) -> *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: csize_t,
__size: csize_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}_aligned_alloc"]
pub fn caligned_alloc(__alignment: csize_t, __size: csize_t) -> *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: csize_t,
__size: csize_t,
__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: csize_t,
__size: csize_t,
__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: csize_t,
) -> ::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: csize_t,
) -> ::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: csize_t,
) -> ::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: csize_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}_mblen"]
pub fn cmblen(__s: *const ::std::os::raw::c_char, __n: csize_t) -> ::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: csize_t,
) -> ::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: csize_t,
) -> csize_t;
}
extern "C" {
#[link_name = "\u{1}_wcstombs"]
pub fn cwcstombs(
__s: *mut ::std::os::raw::c_char,
__pwcs: *const cwchar_t,
__n: csize_t,
) -> csize_t;
}
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}_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() {
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::null::<c__locale_struct>())).__locales as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c__locale_struct),
"::",
stringify!(__locales)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c__locale_struct>())).__ctype_b as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(c__locale_struct),
"::",
stringify!(__ctype_b)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<c__locale_struct>())).__ctype_tolower as *const _ as usize
},
112usize,
concat!(
"Offset of field: ",
stringify!(c__locale_struct),
"::",
stringify!(__ctype_tolower)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<c__locale_struct>())).__ctype_toupper as *const _ as usize
},
120usize,
concat!(
"Offset of field: ",
stringify!(c__locale_struct),
"::",
stringify!(__ctype_toupper)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c__locale_struct>())).__names as *const _ 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: csize_t,
__l: clocale_t,
) -> csize_t;
}
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: csize_t) -> csize_t;
}
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: csize_t,
) -> ::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: csize_t,
);
}
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: csize_t,
__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: csize_t);
}
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: csize_t,
) -> *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() {
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::null::<cbw_Err>())).code as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_Err),
"::",
stringify!(code)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_Err>())).data as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(cbw_Err),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_Err>())).alloc_message as *const _ 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}___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_int,
pub __wchb: [::std::os::raw::c_char; 4usize],
_bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout_c__mbstate_t__bindgen_ty_1() {
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::null::<c__mbstate_t__bindgen_ty_1>())).__wch as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(c__mbstate_t__bindgen_ty_1),
"::",
stringify!(__wch)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<c__mbstate_t__bindgen_ty_1>())).__wchb as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(c__mbstate_t__bindgen_ty_1),
"::",
stringify!(__wchb)
)
);
}
#[test]
fn bindgen_test_layout_c__mbstate_t() {
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::null::<c__mbstate_t>())).__count as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c__mbstate_t),
"::",
stringify!(__count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c__mbstate_t>())).__value as *const _ 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() {
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::null::<c_G_fpos_t>())).__pos as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c_G_fpos_t),
"::",
stringify!(__pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_G_fpos_t>())).__state as *const _ 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() {
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::null::<c_G_fpos64_t>())).__pos as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c_G_fpos64_t),
"::",
stringify!(__pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_G_fpos64_t>())).__state as *const _ 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: csize_t,
pub _mode: ::std::os::raw::c_int,
pub _unused2: [::std::os::raw::c_char; 20usize],
}
#[test]
fn bindgen_test_layout_c_IO_FILE() {
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::null::<c_IO_FILE>()))._flags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._IO_read_ptr as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_read_ptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._IO_read_end as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_read_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._IO_read_base as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_read_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._IO_write_base as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_write_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._IO_write_ptr as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_write_ptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._IO_write_end as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_write_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._IO_buf_base as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_buf_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._IO_buf_end as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_buf_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._IO_save_base as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_save_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._IO_backup_base as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_backup_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._IO_save_end as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_IO_save_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._markers as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_markers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._chain as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_chain)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._fileno as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_fileno)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._flags2 as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_flags2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._old_offset as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_old_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._cur_column as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_cur_column)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._vtable_offset as *const _ as usize },
130usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_vtable_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._shortbuf as *const _ as usize },
131usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_shortbuf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._lock as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_lock)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._offset as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._codecvt as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_codecvt)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._wide_data as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_wide_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._freeres_list as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_freeres_list)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._freeres_buf as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_freeres_buf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>())).__pad5 as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(__pad5)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._mode as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(c_IO_FILE),
"::",
stringify!(_mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c_IO_FILE>()))._unused2 as *const _ 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}_tmpfile"]
pub fn ctmpfile() -> *mut cFILE;
}
extern "C" {
#[link_name = "\u{1}_tmpnam"]
pub fn ctmpnam(__s: *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}_fclose"]
pub fn cfclose(__stream: *mut cFILE) -> ::std::os::raw::c_int;
}
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: csize_t,
__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 csize_t,
) -> *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: csize_t,
) -> ::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: csize_t);
}
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 csize_t,
__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 csize_t,
__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 csize_t,
__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: csize_t,
__n: csize_t,
__stream: *mut cFILE,
) -> csize_t;
}
extern "C" {
#[link_name = "\u{1}_fwrite_unlocked"]
pub fn cfwrite_unlocked(
__ptr: *const ::std::os::raw::c_void,
__size: csize_t,
__n: csize_t,
__stream: *mut cFILE,
) -> csize_t;
}
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}_sys_nerr"]
pub static mut csys_nerr: ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}_sys_errlist"]
pub static mut csys_errlist: [*const ::std::os::raw::c_char; 0usize];
}
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}_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}_pclose"]
pub fn cpclose(__stream: *mut cFILE) -> ::std::os::raw::c_int;
}
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;
}
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_Dims2D {
pub width: u16,
pub height: u16,
}
#[test]
fn bindgen_test_layout_cbw_Dims2D() {
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::null::<cbw_Dims2D>())).width as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_Dims2D),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_Dims2D>())).height as *const _ 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() {
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::null::<cbw_Pos2D>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_Pos2D),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_Pos2D>())).y as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(cbw_Pos2D),
"::",
stringify!(y)
)
);
}
#[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_WindowCallbacks {
#[doc = " Fired just before the window gets destroyed and freed from memory."]
#[doc = " Should be implemented to free the user data provided to the window."]
pub do_cleanup: ::std::option::Option<unsafe extern "C" fn(arg1: *mut cbw_Window)>,
#[doc = " Fired when the window has been closed, either by the user or programmatically."]
pub on_close: ::std::option::Option<unsafe extern "C" fn(arg1: *const cbw_Window)>,
#[doc = " Fired when a window has finished loading"]
pub on_loaded: ::std::option::Option<unsafe extern "C" fn(arg1: *const cbw_Window)>,
#[doc = " Fired when a window is resizing"]
pub on_resize: ::std::option::Option<
unsafe extern "C" fn(
arg1: *const cbw_Window,
width: ::std::os::raw::c_uint,
height: ::std::os::raw::c_uint,
),
>,
}
#[test]
fn bindgen_test_layout_cbw_WindowCallbacks() {
assert_eq!(
::std::mem::size_of::<cbw_WindowCallbacks>(),
32usize,
concat!("Size of: ", stringify!(cbw_WindowCallbacks))
);
assert_eq!(
::std::mem::align_of::<cbw_WindowCallbacks>(),
8usize,
concat!("Alignment of ", stringify!(cbw_WindowCallbacks))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_WindowCallbacks>())).do_cleanup as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_WindowCallbacks),
"::",
stringify!(do_cleanup)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_WindowCallbacks>())).on_close as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(cbw_WindowCallbacks),
"::",
stringify!(on_close)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_WindowCallbacks>())).on_loaded as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(cbw_WindowCallbacks),
"::",
stringify!(on_loaded)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_WindowCallbacks>())).on_resize as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(cbw_WindowCallbacks),
"::",
stringify!(on_resize)
)
);
}
#[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() {
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::null::<cbw_WindowOptions>())).borders as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_WindowOptions),
"::",
stringify!(borders)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_WindowOptions>())).minimizable as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(cbw_WindowOptions),
"::",
stringify!(minimizable)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_WindowOptions>())).resizable as *const _ 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_Window {
pub app: *mut cbw_Application,
pub parent: *const cbw_Window,
pub closed: bool,
pub dropped: bool,
pub callbacks: cbw_WindowCallbacks,
pub user_data: *mut ::std::os::raw::c_void,
pub impl_: cbw_WindowImpl,
}
#[test]
fn bindgen_test_layout_cbw_Window() {
assert_eq!(
::std::mem::size_of::<cbw_Window>(),
64usize,
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::null::<cbw_Window>())).app as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_Window),
"::",
stringify!(app)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_Window>())).parent as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(cbw_Window),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_Window>())).closed as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(cbw_Window),
"::",
stringify!(closed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_Window>())).dropped as *const _ as usize },
17usize,
concat!(
"Offset of field: ",
stringify!(cbw_Window),
"::",
stringify!(dropped)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_Window>())).callbacks as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(cbw_Window),
"::",
stringify!(callbacks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_Window>())).user_data as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(cbw_Window),
"::",
stringify!(user_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_Window>())).impl_ as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(cbw_Window),
"::",
stringify!(impl_)
)
);
}
extern "C" {
#[doc = " Destroy the window, releasing all resources it holds."]
#[doc = " After this call, the handle is considered invalid."]
#[link_name = "\u{1}_bw_Window_destroy"]
pub fn cbw_Window_destroy(window: *mut cbw_Window);
}
extern "C" {
#[doc = " Invalidates the window handle."]
#[doc = " The window will get destroyed when it is deemed possible."]
#[link_name = "\u{1}_bw_Window_drop"]
pub fn cbw_Window_drop(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."]
#[doc = " 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: cbw_StrSlice) -> csize_t;
}
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."]
#[doc = " `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"]
#[doc = " The returned pointer is a handler for the window."]
#[doc = " bw_Window_drop needs to be called on it after it is done being used,"]
#[doc = " 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,
user_data: *mut ::std::os::raw::c_void,
) -> *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" {
#[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"]
#[doc = " 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: csize_t,
),
>;
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_BrowserWindowOptions {
pub dev_tools: bool,
pub resource_path: cbw_CStrSlice,
}
#[test]
fn bindgen_test_layout_cbw_BrowserWindowOptions() {
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::null::<cbw_BrowserWindowOptions>())).dev_tools as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowOptions),
"::",
stringify!(dev_tools)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<cbw_BrowserWindowOptions>())).resource_path as *const _ 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: bool,
}
#[test]
fn bindgen_test_layout_cbw_BrowserWindowSource() {
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::null::<cbw_BrowserWindowSource>())).data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindowSource),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_BrowserWindowSource>())).is_html as *const _ 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 external_handler: cbw_BrowserWindowHandlerFn,
pub user_data: *mut ::std::os::raw::c_void,
pub impl_: cbw_BrowserWindowImpl,
}
#[test]
fn bindgen_test_layout_cbw_BrowserWindow() {
assert_eq!(
::std::mem::size_of::<cbw_BrowserWindow>(),
40usize,
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::null::<cbw_BrowserWindow>())).window as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindow),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<cbw_BrowserWindow>())).external_handler as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindow),
"::",
stringify!(external_handler)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_BrowserWindow>())).user_data as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindow),
"::",
stringify!(user_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<cbw_BrowserWindow>())).impl_ as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(cbw_BrowserWindow),
"::",
stringify!(impl_)
)
);
}
extern "C" {
#[link_name = "\u{1}_bw_BrowserWindow_destroy"]
pub fn cbw_BrowserWindow_destroy(bw: *mut cbw_BrowserWindow);
}
extern "C" {
#[doc = " Marks the browser window handle as not being used anymore."]
#[doc = " This makes it so that if and when the window gets closed, everything is freed and cleaned from memory."]
#[doc = " This function can be called from any thread so it needs to be thread safe."]
#[link_name = "\u{1}_bw_BrowserWindow_drop"]
pub fn cbw_BrowserWindow_drop(bw: *mut cbw_BrowserWindow);
}
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_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_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 = " Creates a new browser window"]
#[link_name = "\u{1}_bw_BrowserWindow_new"]
pub fn cbw_BrowserWindow_new(
app: *mut cbw_Application,
parent: *const cbw_Window,
source: cbw_BrowserWindowSource,
_title: cbw_CStrSlice,
width: ::std::os::raw::c_int,
height: ::std::os::raw::c_int,
window_options: *const cbw_WindowOptions,
browser_window_options: *const cbw_BrowserWindowOptions,
handler: cbw_BrowserWindowHandlerFn,
user_data: *mut ::std::os::raw::c_void,
callback: cbw_BrowserWindowCreationCallbackFn,
callback_data: *mut ::std::os::raw::c_void,
);
}
#[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() {
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::null::<c__va_list_tag>())).gp_offset as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(c__va_list_tag),
"::",
stringify!(gp_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c__va_list_tag>())).fp_offset as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(c__va_list_tag),
"::",
stringify!(fp_offset)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<c__va_list_tag>())).overflow_arg_area as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(c__va_list_tag),
"::",
stringify!(overflow_arg_area)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<c__va_list_tag>())).reg_save_area as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(c__va_list_tag),
"::",
stringify!(reg_save_area)
)
);
}