#[repr(C)]
pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
impl<T> __BindgenUnionField<T> {
#[inline]
pub const fn new() -> Self {
__BindgenUnionField(::std::marker::PhantomData)
}
#[inline]
#[allow(clippy::transmute_ptr_to_ptr)]
pub unsafe fn as_ref(&self) -> &T {
::std::mem::transmute(self)
}
#[inline]
#[allow(clippy::transmute_ptr_to_ptr)]
pub unsafe fn as_mut(&mut self) -> &mut T {
::std::mem::transmute(self)
}
}
impl<T> ::std::default::Default for __BindgenUnionField<T> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
#[inline]
fn clone(&self) -> Self {
Self::new()
}
}
impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
fmt.write_str("__BindgenUnionField")
}
}
impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
}
impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
true
}
}
impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
pub const _STL_COMPILER_PREPROCESSOR: u32 = 1;
pub const _VCRT_COMPILER_PREPROCESSOR: u32 = 1;
pub const _SAL_VERSION: u32 = 20;
pub const __SAL_H_VERSION: u32 = 180000000;
pub const _USE_DECLSPECS_FOR_SAL: u32 = 0;
pub const _USE_ATTRIBUTES_FOR_SAL: u32 = 0;
pub const _CRT_PACKING: u32 = 8;
pub const _HAS_EXCEPTIONS: u32 = 1;
pub const NULL: u32 = 0;
pub const _HAS_CXX17: u32 = 0;
pub const _HAS_CXX20: u32 = 0;
pub const _HAS_NODISCARD: u32 = 1;
pub const _STL_WARNING_LEVEL: u32 = 3;
pub const _HAS_IF_CONSTEXPR: u32 = 1;
pub const _HAS_CONDITIONAL_EXPLICIT: u32 = 1;
pub const _STL_DISABLED_WARNING_C4984: u32 = 4984;
pub const _STL_DISABLED_WARNING_C5053: u32 = 5053;
pub const _CPPLIB_VER: u32 = 650;
pub const _MSVC_STL_VERSION: u32 = 142;
pub const _MSVC_STL_UPDATE: u32 = 202005;
pub const _HAS_STATIC_RTTI: u32 = 1;
pub const _HAS_STD_BYTE: u32 = 0;
pub const _ENFORCE_MATCHING_ALLOCATORS: u32 = 0;
pub const _ENFORCE_FACET_SPECIALIZATIONS: u32 = 0;
pub const _FACET_SPECIALIZATION_MESSAGE : &[ u8 ; 183usize ] = b"Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 to suppress this diagnostic.\0" ;
pub const _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS: u32 = 1;
pub const _STD_VECTORIZE_WITH_FLOAT_CONTROL: u32 = 1;
pub const __cpp_lib_chrono_udls: u32 = 201304;
pub const __cpp_lib_complex_udls: u32 = 201309;
pub const __cpp_lib_exchange_function: u32 = 201304;
pub const __cpp_lib_generic_associative_lookup: u32 = 201304;
pub const __cpp_lib_integer_sequence: u32 = 201304;
pub const __cpp_lib_integral_constant_callable: u32 = 201304;
pub const __cpp_lib_is_final: u32 = 201402;
pub const __cpp_lib_is_null_pointer: u32 = 201309;
pub const __cpp_lib_make_reverse_iterator: u32 = 201402;
pub const __cpp_lib_make_unique: u32 = 201304;
pub const __cpp_lib_null_iterators: u32 = 201304;
pub const __cpp_lib_quoted_string_io: u32 = 201304;
pub const __cpp_lib_result_of_sfinae: u32 = 201210;
pub const __cpp_lib_robust_nonmodifying_seq_ops: u32 = 201304;
pub const __cpp_lib_shared_timed_mutex: u32 = 201402;
pub const __cpp_lib_string_udls: u32 = 201304;
pub const __cpp_lib_transformation_trait_aliases: u32 = 201304;
pub const __cpp_lib_tuple_element_t: u32 = 201402;
pub const __cpp_lib_tuples_by_type: u32 = 201304;
pub const __cpp_lib_addressof_constexpr: u32 = 201603;
pub const __cpp_lib_allocator_traits_is_always_equal: u32 = 201411;
pub const __cpp_lib_as_const: u32 = 201510;
pub const __cpp_lib_bool_constant: u32 = 201505;
pub const __cpp_lib_enable_shared_from_this: u32 = 201603;
pub const __cpp_lib_incomplete_container_elements: u32 = 201505;
pub const __cpp_lib_invoke: u32 = 201411;
pub const __cpp_lib_logical_traits: u32 = 201510;
pub const __cpp_lib_map_try_emplace: u32 = 201411;
pub const __cpp_lib_nonmember_container_access: u32 = 201411;
pub const __cpp_lib_shared_mutex: u32 = 201505;
pub const __cpp_lib_transparent_operators: u32 = 201510;
pub const __cpp_lib_type_trait_variable_templates: u32 = 201510;
pub const __cpp_lib_uncaught_exceptions: u32 = 201411;
pub const __cpp_lib_unordered_map_try_emplace: u32 = 201411;
pub const __cpp_lib_void_t: u32 = 201411;
pub const __cpp_lib_chrono: u32 = 201510;
pub const __cpp_lib_atomic_value_initialization: u32 = 201911;
pub const __cpp_lib_shared_ptr_arrays: u32 = 201611;
pub const __cpp_lib_experimental_erase_if: u32 = 201411;
pub const __cpp_lib_experimental_filesystem: u32 = 201406;
pub const _ARGMAX: u32 = 100;
pub const _CRT_INT_MAX: u32 = 2147483647;
pub const _CRT_FUNCTIONS_REQUIRED: u32 = 1;
pub const _CRT_HAS_CXX17: u32 = 0;
pub const _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE: u32 = 1;
pub const _CRT_BUILD_DESKTOP_APP: u32 = 1;
pub const _CRT_INTERNAL_NONSTDC_NAMES: u32 = 1;
pub const __STDC_SECURE_LIB__: u32 = 200411;
pub const __GOT_SECURE_LIB__: u32 = 200411;
pub const __STDC_WANT_SECURE_LIB__: u32 = 1;
pub const _SECURECRT_FILL_BUFFER_PATTERN: u32 = 254;
pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES: u32 = 0;
pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT: u32 = 0;
pub const _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES: u32 = 1;
pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY: u32 = 0;
pub const _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY: u32 = 0;
pub const _CRT_WARN: u32 = 0;
pub const _CRT_ERROR: u32 = 1;
pub const _CRT_ASSERT: u32 = 2;
pub const _CRT_ERRCNT: u32 = 3;
pub const _CRTDBG_MODE_FILE: u32 = 1;
pub const _CRTDBG_MODE_DEBUG: u32 = 2;
pub const _CRTDBG_MODE_WNDW: u32 = 4;
pub const _CRTDBG_REPORT_MODE: i32 = -1;
pub const _CRT_RPTHOOK_INSTALL: u32 = 0;
pub const _CRT_RPTHOOK_REMOVE: u32 = 1;
pub const _HOOK_ALLOC: u32 = 1;
pub const _HOOK_REALLOC: u32 = 2;
pub const _HOOK_FREE: u32 = 3;
pub const _CRTDBG_ALLOC_MEM_DF: u32 = 1;
pub const _CRTDBG_DELAY_FREE_MEM_DF: u32 = 2;
pub const _CRTDBG_CHECK_ALWAYS_DF: u32 = 4;
pub const _CRTDBG_RESERVED_DF: u32 = 8;
pub const _CRTDBG_CHECK_CRT_DF: u32 = 16;
pub const _CRTDBG_LEAK_CHECK_DF: u32 = 32;
pub const _CRTDBG_CHECK_EVERY_16_DF: u32 = 1048576;
pub const _CRTDBG_CHECK_EVERY_128_DF: u32 = 8388608;
pub const _CRTDBG_CHECK_EVERY_1024_DF: u32 = 67108864;
pub const _CRTDBG_CHECK_DEFAULT_DF: u32 = 0;
pub const _CRTDBG_REPORT_FLAG: i32 = -1;
pub const _FREE_BLOCK: u32 = 0;
pub const _NORMAL_BLOCK: u32 = 1;
pub const _CRT_BLOCK: u32 = 2;
pub const _IGNORE_BLOCK: u32 = 3;
pub const _CLIENT_BLOCK: u32 = 4;
pub const _MAX_BLOCKS: u32 = 5;
pub const _UNKNOWN_BLOCK: i32 = -1;
pub const _CRT_MSVCP_CURRENT: &[u8; 13usize] = b"msvcp140.dll\0";
pub const _HAS_ITERATOR_DEBUGGING: u32 = 0;
pub const _SECURE_SCL: u32 = 0;
pub const _ITERATOR_DEBUG_LEVEL: u32 = 0;
pub const _CONTAINER_DEBUG_LEVEL: u32 = 0;
pub const _DEBUG_AFFIX: &[u8; 1usize] = b"\0";
pub const _IDL_DEFAULT: u32 = 0;
pub const _LIB_STEM: &[u8; 8usize] = b"libcpmt\0";
pub const _IDL_AFFIX: &[u8; 1usize] = b"\0";
pub const _MAX_EXP_DIG: u32 = 8;
pub const _MAX_INT_DIG: u32 = 32;
pub const _MAX_SIG_DIG_V1: u32 = 36;
pub const _MAX_SIG_DIG_V2: u32 = 768;
pub const _LOCK_LOCALE: u32 = 0;
pub const _LOCK_MALLOC: u32 = 1;
pub const _LOCK_STREAM: u32 = 2;
pub const _LOCK_DEBUG: u32 = 3;
pub const _LOCK_AT_THREAD_EXIT: u32 = 4;
pub const _DOMAIN: u32 = 1;
pub const _SING: u32 = 2;
pub const _OVERFLOW: u32 = 3;
pub const _UNDERFLOW: u32 = 4;
pub const _TLOSS: u32 = 5;
pub const _PLOSS: u32 = 6;
pub const _HUGE_ENUF : f64 = 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 ;
pub const _DENORM: i32 = -2;
pub const _FINITE: i32 = -1;
pub const _INFCODE: u32 = 1;
pub const _NANCODE: u32 = 2;
pub const FP_INFINITE: u32 = 1;
pub const FP_NAN: u32 = 2;
pub const FP_NORMAL: i32 = -1;
pub const FP_SUBNORMAL: i32 = -2;
pub const FP_ZERO: u32 = 0;
pub const _C2: u32 = 1;
pub const FP_ILOGB0: i32 = -2147483648;
pub const FP_ILOGBNAN: u32 = 2147483647;
pub const MATH_ERRNO: u32 = 1;
pub const MATH_ERREXCEPT: u32 = 2;
pub const math_errhandling: u32 = 3;
pub const _FE_DIVBYZERO: u32 = 4;
pub const _FE_INEXACT: u32 = 32;
pub const _FE_INVALID: u32 = 1;
pub const _FE_OVERFLOW: u32 = 8;
pub const _FE_UNDERFLOW: u32 = 16;
pub const _D0_C: u32 = 3;
pub const _D1_C: u32 = 2;
pub const _D2_C: u32 = 1;
pub const _D3_C: u32 = 0;
pub const _DBIAS: u32 = 1022;
pub const _DOFF: u32 = 4;
pub const _F0_C: u32 = 1;
pub const _F1_C: u32 = 0;
pub const _FBIAS: u32 = 126;
pub const _FOFF: u32 = 7;
pub const _FRND: u32 = 1;
pub const _L0_C: u32 = 3;
pub const _L1_C: u32 = 2;
pub const _L2_C: u32 = 1;
pub const _L3_C: u32 = 0;
pub const _LBIAS: u32 = 1022;
pub const _LOFF: u32 = 4;
pub const _FP_LT: u32 = 1;
pub const _FP_EQ: u32 = 2;
pub const _FP_GT: u32 = 4;
pub const DOMAIN: u32 = 1;
pub const SING: u32 = 2;
pub const OVERFLOW: u32 = 3;
pub const UNDERFLOW: u32 = 4;
pub const TLOSS: u32 = 5;
pub const PLOSS: u32 = 6;
pub const _MAX_ITOSTR_BASE16_COUNT: u32 = 9;
pub const _MAX_ITOSTR_BASE10_COUNT: u32 = 12;
pub const _MAX_ITOSTR_BASE8_COUNT: u32 = 12;
pub const _MAX_ITOSTR_BASE2_COUNT: u32 = 33;
pub const _MAX_LTOSTR_BASE16_COUNT: u32 = 9;
pub const _MAX_LTOSTR_BASE10_COUNT: u32 = 12;
pub const _MAX_LTOSTR_BASE8_COUNT: u32 = 12;
pub const _MAX_LTOSTR_BASE2_COUNT: u32 = 33;
pub const _MAX_ULTOSTR_BASE16_COUNT: u32 = 9;
pub const _MAX_ULTOSTR_BASE10_COUNT: u32 = 11;
pub const _MAX_ULTOSTR_BASE8_COUNT: u32 = 12;
pub const _MAX_ULTOSTR_BASE2_COUNT: u32 = 33;
pub const _MAX_I64TOSTR_BASE16_COUNT: u32 = 17;
pub const _MAX_I64TOSTR_BASE10_COUNT: u32 = 21;
pub const _MAX_I64TOSTR_BASE8_COUNT: u32 = 23;
pub const _MAX_I64TOSTR_BASE2_COUNT: u32 = 65;
pub const _MAX_U64TOSTR_BASE16_COUNT: u32 = 17;
pub const _MAX_U64TOSTR_BASE10_COUNT: u32 = 21;
pub const _MAX_U64TOSTR_BASE8_COUNT: u32 = 23;
pub const _MAX_U64TOSTR_BASE2_COUNT: u32 = 65;
pub const CHAR_BIT: u32 = 8;
pub const SCHAR_MIN: i32 = -128;
pub const SCHAR_MAX: u32 = 127;
pub const UCHAR_MAX: u32 = 255;
pub const CHAR_MIN: i32 = -128;
pub const CHAR_MAX: u32 = 127;
pub const MB_LEN_MAX: u32 = 5;
pub const SHRT_MIN: i32 = -32768;
pub const SHRT_MAX: u32 = 32767;
pub const USHRT_MAX: u32 = 65535;
pub const INT_MIN: i32 = -2147483648;
pub const INT_MAX: u32 = 2147483647;
pub const UINT_MAX: u32 = 4294967295;
pub const LONG_MIN: i32 = -2147483648;
pub const LONG_MAX: u32 = 2147483647;
pub const ULONG_MAX: u32 = 4294967295;
pub const EXIT_SUCCESS: u32 = 0;
pub const EXIT_FAILURE: u32 = 1;
pub const _WRITE_ABORT_MSG: u32 = 1;
pub const _CALL_REPORTFAULT: u32 = 2;
pub const _OUT_TO_DEFAULT: u32 = 0;
pub const _OUT_TO_STDERR: u32 = 1;
pub const _OUT_TO_MSGBOX: u32 = 2;
pub const _REPORT_ERRMODE: u32 = 3;
pub const RAND_MAX: u32 = 32767;
pub const _CVTBUFSIZE: u32 = 349;
pub const _MAX_PATH: u32 = 260;
pub const _MAX_DRIVE: u32 = 3;
pub const _MAX_DIR: u32 = 256;
pub const _MAX_FNAME: u32 = 256;
pub const _MAX_EXT: u32 = 256;
pub const _MAX_ENV: u32 = 32767;
pub const _HEAP_MAXREQ: i32 = -32;
pub const _HEAPEMPTY: i32 = -1;
pub const _HEAPOK: i32 = -2;
pub const _HEAPBADBEGIN: i32 = -3;
pub const _HEAPBADNODE: i32 = -4;
pub const _HEAPEND: i32 = -5;
pub const _HEAPBADPTR: i32 = -6;
pub const _FREEENTRY: u32 = 0;
pub const _USEDENTRY: u32 = 1;
pub const _ALLOCA_S_THRESHOLD: u32 = 1024;
pub const _ALLOCA_S_STACK_MARKER: u32 = 52428;
pub const _ALLOCA_S_HEAP_MARKER: u32 = 56797;
pub const _ALLOCA_S_MARKER_SIZE: u32 = 16;
pub const _CRT_INTERNAL_STDIO_SYMBOL_PREFIX: &[u8; 1usize] = b"\0";
pub const _CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION: u32 = 1;
pub const _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR: u32 = 2;
pub const _CRT_INTERNAL_PRINTF_LEGACY_WIDE_SPECIFIERS: u32 = 4;
pub const _CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY: u32 = 8;
pub const _CRT_INTERNAL_PRINTF_LEGACY_THREE_DIGIT_EXPONENTS: u32 = 16;
pub const _CRT_INTERNAL_PRINTF_STANDARD_ROUNDING: u32 = 32;
pub const _CRT_INTERNAL_SCANF_SECURECRT: u32 = 1;
pub const _CRT_INTERNAL_SCANF_LEGACY_WIDE_SPECIFIERS: u32 = 2;
pub const _CRT_INTERNAL_SCANF_LEGACY_MSVCRT_COMPATIBILITY: u32 = 4;
pub const BUFSIZ: u32 = 512;
pub const _NSTREAM_: u32 = 512;
pub const _IOB_ENTRIES: u32 = 3;
pub const EOF: i32 = -1;
pub const _IOFBF: u32 = 0;
pub const _IOLBF: u32 = 64;
pub const _IONBF: u32 = 4;
pub const L_tmpnam: u32 = 260;
pub const L_tmpnam_s: u32 = 260;
pub const SEEK_CUR: u32 = 1;
pub const SEEK_END: u32 = 2;
pub const SEEK_SET: u32 = 0;
pub const FILENAME_MAX: u32 = 260;
pub const FOPEN_MAX: u32 = 20;
pub const _SYS_OPEN: u32 = 20;
pub const TMP_MAX: u32 = 2147483647;
pub const TMP_MAX_S: u32 = 2147483647;
pub const _TMP_MAX_S: u32 = 2147483647;
pub const SYS_OPEN: u32 = 20;
pub const EPERM: u32 = 1;
pub const ENOENT: u32 = 2;
pub const ESRCH: u32 = 3;
pub const EINTR: u32 = 4;
pub const EIO: u32 = 5;
pub const ENXIO: u32 = 6;
pub const E2BIG: u32 = 7;
pub const ENOEXEC: u32 = 8;
pub const EBADF: u32 = 9;
pub const ECHILD: u32 = 10;
pub const EAGAIN: u32 = 11;
pub const ENOMEM: u32 = 12;
pub const EACCES: u32 = 13;
pub const EFAULT: u32 = 14;
pub const EBUSY: u32 = 16;
pub const EEXIST: u32 = 17;
pub const EXDEV: u32 = 18;
pub const ENODEV: u32 = 19;
pub const ENOTDIR: u32 = 20;
pub const EISDIR: u32 = 21;
pub const ENFILE: u32 = 23;
pub const EMFILE: u32 = 24;
pub const ENOTTY: u32 = 25;
pub const EFBIG: u32 = 27;
pub const ENOSPC: u32 = 28;
pub const ESPIPE: u32 = 29;
pub const EROFS: u32 = 30;
pub const EMLINK: u32 = 31;
pub const EPIPE: u32 = 32;
pub const EDOM: u32 = 33;
pub const EDEADLK: u32 = 36;
pub const ENAMETOOLONG: u32 = 38;
pub const ENOLCK: u32 = 39;
pub const ENOSYS: u32 = 40;
pub const ENOTEMPTY: u32 = 41;
pub const EINVAL: u32 = 22;
pub const ERANGE: u32 = 34;
pub const EILSEQ: u32 = 42;
pub const STRUNCATE: u32 = 80;
pub const EDEADLOCK: u32 = 36;
pub const EADDRINUSE: u32 = 100;
pub const EADDRNOTAVAIL: u32 = 101;
pub const EAFNOSUPPORT: u32 = 102;
pub const EALREADY: u32 = 103;
pub const EBADMSG: u32 = 104;
pub const ECANCELED: u32 = 105;
pub const ECONNABORTED: u32 = 106;
pub const ECONNREFUSED: u32 = 107;
pub const ECONNRESET: u32 = 108;
pub const EDESTADDRREQ: u32 = 109;
pub const EHOSTUNREACH: u32 = 110;
pub const EIDRM: u32 = 111;
pub const EINPROGRESS: u32 = 112;
pub const EISCONN: u32 = 113;
pub const ELOOP: u32 = 114;
pub const EMSGSIZE: u32 = 115;
pub const ENETDOWN: u32 = 116;
pub const ENETRESET: u32 = 117;
pub const ENETUNREACH: u32 = 118;
pub const ENOBUFS: u32 = 119;
pub const ENODATA: u32 = 120;
pub const ENOLINK: u32 = 121;
pub const ENOMSG: u32 = 122;
pub const ENOPROTOOPT: u32 = 123;
pub const ENOSR: u32 = 124;
pub const ENOSTR: u32 = 125;
pub const ENOTCONN: u32 = 126;
pub const ENOTRECOVERABLE: u32 = 127;
pub const ENOTSOCK: u32 = 128;
pub const ENOTSUP: u32 = 129;
pub const EOPNOTSUPP: u32 = 130;
pub const EOTHER: u32 = 131;
pub const EOVERFLOW: u32 = 132;
pub const EOWNERDEAD: u32 = 133;
pub const EPROTO: u32 = 134;
pub const EPROTONOSUPPORT: u32 = 135;
pub const EPROTOTYPE: u32 = 136;
pub const ETIME: u32 = 137;
pub const ETIMEDOUT: u32 = 138;
pub const ETXTBSY: u32 = 139;
pub const EWOULDBLOCK: u32 = 140;
pub const _NLSCMPERROR: u32 = 2147483647;
pub const _UPPER: u32 = 1;
pub const _LOWER: u32 = 2;
pub const _DIGIT: u32 = 4;
pub const _SPACE: u32 = 8;
pub const _PUNCT: u32 = 16;
pub const _CONTROL: u32 = 32;
pub const _BLANK: u32 = 64;
pub const _HEX: u32 = 128;
pub const _LEADBYTE: u32 = 32768;
pub const _ALPHA: u32 = 259;
pub const _SH_DENYRW: u32 = 16;
pub const _SH_DENYWR: u32 = 32;
pub const _SH_DENYRD: u32 = 48;
pub const _SH_DENYNO: u32 = 64;
pub const _SH_SECURE: u32 = 128;
pub const SH_DENYRW: u32 = 16;
pub const SH_DENYWR: u32 = 32;
pub const SH_DENYRD: u32 = 48;
pub const SH_DENYNO: u32 = 64;
pub const _S_IFMT: u32 = 61440;
pub const _S_IFDIR: u32 = 16384;
pub const _S_IFCHR: u32 = 8192;
pub const _S_IFIFO: u32 = 4096;
pub const _S_IFREG: u32 = 32768;
pub const _S_IREAD: u32 = 256;
pub const _S_IWRITE: u32 = 128;
pub const _S_IEXEC: u32 = 64;
pub const S_IFMT: u32 = 61440;
pub const S_IFDIR: u32 = 16384;
pub const S_IFCHR: u32 = 8192;
pub const S_IFREG: u32 = 32768;
pub const S_IREAD: u32 = 256;
pub const S_IWRITE: u32 = 128;
pub const S_IEXEC: u32 = 64;
pub const WCHAR_MIN: u32 = 0;
pub const WCHAR_MAX: u32 = 65535;
pub const WINT_MIN: u32 = 0;
pub const WINT_MAX: u32 = 65535;
pub const FLT_EVAL_METHOD: u32 = 0;
pub const DBL_DECIMAL_DIG: u32 = 17;
pub const DBL_DIG: u32 = 15;
pub const DBL_HAS_SUBNORM: u32 = 1;
pub const DBL_MANT_DIG: u32 = 53;
pub const DBL_MAX_10_EXP: u32 = 308;
pub const DBL_MAX_EXP: u32 = 1024;
pub const DBL_MIN_10_EXP: i32 = -307;
pub const DBL_MIN_EXP: i32 = -1021;
pub const _DBL_RADIX: u32 = 2;
pub const FLT_DECIMAL_DIG: u32 = 9;
pub const FLT_DIG: u32 = 6;
pub const FLT_HAS_SUBNORM: u32 = 1;
pub const FLT_GUARD: u32 = 0;
pub const FLT_MANT_DIG: u32 = 24;
pub const FLT_MAX_10_EXP: u32 = 38;
pub const FLT_MAX_EXP: u32 = 128;
pub const FLT_MIN_10_EXP: i32 = -37;
pub const FLT_MIN_EXP: i32 = -125;
pub const FLT_NORMALIZE: u32 = 0;
pub const FLT_RADIX: u32 = 2;
pub const LDBL_DIG: u32 = 15;
pub const LDBL_HAS_SUBNORM: u32 = 1;
pub const LDBL_MANT_DIG: u32 = 53;
pub const LDBL_MAX_10_EXP: u32 = 308;
pub const LDBL_MAX_EXP: u32 = 1024;
pub const LDBL_MIN_10_EXP: i32 = -307;
pub const LDBL_MIN_EXP: i32 = -1021;
pub const _LDBL_RADIX: u32 = 2;
pub const DECIMAL_DIG: u32 = 17;
pub const _SW_INEXACT: u32 = 1;
pub const _SW_UNDERFLOW: u32 = 2;
pub const _SW_OVERFLOW: u32 = 4;
pub const _SW_ZERODIVIDE: u32 = 8;
pub const _SW_INVALID: u32 = 16;
pub const _SW_DENORMAL: u32 = 524288;
pub const _EM_AMBIGUIOUS: u32 = 2147483648;
pub const _EM_AMBIGUOUS: u32 = 2147483648;
pub const _MCW_EM: u32 = 524319;
pub const _EM_INEXACT: u32 = 1;
pub const _EM_UNDERFLOW: u32 = 2;
pub const _EM_OVERFLOW: u32 = 4;
pub const _EM_ZERODIVIDE: u32 = 8;
pub const _EM_INVALID: u32 = 16;
pub const _EM_DENORMAL: u32 = 524288;
pub const _MCW_RC: u32 = 768;
pub const _RC_NEAR: u32 = 0;
pub const _RC_DOWN: u32 = 256;
pub const _RC_UP: u32 = 512;
pub const _RC_CHOP: u32 = 768;
pub const _MCW_PC: u32 = 196608;
pub const _PC_64: u32 = 0;
pub const _PC_53: u32 = 65536;
pub const _PC_24: u32 = 131072;
pub const _MCW_IC: u32 = 262144;
pub const _IC_AFFINE: u32 = 262144;
pub const _IC_PROJECTIVE: u32 = 0;
pub const _MCW_DN: u32 = 50331648;
pub const _DN_SAVE: u32 = 0;
pub const _DN_FLUSH: u32 = 16777216;
pub const _DN_FLUSH_OPERANDS_SAVE_RESULTS: u32 = 33554432;
pub const _DN_SAVE_OPERANDS_FLUSH_RESULTS: u32 = 50331648;
pub const _SW_UNEMULATED: u32 = 64;
pub const _SW_SQRTNEG: u32 = 128;
pub const _SW_STACKOVERFLOW: u32 = 512;
pub const _SW_STACKUNDERFLOW: u32 = 1024;
pub const _FPE_INVALID: u32 = 129;
pub const _FPE_DENORMAL: u32 = 130;
pub const _FPE_ZERODIVIDE: u32 = 131;
pub const _FPE_OVERFLOW: u32 = 132;
pub const _FPE_UNDERFLOW: u32 = 133;
pub const _FPE_INEXACT: u32 = 134;
pub const _FPE_UNEMULATED: u32 = 135;
pub const _FPE_SQRTNEG: u32 = 136;
pub const _FPE_STACKOVERFLOW: u32 = 138;
pub const _FPE_STACKUNDERFLOW: u32 = 139;
pub const _FPE_EXPLICITGEN: u32 = 140;
pub const _FPE_MULTIPLE_TRAPS: u32 = 141;
pub const _FPE_MULTIPLE_FAULTS: u32 = 142;
pub const _FPCLASS_SNAN: u32 = 1;
pub const _FPCLASS_QNAN: u32 = 2;
pub const _FPCLASS_NINF: u32 = 4;
pub const _FPCLASS_NN: u32 = 8;
pub const _FPCLASS_ND: u32 = 16;
pub const _FPCLASS_NZ: u32 = 32;
pub const _FPCLASS_PZ: u32 = 64;
pub const _FPCLASS_PD: u32 = 128;
pub const _FPCLASS_PN: u32 = 256;
pub const _FPCLASS_PINF: u32 = 512;
pub const _CW_DEFAULT: u32 = 524319;
pub const DBL_RADIX: u32 = 2;
pub const LDBL_RADIX: u32 = 2;
pub const EM_AMBIGUIOUS: u32 = 2147483648;
pub const EM_AMBIGUOUS: u32 = 2147483648;
pub const MCW_EM: u32 = 524319;
pub const EM_INVALID: u32 = 16;
pub const EM_DENORMAL: u32 = 524288;
pub const EM_ZERODIVIDE: u32 = 8;
pub const EM_OVERFLOW: u32 = 4;
pub const EM_UNDERFLOW: u32 = 2;
pub const EM_INEXACT: u32 = 1;
pub const MCW_IC: u32 = 262144;
pub const IC_AFFINE: u32 = 262144;
pub const IC_PROJECTIVE: u32 = 0;
pub const MCW_RC: u32 = 768;
pub const RC_CHOP: u32 = 768;
pub const RC_UP: u32 = 512;
pub const RC_DOWN: u32 = 256;
pub const RC_NEAR: u32 = 0;
pub const MCW_PC: u32 = 196608;
pub const PC_24: u32 = 131072;
pub const PC_53: u32 = 65536;
pub const PC_64: u32 = 0;
pub const CW_DEFAULT: u32 = 524319;
pub const SW_INVALID: u32 = 16;
pub const SW_DENORMAL: u32 = 524288;
pub const SW_ZERODIVIDE: u32 = 8;
pub const SW_OVERFLOW: u32 = 4;
pub const SW_UNDERFLOW: u32 = 2;
pub const SW_INEXACT: u32 = 1;
pub const SW_UNEMULATED: u32 = 64;
pub const SW_SQRTNEG: u32 = 128;
pub const SW_STACKOVERFLOW: u32 = 512;
pub const SW_STACKUNDERFLOW: u32 = 1024;
pub const FPE_INVALID: u32 = 129;
pub const FPE_DENORMAL: u32 = 130;
pub const FPE_ZERODIVIDE: u32 = 131;
pub const FPE_OVERFLOW: u32 = 132;
pub const FPE_UNDERFLOW: u32 = 133;
pub const FPE_INEXACT: u32 = 134;
pub const FPE_UNEMULATED: u32 = 135;
pub const FPE_SQRTNEG: u32 = 136;
pub const FPE_STACKOVERFLOW: u32 = 138;
pub const FPE_STACKUNDERFLOW: u32 = 139;
pub const FPE_EXPLICITGEN: u32 = 140;
pub const _USE_STD_VECTOR_ALGORITHMS: u32 = 1;
pub const _HAS_ALIGNED_NEW: u32 = 0;
pub const _HAS_U8_INTRINSICS: u32 = 0;
pub const FMX_USE_AUTO_PTR: u32 = 1;
pub const FMX_USE_UNIQUE_PTR: u32 = 1;
pub const FMX_64BIT_PLUGIN_API: u32 = 1;
pub const FMX_OBSOLETE_API: u32 = 0;
pub const TRUE: u32 = 1;
pub const FALSE: u32 = 0;
pub type va_list = *mut ::std::os::raw::c_char;
extern "C" {
pub fn __va_start(arg1: *mut va_list, ...);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __vcrt_va_list_is_reference {
pub _address: u8,
}
pub const __vcrt_va_list_is_reference___the_value: __vcrt_va_list_is_reference__bindgen_ty_1 = 0;
pub type __vcrt_va_list_is_reference__bindgen_ty_1 = u8;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __vcrt_assert_va_start_is_not_reference {
pub _address: u8,
}
pub type size_t = ::std::os::raw::c_ulonglong;
pub type __vcrt_bool = bool;
extern "C" {
pub fn __security_init_cookie();
}
extern "C" {
pub fn __security_check_cookie(_StackCookie: usize);
}
extern "C" {
pub fn __report_gsfailure(_StackCookie: usize);
}
extern "C" {
pub static mut __security_cookie: usize;
}
pub type __crt_bool = bool;
extern "C" {
pub fn _invalid_parameter_noinfo();
}
extern "C" {
pub fn _invalid_parameter_noinfo_noreturn();
}
extern "C" {
pub fn _invoke_watson(
_Expression: *const u16,
_FunctionName: *const u16,
_FileName: *const u16,
_LineNo: ::std::os::raw::c_uint,
_Reserved: usize,
);
}
pub type errno_t = ::std::os::raw::c_int;
pub type wint_t = ::std::os::raw::c_ushort;
pub type wctype_t = ::std::os::raw::c_ushort;
pub type __time32_t = ::std::os::raw::c_long;
pub type __time64_t = ::std::os::raw::c_longlong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __crt_locale_data_public {
pub _locale_pctype: *const ::std::os::raw::c_ushort,
pub _locale_mb_cur_max: ::std::os::raw::c_int,
pub _locale_lc_codepage: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout___crt_locale_data_public() {
assert_eq!(
::std::mem::size_of::<__crt_locale_data_public>(),
16usize,
concat!("Size of: ", stringify!(__crt_locale_data_public))
);
assert_eq!(
::std::mem::align_of::<__crt_locale_data_public>(),
8usize,
concat!("Alignment of ", stringify!(__crt_locale_data_public))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__crt_locale_data_public>()))._locale_pctype as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__crt_locale_data_public),
"::",
stringify!(_locale_pctype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__crt_locale_data_public>()))._locale_mb_cur_max as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(__crt_locale_data_public),
"::",
stringify!(_locale_mb_cur_max)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__crt_locale_data_public>()))._locale_lc_codepage as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(__crt_locale_data_public),
"::",
stringify!(_locale_lc_codepage)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __crt_locale_pointers {
pub locinfo: *mut __crt_locale_data,
pub mbcinfo: *mut __crt_multibyte_data,
}
#[test]
fn bindgen_test_layout___crt_locale_pointers() {
assert_eq!(
::std::mem::size_of::<__crt_locale_pointers>(),
16usize,
concat!("Size of: ", stringify!(__crt_locale_pointers))
);
assert_eq!(
::std::mem::align_of::<__crt_locale_pointers>(),
8usize,
concat!("Alignment of ", stringify!(__crt_locale_pointers))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__crt_locale_pointers>())).locinfo as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__crt_locale_pointers),
"::",
stringify!(locinfo)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__crt_locale_pointers>())).mbcinfo as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__crt_locale_pointers),
"::",
stringify!(mbcinfo)
)
);
}
pub type _locale_t = *mut __crt_locale_pointers;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _Mbstatet {
pub _Wchar: ::std::os::raw::c_ulong,
pub _Byte: ::std::os::raw::c_ushort,
pub _State: ::std::os::raw::c_ushort,
}
#[test]
fn bindgen_test_layout__Mbstatet() {
assert_eq!(
::std::mem::size_of::<_Mbstatet>(),
8usize,
concat!("Size of: ", stringify!(_Mbstatet))
);
assert_eq!(
::std::mem::align_of::<_Mbstatet>(),
4usize,
concat!("Alignment of ", stringify!(_Mbstatet))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_Mbstatet>()))._Wchar as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_Mbstatet),
"::",
stringify!(_Wchar)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_Mbstatet>()))._Byte as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_Mbstatet),
"::",
stringify!(_Byte)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_Mbstatet>()))._State as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(_Mbstatet),
"::",
stringify!(_State)
)
);
}
pub type mbstate_t = _Mbstatet;
pub type time_t = __time64_t;
pub type rsize_t = size_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_nothrow_t {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std_nothrow_t() {
assert_eq!(
::std::mem::size_of::<std_nothrow_t>(),
1usize,
concat!("Size of: ", stringify!(std_nothrow_t))
);
assert_eq!(
::std::mem::align_of::<std_nothrow_t>(),
1usize,
concat!("Alignment of ", stringify!(std_nothrow_t))
);
}
extern "C" {
#[link_name = "\u{1}?nothrow@std@@3Unothrow_t@1@B"]
pub static std_nothrow: std_nothrow_t;
}
pub const std__Uninitialized__Noinit: std__Uninitialized = 0;
pub type std__Uninitialized = i32;
#[repr(C)]
#[derive(Debug)]
pub struct std__Lockit {
pub _Locktype: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_std__Lockit() {
assert_eq!(
::std::mem::size_of::<std__Lockit>(),
4usize,
concat!("Size of: ", stringify!(std__Lockit))
);
assert_eq!(
::std::mem::align_of::<std__Lockit>(),
4usize,
concat!("Alignment of ", stringify!(std__Lockit))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<std__Lockit>()))._Locktype as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(std__Lockit),
"::",
stringify!(_Locktype)
)
);
}
extern "C" {
#[link_name = "\u{1}?_Lockit_ctor@_Lockit@std@@SAXH@Z"]
pub fn std__Lockit__Lockit_ctor(arg1: ::std::os::raw::c_int);
}
extern "C" {
#[link_name = "\u{1}?_Lockit_dtor@_Lockit@std@@SAXH@Z"]
pub fn std__Lockit__Lockit_dtor(arg1: ::std::os::raw::c_int);
}
extern "C" {
#[link_name = "\u{1}??0_Lockit@std@@QEAA@XZ"]
pub fn std__Lockit__Lockit(this: *mut std__Lockit);
}
extern "C" {
#[link_name = "\u{1}??0_Lockit@std@@QEAA@H@Z"]
pub fn std__Lockit__Lockit1(this: *mut std__Lockit, arg1: ::std::os::raw::c_int);
}
extern "C" {
#[link_name = "\u{1}??_D_Lockit@std@@QEAAXXZ"]
pub fn std__Lockit__Lockit_destructor(this: *mut std__Lockit);
}
impl std__Lockit {
#[inline]
pub unsafe fn _Lockit_ctor(arg1: ::std::os::raw::c_int) {
std__Lockit__Lockit_ctor(arg1)
}
#[inline]
pub unsafe fn _Lockit_dtor(arg1: ::std::os::raw::c_int) {
std__Lockit__Lockit_dtor(arg1)
}
#[inline]
pub unsafe fn new() -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
std__Lockit__Lockit(__bindgen_tmp.as_mut_ptr());
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new1(arg1: ::std::os::raw::c_int) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
std__Lockit__Lockit1(__bindgen_tmp.as_mut_ptr(), arg1);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn destruct(&mut self) {
std__Lockit__Lockit_destructor(self)
}
}
#[repr(C)]
#[derive(Debug)]
pub struct std__Init_locks {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std__Init_locks() {
assert_eq!(
::std::mem::size_of::<std__Init_locks>(),
1usize,
concat!("Size of: ", stringify!(std__Init_locks))
);
assert_eq!(
::std::mem::align_of::<std__Init_locks>(),
1usize,
concat!("Alignment of ", stringify!(std__Init_locks))
);
}
extern "C" {
#[link_name = "\u{1}??0_Init_locks@std@@QEAA@XZ"]
pub fn std__Init_locks__Init_locks(this: *mut std__Init_locks);
}
extern "C" {
#[link_name = "\u{1}??_D_Init_locks@std@@QEAAXXZ"]
pub fn std__Init_locks__Init_locks_destructor(this: *mut std__Init_locks);
}
impl std__Init_locks {
#[inline]
pub unsafe fn new() -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
std__Init_locks__Init_locks(__bindgen_tmp.as_mut_ptr());
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn destruct(&mut self) {
std__Init_locks__Init_locks_destructor(self)
}
}
pub type std_nullptr_t = *const ::std::os::raw::c_void;
pub type std_integral_constant_value_type<_Ty> = _Ty;
pub type std_integral_constant_type = u8;
pub type std_bool_constant = u8;
pub type std_true_type = u8;
pub type std_false_type = u8;
pub type std_enable_if_t = u8;
pub type std_conditional_type<_Ty1> = _Ty1;
pub type std_conditional_t = u8;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_same {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_remove_const {
pub _address: u8,
}
pub type std_remove_const_type<_Ty> = _Ty;
pub type std_remove_const_t = std_remove_const;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_remove_volatile {
pub _address: u8,
}
pub type std_remove_volatile_type<_Ty> = _Ty;
pub type std_remove_volatile_t = std_remove_volatile;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_remove_cv {
pub _address: u8,
}
pub type std_remove_cv_type<_Ty> = _Ty;
pub type std_remove_cv__Apply = u8;
pub type std_remove_cv_t = std_remove_cv;
pub type std__Disjunction_type<_First> = _First;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_disjunction {
pub _base: std_false_type,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_integral {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_floating_point {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_arithmetic {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_remove_reference {
pub _address: u8,
}
pub type std_remove_reference_type<_Ty> = _Ty;
pub type std_remove_reference__Const_thru_ref_type<_Ty> = _Ty;
pub type std_remove_reference_t = std_remove_reference;
pub type std__Const_thru_ref = std_remove_reference;
pub type std__Remove_cvref_t = std_remove_cv_t;
pub type std_max_align_t = f64;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_initializer_list<_Elem> {
pub _First: *const _Elem,
pub _Last: *const _Elem,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Elem>>,
}
pub type std_initializer_list_value_type<_Elem> = _Elem;
pub type std_initializer_list_reference<_Elem> = *const _Elem;
pub type std_initializer_list_const_reference<_Elem> = *const _Elem;
pub type std_initializer_list_size_type = size_t;
pub type std_initializer_list_iterator<_Elem> = *const _Elem;
pub type std_initializer_list_const_iterator<_Elem> = *const _Elem;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_unary_function {
pub _address: u8,
}
pub type std_unary_function_argument_type<_Arg> = _Arg;
pub type std_unary_function_result_type<_Result> = _Result;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_binary_function {
pub _address: u8,
}
pub type std_binary_function_first_argument_type<_Arg1> = _Arg1;
pub type std_binary_function_second_argument_type<_Arg2> = _Arg2;
pub type std_binary_function_result_type<_Result> = _Result;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_plus {
pub _address: u8,
}
pub type std_plus_first_argument_type<_Ty> = _Ty;
pub type std_plus_second_argument_type<_Ty> = _Ty;
pub type std_plus_result_type<_Ty> = _Ty;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_minus {
pub _address: u8,
}
pub type std_minus_first_argument_type<_Ty> = _Ty;
pub type std_minus_second_argument_type<_Ty> = _Ty;
pub type std_minus_result_type<_Ty> = _Ty;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_multiplies {
pub _address: u8,
}
pub type std_multiplies_first_argument_type<_Ty> = _Ty;
pub type std_multiplies_second_argument_type<_Ty> = _Ty;
pub type std_multiplies_result_type<_Ty> = _Ty;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_equal_to {
pub _address: u8,
}
pub type std_equal_to_first_argument_type<_Ty> = _Ty;
pub type std_equal_to_second_argument_type<_Ty> = _Ty;
pub type std_equal_to_result_type = bool;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_not_equal_to {
pub _address: u8,
}
pub type std_not_equal_to_first_argument_type<_Ty> = _Ty;
pub type std_not_equal_to_second_argument_type<_Ty> = _Ty;
pub type std_not_equal_to_result_type = bool;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_greater {
pub _address: u8,
}
pub type std_greater_first_argument_type<_Ty> = _Ty;
pub type std_greater_second_argument_type<_Ty> = _Ty;
pub type std_greater_result_type = bool;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_less {
pub _address: u8,
}
pub type std_less_first_argument_type<_Ty> = _Ty;
pub type std_less_second_argument_type<_Ty> = _Ty;
pub type std_less_result_type = bool;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_greater_equal {
pub _address: u8,
}
pub type std_greater_equal_first_argument_type<_Ty> = _Ty;
pub type std_greater_equal_second_argument_type<_Ty> = _Ty;
pub type std_greater_equal_result_type = bool;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_less_equal {
pub _address: u8,
}
pub type std_less_equal_first_argument_type<_Ty> = _Ty;
pub type std_less_equal_second_argument_type<_Ty> = _Ty;
pub type std_less_equal_result_type = bool;
#[test]
fn __bindgen_test_layout_std_plus_open0_void_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_plus>(),
1usize,
concat!("Size of template specialization: ", stringify!(std_plus))
);
assert_eq!(
::std::mem::align_of::<std_plus>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_plus)
)
);
}
#[test]
fn __bindgen_test_layout_std_minus_open0_void_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_minus>(),
1usize,
concat!("Size of template specialization: ", stringify!(std_minus))
);
assert_eq!(
::std::mem::align_of::<std_minus>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_minus)
)
);
}
#[test]
fn __bindgen_test_layout_std_multiplies_open0_void_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_multiplies>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_multiplies)
)
);
assert_eq!(
::std::mem::align_of::<std_multiplies>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_multiplies)
)
);
}
#[test]
fn __bindgen_test_layout_std_equal_to_open0_void_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_equal_to>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_equal_to)
)
);
assert_eq!(
::std::mem::align_of::<std_equal_to>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_equal_to)
)
);
}
#[test]
fn __bindgen_test_layout_std_not_equal_to_open0_void_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_not_equal_to>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_not_equal_to)
)
);
assert_eq!(
::std::mem::align_of::<std_not_equal_to>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_not_equal_to)
)
);
}
#[test]
fn __bindgen_test_layout_std_greater_open0_void_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_greater>(),
1usize,
concat!("Size of template specialization: ", stringify!(std_greater))
);
assert_eq!(
::std::mem::align_of::<std_greater>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_greater)
)
);
}
#[test]
fn __bindgen_test_layout_std_less_open0_void_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_less>(),
1usize,
concat!("Size of template specialization: ", stringify!(std_less))
);
assert_eq!(
::std::mem::align_of::<std_less>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_less)
)
);
}
#[test]
fn __bindgen_test_layout_std_greater_equal_open0_void_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_greater_equal>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_greater_equal)
)
);
assert_eq!(
::std::mem::align_of::<std_greater_equal>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_greater_equal)
)
);
}
#[test]
fn __bindgen_test_layout_std_less_equal_open0_void_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_less_equal>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_less_equal)
)
);
assert_eq!(
::std::mem::align_of::<std_less_equal>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_less_equal)
)
);
}
pub type std_integer_sequence_value_type<_Ty> = _Ty;
pub type std_make_integer_sequence = u8;
pub type std_index_sequence = u8;
pub type std_make_index_sequence = std_make_integer_sequence;
pub type std_index_sequence_for = std_make_index_sequence;
pub type std__Conjunction_type<_First> = _First;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_conjunction {
pub _base: std_true_type,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_negation {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Arg_types {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Is_function {
pub _address: u8,
}
pub type std__Is_function__Bool_type = std_false_type;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_function {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Is_memfunptr {
pub _address: u8,
}
pub type std__Is_memfunptr__Bool_type = std_false_type;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_void {
pub _address: u8,
}
pub type std_void_t = ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_add_const {
pub _address: u8,
}
pub type std_add_const_type<_Ty> = _Ty;
pub type std_add_const_t = std_add_const;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_add_volatile {
pub _address: u8,
}
pub type std_add_volatile_type<_Ty> = _Ty;
pub type std_add_volatile_t = std_add_volatile;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_add_cv {
pub _address: u8,
}
pub type std_add_cv_type<_Ty> = _Ty;
pub type std_add_cv_t = std_add_cv;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Add_reference {
pub _address: u8,
}
pub type std__Add_reference__Lvalue<_Ty> = _Ty;
pub type std__Add_reference__Rvalue<_Ty> = _Ty;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_add_lvalue_reference {
pub _address: u8,
}
pub type std_add_lvalue_reference_type = std__Add_reference;
pub type std_add_lvalue_reference_t = std__Add_reference;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_add_rvalue_reference {
pub _address: u8,
}
pub type std_add_rvalue_reference_type = std__Add_reference;
pub type std_add_rvalue_reference_t = std__Add_reference;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_remove_extent {
pub _address: u8,
}
pub type std_remove_extent_type<_Ty> = _Ty;
pub type std_remove_extent_t = std_remove_extent;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_remove_all_extents {
pub _address: u8,
}
pub type std_remove_all_extents_type<_Ty> = _Ty;
pub type std_remove_all_extents_t = std_remove_all_extents;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_remove_pointer {
pub _address: u8,
}
pub type std_remove_pointer_type<_Ty> = _Ty;
pub type std_remove_pointer_t = std_remove_pointer;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Add_pointer {
pub _address: u8,
}
pub type std__Add_pointer_type<_Ty> = _Ty;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_add_pointer {
pub _address: u8,
}
pub type std_add_pointer_type = std__Add_pointer;
pub type std_add_pointer_t = std__Add_pointer;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_array {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_lvalue_reference {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_rvalue_reference {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_reference {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_member_object_pointer {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_member_function_pointer {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_pointer {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_null_pointer {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_union {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_class {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_fundamental {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_object {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_convertible {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_enum {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_compound {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_member_pointer {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_scalar {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_const {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_volatile {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_pod {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_empty {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_polymorphic {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_abstract {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_final {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_standard_layout {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_literal_type {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_trivial {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_trivially_copyable {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_has_virtual_destructor {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_constructible {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_copy_constructible {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_default_constructible {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Is_implicitly_default_constructible {
pub _base: std_false_type,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_move_constructible {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_assignable {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_copy_assignable {
pub _address: u8,
}
pub type std__Is_copy_assignable_no_precondition_check = std_is_copy_assignable;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_move_assignable {
pub _address: u8,
}
pub type std__Is_move_assignable_no_precondition_check = std_is_move_assignable;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_destructible {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_trivially_constructible {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_trivially_copy_constructible {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_trivially_default_constructible {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_trivially_move_constructible {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_trivially_assignable {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_trivially_copy_assignable {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_trivially_move_assignable {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_trivially_destructible {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_nothrow_constructible {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_nothrow_copy_constructible {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_nothrow_default_constructible {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_nothrow_move_constructible {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_nothrow_assignable {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_nothrow_copy_assignable {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_nothrow_move_assignable {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_nothrow_destructible {
pub _address: u8,
}
pub type std__Sign_base__Uty = std_remove_cv_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_signed {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_unsigned {
pub _address: u8,
}
pub type std__Select__Apply<_Ty1> = _Ty1;
pub type std__Make_signed1 = u8;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_make_signed {
pub _address: u8,
}
pub type std_make_signed_type = std_remove_cv;
pub type std_make_signed_t = std_make_signed;
pub type std__Make_unsigned1 = u8;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_make_unsigned {
pub _address: u8,
}
pub type std_make_unsigned_type = std_remove_cv;
pub type std_make_unsigned_t = std_make_unsigned;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_alignment_of {
pub _address: u8,
}
pub type std_aligned_storage__Next = ::std::os::raw::c_char;
extern "C" {
#[link_name = "\u{1}_Fits"]
pub static std_aligned_storage__Fits: bool;
}
pub type std_aligned_storage_type = u8;
pub type std_aligned_storage_t = u8;
pub type std_aligned_union_type = std_aligned_storage_t;
pub type std_aligned_union_t = u8;
pub type std__Underlying_type_type<_Ty> = _Ty;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_underlying_type {
pub _address: u8,
}
pub type std_underlying_type_t = u8;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_rank {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_base_of {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_decay {
pub _address: u8,
}
pub type std_decay__Ty1 = std_remove_reference_t;
pub type std_decay__Ty2 = u8;
pub type std_decay_type = u8;
pub type std_decay_t = std_decay;
pub type std__Conditional_type<_Ty1> = _Ty1;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Decayed_cond_oper {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_common_type {
pub _address: u8,
}
pub type std_common_type_t = std_common_type;
#[test]
fn __bindgen_test_layout_std_common_type_open0_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_common_type>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_common_type)
)
);
assert_eq!(
::std::mem::align_of::<std_common_type>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_common_type)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Common_type2 {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Common_type3 {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Identity {
pub _address: u8,
}
pub type std__Identity_type<_Ty> = _Ty;
pub type std__Identity_t = std__Identity;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Is_specialization {
pub _address: u8,
}
pub const std__Invoker_strategy__Functor: std__Invoker_strategy = 0;
pub const std__Invoker_strategy__Pmf_object: std__Invoker_strategy = 1;
pub const std__Invoker_strategy__Pmf_refwrap: std__Invoker_strategy = 2;
pub const std__Invoker_strategy__Pmf_pointer: std__Invoker_strategy = 3;
pub const std__Invoker_strategy__Pmd_object: std__Invoker_strategy = 4;
pub const std__Invoker_strategy__Pmd_refwrap: std__Invoker_strategy = 5;
pub const std__Invoker_strategy__Pmd_pointer: std__Invoker_strategy = 6;
pub type std__Invoker_strategy = i32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Invoker_functor {
pub _address: u8,
}
extern "C" {
#[link_name = "\u{1}?_Strategy@_Invoker_functor@std@@2W4_Invoker_strategy@2@B"]
pub static std__Invoker_functor__Strategy: std__Invoker_strategy;
}
#[test]
fn bindgen_test_layout_std__Invoker_functor() {
assert_eq!(
::std::mem::size_of::<std__Invoker_functor>(),
1usize,
concat!("Size of: ", stringify!(std__Invoker_functor))
);
assert_eq!(
::std::mem::align_of::<std__Invoker_functor>(),
1usize,
concat!("Alignment of ", stringify!(std__Invoker_functor))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Invoker_pmf_object {
pub _address: u8,
}
extern "C" {
#[link_name = "\u{1}?_Strategy@_Invoker_pmf_object@std@@2W4_Invoker_strategy@2@B"]
pub static std__Invoker_pmf_object__Strategy: std__Invoker_strategy;
}
#[test]
fn bindgen_test_layout_std__Invoker_pmf_object() {
assert_eq!(
::std::mem::size_of::<std__Invoker_pmf_object>(),
1usize,
concat!("Size of: ", stringify!(std__Invoker_pmf_object))
);
assert_eq!(
::std::mem::align_of::<std__Invoker_pmf_object>(),
1usize,
concat!("Alignment of ", stringify!(std__Invoker_pmf_object))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Invoker_pmf_refwrap {
pub _address: u8,
}
extern "C" {
#[link_name = "\u{1}?_Strategy@_Invoker_pmf_refwrap@std@@2W4_Invoker_strategy@2@B"]
pub static std__Invoker_pmf_refwrap__Strategy: std__Invoker_strategy;
}
#[test]
fn bindgen_test_layout_std__Invoker_pmf_refwrap() {
assert_eq!(
::std::mem::size_of::<std__Invoker_pmf_refwrap>(),
1usize,
concat!("Size of: ", stringify!(std__Invoker_pmf_refwrap))
);
assert_eq!(
::std::mem::align_of::<std__Invoker_pmf_refwrap>(),
1usize,
concat!("Alignment of ", stringify!(std__Invoker_pmf_refwrap))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Invoker_pmf_pointer {
pub _address: u8,
}
extern "C" {
#[link_name = "\u{1}?_Strategy@_Invoker_pmf_pointer@std@@2W4_Invoker_strategy@2@B"]
pub static std__Invoker_pmf_pointer__Strategy: std__Invoker_strategy;
}
#[test]
fn bindgen_test_layout_std__Invoker_pmf_pointer() {
assert_eq!(
::std::mem::size_of::<std__Invoker_pmf_pointer>(),
1usize,
concat!("Size of: ", stringify!(std__Invoker_pmf_pointer))
);
assert_eq!(
::std::mem::align_of::<std__Invoker_pmf_pointer>(),
1usize,
concat!("Alignment of ", stringify!(std__Invoker_pmf_pointer))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Invoker_pmd_object {
pub _address: u8,
}
extern "C" {
#[link_name = "\u{1}?_Strategy@_Invoker_pmd_object@std@@2W4_Invoker_strategy@2@B"]
pub static std__Invoker_pmd_object__Strategy: std__Invoker_strategy;
}
#[test]
fn bindgen_test_layout_std__Invoker_pmd_object() {
assert_eq!(
::std::mem::size_of::<std__Invoker_pmd_object>(),
1usize,
concat!("Size of: ", stringify!(std__Invoker_pmd_object))
);
assert_eq!(
::std::mem::align_of::<std__Invoker_pmd_object>(),
1usize,
concat!("Alignment of ", stringify!(std__Invoker_pmd_object))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Invoker_pmd_refwrap {
pub _address: u8,
}
extern "C" {
#[link_name = "\u{1}?_Strategy@_Invoker_pmd_refwrap@std@@2W4_Invoker_strategy@2@B"]
pub static std__Invoker_pmd_refwrap__Strategy: std__Invoker_strategy;
}
#[test]
fn bindgen_test_layout_std__Invoker_pmd_refwrap() {
assert_eq!(
::std::mem::size_of::<std__Invoker_pmd_refwrap>(),
1usize,
concat!("Size of: ", stringify!(std__Invoker_pmd_refwrap))
);
assert_eq!(
::std::mem::align_of::<std__Invoker_pmd_refwrap>(),
1usize,
concat!("Alignment of ", stringify!(std__Invoker_pmd_refwrap))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Invoker_pmd_pointer {
pub _address: u8,
}
extern "C" {
#[link_name = "\u{1}?_Strategy@_Invoker_pmd_pointer@std@@2W4_Invoker_strategy@2@B"]
pub static std__Invoker_pmd_pointer__Strategy: std__Invoker_strategy;
}
#[test]
fn bindgen_test_layout_std__Invoker_pmd_pointer() {
assert_eq!(
::std::mem::size_of::<std__Invoker_pmd_pointer>(),
1usize,
concat!("Size of: ", stringify!(std__Invoker_pmd_pointer))
);
assert_eq!(
::std::mem::align_of::<std__Invoker_pmd_pointer>(),
1usize,
concat!("Alignment of ", stringify!(std__Invoker_pmd_pointer))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Unforced {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std__Unforced() {
assert_eq!(
::std::mem::size_of::<std__Unforced>(),
1usize,
concat!("Size of: ", stringify!(std__Unforced))
);
assert_eq!(
::std::mem::align_of::<std__Unforced>(),
1usize,
concat!("Alignment of ", stringify!(std__Unforced))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Is_nothrow_convertible {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Invoke_traits_zero {
pub _address: u8,
}
pub type std__Invoke_traits_zero__Is_invocable = std_false_type;
pub type std__Invoke_traits_zero__Is_nothrow_invocable = std_false_type;
pub type std__Invoke_traits_zero__Is_invocable_r = std_false_type;
pub type std__Invoke_traits_zero__Is_nothrow_invocable_r = std_false_type;
pub type std__Decltype_invoke_zero<_Callable> = _Callable;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Invoke_traits_nonzero {
pub _address: u8,
}
pub type std__Invoke_traits_nonzero__Is_invocable = std_false_type;
pub type std__Invoke_traits_nonzero__Is_nothrow_invocable = std_false_type;
pub type std__Invoke_traits_nonzero__Is_invocable_r = std_false_type;
pub type std__Invoke_traits_nonzero__Is_nothrow_invocable_r = std_false_type;
pub type std__Decltype_invoke_nonzero = u8;
pub type std__Select_invoke_traits = std_conditional_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_result_of {
pub _address: u8,
}
pub type std_result_of_t = std_result_of;
pub type std__Invoke_result_t = std__Select_invoke_traits;
pub type std__Is_invocable_r_ = std__Select_invoke_traits;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Is_invocable_r {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Weak_result_type {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Weak_argument_type {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Weak_binary_args {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Weak_types {
pub _address: u8,
}
pub type std__Weak_types__Is_f_or_pf = std__Is_function;
pub type std__Weak_types__Is_pmf = std__Is_memfunptr;
pub type std__Weak_types_type = std_conditional_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Refwrap_has_ctor_from {
pub _base: std_false_type,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_reference_wrapper<_Ty> {
pub _Ptr: *mut _Ty,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Ty>>,
}
pub type std_reference_wrapper_type<_Ty> = _Ty;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Swappable_with_helper {
pub _base: std_false_type,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Is_swappable_with {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Is_swappable {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Swap_cannot_throw {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Is_nothrow_swappable_with {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Is_nothrow_swappable {
pub _address: u8,
}
extern "C" {
#[link_name = "\u{1}?swap@_Has_ADL_swap_detail@std@@YAXXZ"]
pub fn std__Has_ADL_swap_detail_swap();
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Has_ADL_swap_detail__Has_ADL_swap {
pub _base: std_false_type,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Is_trivially_swappable {
pub _address: u8,
}
pub const std__FNV_offset_basis: size_t = 14695981039346656037;
pub const std__FNV_prime: size_t = 1099511628211;
pub type std__Conditionally_enabled_hash_argument_type<_Kty> = _Kty;
pub type std__Conditionally_enabled_hash_result_type = size_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_hash {
pub _address: u8,
}
#[test]
fn __bindgen_test_layout_std_hash_open0_float_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_hash>(),
1usize,
concat!("Size of template specialization: ", stringify!(std_hash))
);
assert_eq!(
::std::mem::align_of::<std_hash>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_hash)
)
);
}
#[test]
fn __bindgen_test_layout_std_hash_open0_double_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_hash>(),
1usize,
concat!("Size of template specialization: ", stringify!(std_hash))
);
assert_eq!(
::std::mem::align_of::<std_hash>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_hash)
)
);
}
#[test]
fn __bindgen_test_layout_std_hash_open0_long_double_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_hash>(),
1usize,
concat!("Size of template specialization: ", stringify!(std_hash))
);
assert_eq!(
::std::mem::align_of::<std_hash>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_hash)
)
);
}
#[test]
fn __bindgen_test_layout_std_hash_open0_nullptr_t_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_hash>(),
1usize,
concat!("Size of template specialization: ", stringify!(std_hash))
);
assert_eq!(
::std::mem::align_of::<std_hash>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_hash)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Is_nothrow_hashable {
pub _base: std_false_type,
}
extern "C" {
#[link_name = "\u{1}?uncaught_exception@std@@YA_NXZ"]
pub fn std_uncaught_exception() -> bool;
}
extern "C" {
#[link_name = "\u{1}?uncaught_exceptions@std@@YAHXZ"]
pub fn std_uncaught_exceptions() -> ::std::os::raw::c_int;
}
#[repr(C)]
pub struct std_exception__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug)]
pub struct std_exception {
pub vtable_: *const std_exception__bindgen_vtable,
pub _Data: __std_exception_data,
}
#[test]
fn bindgen_test_layout_std_exception() {
assert_eq!(
::std::mem::size_of::<std_exception>(),
24usize,
concat!("Size of: ", stringify!(std_exception))
);
assert_eq!(
::std::mem::align_of::<std_exception>(),
8usize,
concat!("Alignment of ", stringify!(std_exception))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<std_exception>()))._Data as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(std_exception),
"::",
stringify!(_Data)
)
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std_bad_exception {
pub _base: std_exception,
}
#[test]
fn bindgen_test_layout_std_bad_exception() {
assert_eq!(
::std::mem::size_of::<std_bad_exception>(),
24usize,
concat!("Size of: ", stringify!(std_bad_exception))
);
assert_eq!(
::std::mem::align_of::<std_bad_exception>(),
8usize,
concat!("Alignment of ", stringify!(std_bad_exception))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std_bad_alloc {
pub _base: std_exception,
}
#[test]
fn bindgen_test_layout_std_bad_alloc() {
assert_eq!(
::std::mem::size_of::<std_bad_alloc>(),
24usize,
concat!("Size of: ", stringify!(std_bad_alloc))
);
assert_eq!(
::std::mem::align_of::<std_bad_alloc>(),
8usize,
concat!("Alignment of ", stringify!(std_bad_alloc))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std_bad_array_new_length {
pub _base: std_bad_alloc,
}
#[test]
fn bindgen_test_layout_std_bad_array_new_length() {
assert_eq!(
::std::mem::size_of::<std_bad_array_new_length>(),
24usize,
concat!("Size of: ", stringify!(std_bad_array_new_length))
);
assert_eq!(
::std::mem::align_of::<std_bad_array_new_length>(),
8usize,
concat!("Alignment of ", stringify!(std_bad_array_new_length))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std_exception_ptr {
pub _Data1: *mut ::std::os::raw::c_void,
pub _Data2: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_std_exception_ptr() {
assert_eq!(
::std::mem::size_of::<std_exception_ptr>(),
16usize,
concat!("Size of: ", stringify!(std_exception_ptr))
);
assert_eq!(
::std::mem::align_of::<std_exception_ptr>(),
8usize,
concat!("Alignment of ", stringify!(std_exception_ptr))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<std_exception_ptr>()))._Data1 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(std_exception_ptr),
"::",
stringify!(_Data1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<std_exception_ptr>()))._Data2 as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(std_exception_ptr),
"::",
stringify!(_Data2)
)
);
}
#[repr(C)]
pub struct std_nested_exception__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug)]
pub struct std_nested_exception {
pub vtable_: *const std_nested_exception__bindgen_vtable,
pub _Exc: std_exception_ptr,
}
#[test]
fn bindgen_test_layout_std_nested_exception() {
assert_eq!(
::std::mem::size_of::<std_nested_exception>(),
24usize,
concat!("Size of: ", stringify!(std_nested_exception))
);
assert_eq!(
::std::mem::align_of::<std_nested_exception>(),
8usize,
concat!("Alignment of ", stringify!(std_nested_exception))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<std_nested_exception>()))._Exc as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(std_nested_exception),
"::",
stringify!(_Exc)
)
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std__With_nested<_Uty> {
pub _base: _Uty,
pub _base_1: std_nested_exception,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Uty>>,
}
pub type std_streamoff = ::std::os::raw::c_longlong;
pub type std_streamsize = ::std::os::raw::c_longlong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_fpos<_Statetype> {
pub _Myoff: std_streamoff,
pub _Fpos: fpos_t,
pub _Mystate: _Statetype,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Statetype>>,
}
pub type std_streampos = std_fpos<_Mbstatet>;
pub type std_wstreampos = std_streampos;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_locale {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_ios_base {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_basic_ios {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_istreambuf_iterator {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_ostreambuf_iterator {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_basic_streambuf {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_basic_istream {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_basic_ostream {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_basic_iostream {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_basic_stringbuf {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_basic_istringstream {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_basic_ostringstream {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_basic_stringstream {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_basic_filebuf {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_basic_ifstream {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_basic_ofstream {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_basic_fstream {
pub _address: u8,
}
pub type std_ios = std_basic_ios;
pub type std_streambuf = std_basic_streambuf;
pub type std_istream = std_basic_istream;
pub type std_ostream = std_basic_ostream;
pub type std_iostream = std_basic_iostream;
pub type std_stringbuf = std_basic_stringbuf;
pub type std_istringstream = std_basic_istringstream;
pub type std_ostringstream = std_basic_ostringstream;
pub type std_stringstream = std_basic_stringstream;
pub type std_filebuf = std_basic_filebuf;
pub type std_ifstream = std_basic_ifstream;
pub type std_ofstream = std_basic_ofstream;
pub type std_fstream = std_basic_fstream;
pub type std_wios = std_basic_ios;
pub type std_wstreambuf = std_basic_streambuf;
pub type std_wistream = std_basic_istream;
pub type std_wostream = std_basic_ostream;
pub type std_wiostream = std_basic_iostream;
pub type std_wstringbuf = std_basic_stringbuf;
pub type std_wistringstream = std_basic_istringstream;
pub type std_wostringstream = std_basic_ostringstream;
pub type std_wstringstream = std_basic_stringstream;
pub type std_wfilebuf = std_basic_filebuf;
pub type std_wifstream = std_basic_ifstream;
pub type std_wofstream = std_basic_ofstream;
pub type std_wfstream = std_basic_fstream;
pub const std_float_denorm_style_denorm_indeterminate: std_float_denorm_style = -1;
pub const std_float_denorm_style_denorm_absent: std_float_denorm_style = 0;
pub const std_float_denorm_style_denorm_present: std_float_denorm_style = 1;
pub type std_float_denorm_style = i32;
pub const std_float_round_style_round_indeterminate: std_float_round_style = -1;
pub const std_float_round_style_round_toward_zero: std_float_round_style = 0;
pub const std_float_round_style_round_to_nearest: std_float_round_style = 1;
pub const std_float_round_style_round_toward_infinity: std_float_round_style = 2;
pub const std_float_round_style_round_toward_neg_infinity: std_float_round_style = 3;
pub type std_float_round_style = i32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Num_base {
pub _address: u8,
}
extern "C" {
#[link_name = "\u{1}?has_denorm@_Num_base@std@@2W4float_denorm_style@2@B"]
pub static std__Num_base_has_denorm: std_float_denorm_style;
}
pub const std__Num_base_has_denorm_loss: bool = false;
pub const std__Num_base_has_infinity: bool = false;
pub const std__Num_base_has_quiet_NaN: bool = false;
pub const std__Num_base_has_signaling_NaN: bool = false;
pub const std__Num_base_is_bounded: bool = false;
pub const std__Num_base_is_exact: bool = false;
pub const std__Num_base_is_iec559: bool = false;
pub const std__Num_base_is_integer: bool = false;
pub const std__Num_base_is_modulo: bool = false;
pub const std__Num_base_is_signed: bool = false;
pub const std__Num_base_is_specialized: bool = false;
pub const std__Num_base_tinyness_before: bool = false;
pub const std__Num_base_traps: bool = false;
extern "C" {
#[link_name = "\u{1}?round_style@_Num_base@std@@2W4float_round_style@2@B"]
pub static std__Num_base_round_style: std_float_round_style;
}
pub const std__Num_base_digits: ::std::os::raw::c_int = 0;
pub const std__Num_base_digits10: ::std::os::raw::c_int = 0;
pub const std__Num_base_max_digits10: ::std::os::raw::c_int = 0;
pub const std__Num_base_max_exponent: ::std::os::raw::c_int = 0;
pub const std__Num_base_max_exponent10: ::std::os::raw::c_int = 0;
pub const std__Num_base_min_exponent: ::std::os::raw::c_int = 0;
pub const std__Num_base_min_exponent10: ::std::os::raw::c_int = 0;
pub const std__Num_base_radix: ::std::os::raw::c_int = 0;
#[test]
fn bindgen_test_layout_std__Num_base() {
assert_eq!(
::std::mem::size_of::<std__Num_base>(),
1usize,
concat!("Size of: ", stringify!(std__Num_base))
);
assert_eq!(
::std::mem::align_of::<std__Num_base>(),
1usize,
concat!("Alignment of ", stringify!(std__Num_base))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_numeric_limits {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Num_int_base {
pub _address: u8,
}
pub const std__Num_int_base_is_bounded: bool = true;
pub const std__Num_int_base_is_exact: bool = true;
pub const std__Num_int_base_is_integer: bool = true;
pub const std__Num_int_base_is_specialized: bool = true;
pub const std__Num_int_base_radix: ::std::os::raw::c_int = 2;
#[test]
fn bindgen_test_layout_std__Num_int_base() {
assert_eq!(
::std::mem::size_of::<std__Num_int_base>(),
1usize,
concat!("Size of: ", stringify!(std__Num_int_base))
);
assert_eq!(
::std::mem::align_of::<std__Num_int_base>(),
1usize,
concat!("Alignment of ", stringify!(std__Num_int_base))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Num_float_base {
pub _address: u8,
}
extern "C" {
#[link_name = "\u{1}?has_denorm@_Num_float_base@std@@2W4float_denorm_style@2@B"]
pub static std__Num_float_base_has_denorm: std_float_denorm_style;
}
pub const std__Num_float_base_has_infinity: bool = true;
pub const std__Num_float_base_has_quiet_NaN: bool = true;
pub const std__Num_float_base_has_signaling_NaN: bool = true;
pub const std__Num_float_base_is_bounded: bool = true;
pub const std__Num_float_base_is_iec559: bool = true;
pub const std__Num_float_base_is_signed: bool = true;
pub const std__Num_float_base_is_specialized: bool = true;
extern "C" {
#[link_name = "\u{1}?round_style@_Num_float_base@std@@2W4float_round_style@2@B"]
pub static std__Num_float_base_round_style: std_float_round_style;
}
pub const std__Num_float_base_radix: ::std::os::raw::c_int = 2;
#[test]
fn bindgen_test_layout_std__Num_float_base() {
assert_eq!(
::std::mem::size_of::<std__Num_float_base>(),
1usize,
concat!("Size of: ", stringify!(std__Num_float_base))
);
assert_eq!(
::std::mem::align_of::<std__Num_float_base>(),
1usize,
concat!("Alignment of ", stringify!(std__Num_float_base))
);
}
#[test]
fn __bindgen_test_layout_std_numeric_limits_open0_bool__close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_numeric_limits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_numeric_limits)
)
);
assert_eq!(
::std::mem::align_of::<std_numeric_limits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_numeric_limits)
)
);
}
#[test]
fn __bindgen_test_layout_std_numeric_limits_open0_char_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_numeric_limits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_numeric_limits)
)
);
assert_eq!(
::std::mem::align_of::<std_numeric_limits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_numeric_limits)
)
);
}
#[test]
fn __bindgen_test_layout_std_numeric_limits_open0_signed_char_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_numeric_limits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_numeric_limits)
)
);
assert_eq!(
::std::mem::align_of::<std_numeric_limits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_numeric_limits)
)
);
}
#[test]
fn __bindgen_test_layout_std_numeric_limits_open0_unsigned_char_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_numeric_limits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_numeric_limits)
)
);
assert_eq!(
::std::mem::align_of::<std_numeric_limits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_numeric_limits)
)
);
}
#[test]
fn __bindgen_test_layout_std_numeric_limits_open0_char16_t_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_numeric_limits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_numeric_limits)
)
);
assert_eq!(
::std::mem::align_of::<std_numeric_limits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_numeric_limits)
)
);
}
#[test]
fn __bindgen_test_layout_std_numeric_limits_open0_char32_t_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_numeric_limits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_numeric_limits)
)
);
assert_eq!(
::std::mem::align_of::<std_numeric_limits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_numeric_limits)
)
);
}
#[test]
fn __bindgen_test_layout_std_numeric_limits_open0_wchar_t_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_numeric_limits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_numeric_limits)
)
);
assert_eq!(
::std::mem::align_of::<std_numeric_limits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_numeric_limits)
)
);
}
#[test]
fn __bindgen_test_layout_std_numeric_limits_open0_short_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_numeric_limits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_numeric_limits)
)
);
assert_eq!(
::std::mem::align_of::<std_numeric_limits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_numeric_limits)
)
);
}
#[test]
fn __bindgen_test_layout_std_numeric_limits_open0_int_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_numeric_limits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_numeric_limits)
)
);
assert_eq!(
::std::mem::align_of::<std_numeric_limits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_numeric_limits)
)
);
}
#[test]
fn __bindgen_test_layout_std_numeric_limits_open0_long_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_numeric_limits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_numeric_limits)
)
);
assert_eq!(
::std::mem::align_of::<std_numeric_limits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_numeric_limits)
)
);
}
#[test]
fn __bindgen_test_layout_std_numeric_limits_open0_long_long_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_numeric_limits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_numeric_limits)
)
);
assert_eq!(
::std::mem::align_of::<std_numeric_limits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_numeric_limits)
)
);
}
#[test]
fn __bindgen_test_layout_std_numeric_limits_open0_unsigned_short_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_numeric_limits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_numeric_limits)
)
);
assert_eq!(
::std::mem::align_of::<std_numeric_limits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_numeric_limits)
)
);
}
#[test]
fn __bindgen_test_layout_std_numeric_limits_open0_unsigned_int_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_numeric_limits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_numeric_limits)
)
);
assert_eq!(
::std::mem::align_of::<std_numeric_limits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_numeric_limits)
)
);
}
#[test]
fn __bindgen_test_layout_std_numeric_limits_open0_unsigned_long_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_numeric_limits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_numeric_limits)
)
);
assert_eq!(
::std::mem::align_of::<std_numeric_limits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_numeric_limits)
)
);
}
#[test]
fn __bindgen_test_layout_std_numeric_limits_open0_unsigned_long_long_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_numeric_limits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_numeric_limits)
)
);
assert_eq!(
::std::mem::align_of::<std_numeric_limits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_numeric_limits)
)
);
}
#[test]
fn __bindgen_test_layout_std_numeric_limits_open0_float_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_numeric_limits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_numeric_limits)
)
);
assert_eq!(
::std::mem::align_of::<std_numeric_limits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_numeric_limits)
)
);
}
#[test]
fn __bindgen_test_layout_std_numeric_limits_open0_double_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_numeric_limits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_numeric_limits)
)
);
assert_eq!(
::std::mem::align_of::<std_numeric_limits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_numeric_limits)
)
);
}
#[test]
fn __bindgen_test_layout_std_numeric_limits_open0_long_double_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_numeric_limits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_numeric_limits)
)
);
assert_eq!(
::std::mem::align_of::<std_numeric_limits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_numeric_limits)
)
);
}
pub type std_new_handler = ::std::option::Option<unsafe extern "C" fn()>;
extern "C" {
#[link_name = "\u{1}?set_new_handler@std@@YAP6AXXZP6AXXZ@Z"]
pub fn std_set_new_handler(arg1: std_new_handler) -> std_new_handler;
}
extern "C" {
#[link_name = "\u{1}?get_new_handler@std@@YAP6AXXZXZ"]
pub fn std_get_new_handler() -> std_new_handler;
}
pub const std_memory_order_memory_order_relaxed: std_memory_order = 0;
pub const std_memory_order_memory_order_consume: std_memory_order = 1;
pub const std_memory_order_memory_order_acquire: std_memory_order = 2;
pub const std_memory_order_memory_order_release: std_memory_order = 3;
pub const std_memory_order_memory_order_acq_rel: std_memory_order = 4;
pub const std_memory_order_memory_order_seq_cst: std_memory_order = 5;
pub type std_memory_order = i32;
pub type std__Atomic_counter_t = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_piecewise_construct_t {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std_piecewise_construct_t() {
assert_eq!(
::std::mem::size_of::<std_piecewise_construct_t>(),
1usize,
concat!("Size of: ", stringify!(std_piecewise_construct_t))
);
assert_eq!(
::std::mem::align_of::<std_piecewise_construct_t>(),
1usize,
concat!("Alignment of ", stringify!(std_piecewise_construct_t))
);
}
extern "C" {
#[link_name = "\u{1}?piecewise_construct@std@@3Upiecewise_construct_t@1@B"]
pub static std_piecewise_construct: std_piecewise_construct_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_tuple {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_pair<_Ty1, _Ty2> {
pub first: _Ty1,
pub second: _Ty2,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Ty1>>,
pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Ty2>>,
}
pub type std_pair_first_type<_Ty1> = _Ty1;
pub type std_pair_second_type<_Ty2> = _Ty2;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Unrefwrap_helper {
pub _address: u8,
}
pub type std__Unrefwrap_helper_type<_Ty> = _Ty;
pub type std__Unrefwrap_t = std__Unrefwrap_helper;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_tuple_size {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Tuple_size_sfinae {
pub _address: u8,
}
pub type std_tuple_element_t = u8;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Get_first_parameter {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Replace_first_parameter {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Get_element_type {
pub _address: u8,
}
pub type std__Get_element_type_type = std__Get_first_parameter;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Get_ptr_difference_type {
pub _address: u8,
}
pub type std__Get_ptr_difference_type_type = isize;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Get_rebind_alias {
pub _address: u8,
}
pub type std__Get_rebind_alias_type = std__Replace_first_parameter;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_pointer_traits {
pub _address: u8,
}
pub type std_pointer_traits_pointer<_Ty> = _Ty;
pub type std_pointer_traits_element_type = std__Get_element_type;
pub type std_pointer_traits_difference_type = std__Get_ptr_difference_type;
pub type std_pointer_traits_rebind = std__Get_rebind_alias;
pub type std_pointer_traits__Reftype = *mut std_conditional_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Ref_fn<_Fx> {
pub _Fn: *mut _Fx,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Fx>>,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Unused_parameter {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std__Unused_parameter() {
assert_eq!(
::std::mem::size_of::<std__Unused_parameter>(),
1usize,
concat!("Size of: ", stringify!(std__Unused_parameter))
);
assert_eq!(
::std::mem::align_of::<std__Unused_parameter>(),
1usize,
concat!("Alignment of ", stringify!(std__Unused_parameter))
);
}
pub type std__Any_tag = std__Unused_parameter;
pub type std__Algorithm_int_t = std_conditional_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_input_iterator_tag {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std_input_iterator_tag() {
assert_eq!(
::std::mem::size_of::<std_input_iterator_tag>(),
1usize,
concat!("Size of: ", stringify!(std_input_iterator_tag))
);
assert_eq!(
::std::mem::align_of::<std_input_iterator_tag>(),
1usize,
concat!("Alignment of ", stringify!(std_input_iterator_tag))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_output_iterator_tag {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std_output_iterator_tag() {
assert_eq!(
::std::mem::size_of::<std_output_iterator_tag>(),
1usize,
concat!("Size of: ", stringify!(std_output_iterator_tag))
);
assert_eq!(
::std::mem::align_of::<std_output_iterator_tag>(),
1usize,
concat!("Alignment of ", stringify!(std_output_iterator_tag))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_forward_iterator_tag {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std_forward_iterator_tag() {
assert_eq!(
::std::mem::size_of::<std_forward_iterator_tag>(),
1usize,
concat!("Size of: ", stringify!(std_forward_iterator_tag))
);
assert_eq!(
::std::mem::align_of::<std_forward_iterator_tag>(),
1usize,
concat!("Alignment of ", stringify!(std_forward_iterator_tag))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_bidirectional_iterator_tag {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std_bidirectional_iterator_tag() {
assert_eq!(
::std::mem::size_of::<std_bidirectional_iterator_tag>(),
1usize,
concat!("Size of: ", stringify!(std_bidirectional_iterator_tag))
);
assert_eq!(
::std::mem::align_of::<std_bidirectional_iterator_tag>(),
1usize,
concat!("Alignment of ", stringify!(std_bidirectional_iterator_tag))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_random_access_iterator_tag {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std_random_access_iterator_tag() {
assert_eq!(
::std::mem::size_of::<std_random_access_iterator_tag>(),
1usize,
concat!("Size of: ", stringify!(std_random_access_iterator_tag))
);
assert_eq!(
::std::mem::align_of::<std_random_access_iterator_tag>(),
1usize,
concat!("Alignment of ", stringify!(std_random_access_iterator_tag))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Iterator_traits_base {
pub _address: u8,
}
pub type std__Iterator_traits_pointer_base_iterator_category = std_random_access_iterator_tag;
pub type std__Iterator_traits_pointer_base_value_type = std_remove_cv_t;
pub type std__Iterator_traits_pointer_base_difference_type = isize;
pub type std__Iterator_traits_pointer_base_pointer<_Ty> = *mut _Ty;
pub type std__Iterator_traits_pointer_base_reference<_Ty> = *mut _Ty;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_iterator_traits {
pub _address: u8,
}
pub type std__Iter_ref_t = std_iterator_traits;
pub type std__Iter_value_t = std_iterator_traits;
pub type std__Iter_diff_t = std_iterator_traits;
pub type std__Common_diff_t = std_common_type_t;
pub type std__Iter_cat_t = std_iterator_traits;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Is_iterator {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Is_checked_helper {
pub _address: u8,
}
pub type std__Unwrapped_t = std__Remove_cvref_t;
pub type std__Unwrapped_unverified_t = std__Remove_cvref_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Distance_unknown {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std__Distance_unknown() {
assert_eq!(
::std::mem::size_of::<std__Distance_unknown>(),
1usize,
concat!("Size of: ", stringify!(std__Distance_unknown))
);
assert_eq!(
::std::mem::align_of::<std__Distance_unknown>(),
1usize,
concat!("Alignment of ", stringify!(std__Distance_unknown))
);
}
pub type std__Unwrapped_n_t = std__Remove_cvref_t;
pub type std__Unwrap_enum_type = std_underlying_type_t;
pub type std__Unwrap_enum_t = u8;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_reverse_iterator<_BidIt> {
pub current: _BidIt,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_BidIt>>,
}
pub type std_reverse_iterator_iterator_type<_BidIt> = _BidIt;
pub type std_reverse_iterator_iterator_category = std__Iter_cat_t;
pub type std_reverse_iterator_value_type = std__Iter_value_t;
pub type std_reverse_iterator_difference_type = std__Iter_diff_t;
pub type std_reverse_iterator_pointer = std_iterator_traits;
pub type std_reverse_iterator_reference = std__Iter_ref_t;
pub type std_reverse_iterator__Prevent_inheriting_unwrap<_BidIt> = std_reverse_iterator<_BidIt>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Default_sentinel {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std__Default_sentinel() {
assert_eq!(
::std::mem::size_of::<std__Default_sentinel>(),
1usize,
concat!("Size of: ", stringify!(std__Default_sentinel))
);
assert_eq!(
::std::mem::align_of::<std__Default_sentinel>(),
1usize,
concat!("Alignment of ", stringify!(std__Default_sentinel))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_move_iterator<_Iter> {
pub current: std_move_iterator_iterator_type<_Iter>,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Iter>>,
}
pub type std_move_iterator_iterator_type<_Iter> = _Iter;
pub type std_move_iterator_iterator_category = std__Iter_cat_t;
pub type std_move_iterator_value_type = std__Iter_value_t;
pub type std_move_iterator_difference_type = std__Iter_diff_t;
pub type std_move_iterator_pointer<_Iter> = _Iter;
pub type std_move_iterator_reference = std_conditional_t;
pub type std_move_iterator__Prevent_inheriting_unwrap<_Iter> = std_move_iterator<_Iter>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Ptr_cat_helper {
pub _address: u8,
}
pub type std__Ptr_cat_helper__USource = std__Unwrap_enum_t;
pub type std__Ptr_cat_helper__UDest = std__Unwrap_enum_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__False_copy_cat {
pub _address: u8,
}
pub const std__False_copy_cat__Really_trivial: bool = false;
pub const std__False_copy_cat__Trivially_copyable: bool = false;
#[test]
fn bindgen_test_layout_std__False_copy_cat() {
assert_eq!(
::std::mem::size_of::<std__False_copy_cat>(),
1usize,
concat!("Size of: ", stringify!(std__False_copy_cat))
);
assert_eq!(
::std::mem::align_of::<std__False_copy_cat>(),
1usize,
concat!("Alignment of ", stringify!(std__False_copy_cat))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Ptr_copy_cat {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Ptr_move_cat {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Is_character {
pub _base: std_false_type,
}
#[test]
fn __bindgen_test_layout_std__Is_character_open0_char_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std__Is_character>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std__Is_character)
)
);
assert_eq!(
::std::mem::align_of::<std__Is_character>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std__Is_character)
)
);
}
#[test]
fn __bindgen_test_layout_std__Is_character_open0_signed_char_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std__Is_character>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std__Is_character)
)
);
assert_eq!(
::std::mem::align_of::<std__Is_character>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std__Is_character)
)
);
}
#[test]
fn __bindgen_test_layout_std__Is_character_open0_unsigned_char_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std__Is_character>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std__Is_character)
)
);
assert_eq!(
::std::mem::align_of::<std__Is_character>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std__Is_character)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Is_character_or_byte {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Value_equality_is_bitwise_equality {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Equal_memcmp_is_safe_helper {
pub _base: std_false_type,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Lex_compare_check_element_types_helper {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Lex_compare_optimize {
pub _address: u8,
}
pub type std__Lex_compare_check_element_types = std__Lex_compare_optimize;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Rng_from_urng<_Urng> {
pub _Ref: *mut _Urng,
pub _Bits: size_t,
pub _Bmask: std__Rng_from_urng__Udiff,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Urng>>,
}
pub type std__Rng_from_urng__Ty0 = std_make_unsigned_t;
pub type std__Rng_from_urng__Ty1 = [u8; 0usize];
pub type std__Rng_from_urng__Udiff = std_conditional_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Has_allocator_type {
pub _base: std_false_type,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_allocator_arg_t {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std_allocator_arg_t() {
assert_eq!(
::std::mem::size_of::<std_allocator_arg_t>(),
1usize,
concat!("Size of: ", stringify!(std_allocator_arg_t))
);
assert_eq!(
::std::mem::align_of::<std_allocator_arg_t>(),
1usize,
concat!("Alignment of ", stringify!(std_allocator_arg_t))
);
}
extern "C" {
#[link_name = "\u{1}?allocator_arg@std@@3Uallocator_arg_t@1@B"]
pub static std_allocator_arg: std_allocator_arg_t;
}
extern "C" {
#[link_name = "\u{1}?_Xbad_alloc@std@@YAXXZ"]
pub fn std__Xbad_alloc();
}
extern "C" {
#[link_name = "\u{1}?_Xinvalid_argument@std@@YAXPEBD@Z"]
pub fn std__Xinvalid_argument(arg1: *const ::std::os::raw::c_char);
}
extern "C" {
#[link_name = "\u{1}?_Xlength_error@std@@YAXPEBD@Z"]
pub fn std__Xlength_error(arg1: *const ::std::os::raw::c_char);
}
extern "C" {
#[link_name = "\u{1}?_Xout_of_range@std@@YAXPEBD@Z"]
pub fn std__Xout_of_range(arg1: *const ::std::os::raw::c_char);
}
extern "C" {
#[link_name = "\u{1}?_Xoverflow_error@std@@YAXPEBD@Z"]
pub fn std__Xoverflow_error(arg1: *const ::std::os::raw::c_char);
}
extern "C" {
#[link_name = "\u{1}?_Xruntime_error@std@@YAXPEBD@Z"]
pub fn std__Xruntime_error(arg1: *const ::std::os::raw::c_char);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_uses_allocator {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_iterator {
pub _address: u8,
}
pub type std_iterator_iterator_category<_Category> = _Category;
pub type std_iterator_value_type<_Ty> = _Ty;
pub type std_iterator_difference_type<_Diff> = _Diff;
pub type std_iterator_pointer<_Pointer> = _Pointer;
pub type std_iterator_reference<_Reference> = _Reference;
#[repr(C)]
#[derive(Debug)]
pub struct std__Tidy_guard<_Ty> {
pub _Target: *mut _Ty,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Ty>>,
}
#[repr(C)]
#[derive(Debug)]
pub struct std__Tidy_deallocate_guard<_Ty> {
pub _Target: *mut _Ty,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Ty>>,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Default_allocate_traits {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std__Default_allocate_traits() {
assert_eq!(
::std::mem::size_of::<std__Default_allocate_traits>(),
1usize,
concat!("Size of: ", stringify!(std__Default_allocate_traits))
);
assert_eq!(
::std::mem::align_of::<std__Default_allocate_traits>(),
1usize,
concat!("Alignment of ", stringify!(std__Default_allocate_traits))
);
}
pub const std__Big_allocation_threshold: size_t = 4096;
pub const std__Big_allocation_alignment: size_t = 32;
pub const std__Non_user_size: size_t = 39;
pub const std__Big_allocation_sentinel: size_t = 18085043209519168250;
pub type std__Rebind_pointer_t = std_pointer_traits;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Get_pointer_type {
pub _address: u8,
}
pub type std__Get_pointer_type_type = *mut [u8; 0usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Get_const_pointer_type {
pub _address: u8,
}
pub type std__Get_const_pointer_type__Ptrty = std__Get_pointer_type;
pub type std__Get_const_pointer_type__Valty = [u8; 0usize];
pub type std__Get_const_pointer_type_type = [u8; 0usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Get_void_pointer_type {
pub _address: u8,
}
pub type std__Get_void_pointer_type__Ptrty = std__Get_pointer_type;
pub type std__Get_void_pointer_type_type = std_pointer_traits;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Get_const_void_pointer_type {
pub _address: u8,
}
pub type std__Get_const_void_pointer_type__Ptrty = std__Get_pointer_type;
pub type std__Get_const_void_pointer_type_type = std_pointer_traits;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Get_difference_type {
pub _address: u8,
}
pub type std__Get_difference_type__Ptrty = std__Get_pointer_type;
pub type std__Get_difference_type_type = std_pointer_traits;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Get_size_type {
pub _address: u8,
}
pub type std__Get_size_type_type = std_make_unsigned_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Get_propagate_on_container_copy {
pub _address: u8,
}
pub type std__Get_propagate_on_container_copy_type = std_false_type;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Get_propagate_on_container_move {
pub _address: u8,
}
pub type std__Get_propagate_on_container_move_type = std_false_type;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Get_propagate_on_container_swap {
pub _address: u8,
}
pub type std__Get_propagate_on_container_swap_type = std_false_type;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Get_is_always_equal {
pub _address: u8,
}
pub type std__Get_is_always_equal_type = std_is_empty;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Get_rebind_type {
pub _address: u8,
}
pub type std__Get_rebind_type_type = std__Replace_first_parameter;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Is_default_allocator {
pub _base: std_false_type,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Has_no_allocator_construct {
pub _base: std_true_type,
}
pub type std__Uses_default_construct = std_disjunction;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Has_no_alloc_destroy {
pub _base: std_true_type,
}
pub type std__Uses_default_destroy = std_disjunction;
pub type std__Uses_default_destroy_t = std__Uses_default_destroy;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Has_allocate_hint {
pub _base: std_false_type,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Has_max_size {
pub _base: std_false_type,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Has_select_on_container_copy_construction {
pub _base: std_false_type,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Normal_allocator_traits {
pub _address: u8,
}
pub type std__Normal_allocator_traits_allocator_type<_Alloc> = _Alloc;
pub type std__Normal_allocator_traits_value_type = [u8; 0usize];
pub type std__Normal_allocator_traits_pointer = std__Get_pointer_type;
pub type std__Normal_allocator_traits_const_pointer = std__Get_const_pointer_type;
pub type std__Normal_allocator_traits_void_pointer = std__Get_void_pointer_type;
pub type std__Normal_allocator_traits_const_void_pointer = std__Get_const_void_pointer_type;
pub type std__Normal_allocator_traits_size_type = std__Get_size_type;
pub type std__Normal_allocator_traits_difference_type = std__Get_difference_type;
pub type std__Normal_allocator_traits_propagate_on_container_copy_assignment =
std__Get_propagate_on_container_copy;
pub type std__Normal_allocator_traits_propagate_on_container_move_assignment =
std__Get_propagate_on_container_move;
pub type std__Normal_allocator_traits_propagate_on_container_swap =
std__Get_propagate_on_container_swap;
pub type std__Normal_allocator_traits_is_always_equal = std__Get_is_always_equal;
pub type std__Normal_allocator_traits_rebind_alloc = std__Get_rebind_type;
pub type std__Normal_allocator_traits_rebind_traits = std_allocator_traits;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Default_allocator_traits {
pub _address: u8,
}
pub type std__Default_allocator_traits_allocator_type<_Alloc> = _Alloc;
pub type std__Default_allocator_traits_value_type = [u8; 0usize];
pub type std__Default_allocator_traits_pointer = *mut std__Default_allocator_traits_value_type;
pub type std__Default_allocator_traits_const_pointer =
*const std__Default_allocator_traits_value_type;
pub type std__Default_allocator_traits_void_pointer = *mut ::std::os::raw::c_void;
pub type std__Default_allocator_traits_const_void_pointer = *const ::std::os::raw::c_void;
pub type std__Default_allocator_traits_size_type = size_t;
pub type std__Default_allocator_traits_difference_type = isize;
pub type std__Default_allocator_traits_propagate_on_container_copy_assignment = std_false_type;
pub type std__Default_allocator_traits_propagate_on_container_move_assignment = std_true_type;
pub type std__Default_allocator_traits_propagate_on_container_swap = std_false_type;
pub type std__Default_allocator_traits_is_always_equal = std_true_type;
pub type std__Default_allocator_traits_rebind_alloc = std_allocator;
pub type std__Default_allocator_traits_rebind_traits = std_allocator_traits;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_allocator_traits {
pub _address: u8,
}
pub type std__Choose_pocca = std_bool_constant;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Equal_allocators {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std__Equal_allocators() {
assert_eq!(
::std::mem::size_of::<std__Equal_allocators>(),
1usize,
concat!("Size of: ", stringify!(std__Equal_allocators))
);
assert_eq!(
::std::mem::align_of::<std__Equal_allocators>(),
1usize,
concat!("Alignment of ", stringify!(std__Equal_allocators))
);
}
pub type std__Propagate_allocators = std_true_type;
pub type std__No_propagate_allocators = std_false_type;
pub type std__Choose_pocma = std_conditional_t;
pub type std__Rebind_alloc_t = std_allocator_traits;
pub type std__Maybe_rebind_alloc_t = u8;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Simple_types {
pub _address: u8,
}
pub type std__Simple_types_value_type<_Value_type> = _Value_type;
pub type std__Simple_types_size_type = size_t;
pub type std__Simple_types_difference_type = isize;
pub type std__Simple_types_pointer<_Value_type> = *mut std__Simple_types_value_type<_Value_type>;
pub type std__Simple_types_const_pointer<_Value_type> =
*const std__Simple_types_value_type<_Value_type>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_allocator {
pub _address: u8,
}
pub type std_allocator__From_primary = std_allocator;
pub type std_allocator_value_type<_Ty> = _Ty;
pub type std_allocator_pointer<_Ty> = *mut _Ty;
pub type std_allocator_const_pointer<_Ty> = *const _Ty;
pub type std_allocator_reference<_Ty> = *mut _Ty;
pub type std_allocator_const_reference<_Ty> = *const _Ty;
pub type std_allocator_size_type = size_t;
pub type std_allocator_difference_type = isize;
pub type std_allocator_propagate_on_container_move_assignment = std_true_type;
pub type std_allocator_is_always_equal = std_true_type;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_allocator_rebind {
pub _address: u8,
}
pub type std_allocator_rebind_other = std_allocator;
#[test]
fn __bindgen_test_layout_std_allocator_open0_void_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_allocator>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_allocator)
)
);
assert_eq!(
::std::mem::align_of::<std_allocator>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_allocator)
)
);
}
pub type std__Alloc_ptr_t = std_allocator_traits;
pub type std__Alloc_size_t = std_allocator_traits;
#[repr(C)]
#[derive(Debug)]
pub struct std__Alloc_construct_ptr<_Alloc> {
pub _Al: *mut _Alloc,
pub _Ptr: std__Alloc_construct_ptr_pointer,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Alloc>>,
}
pub type std__Alloc_construct_ptr_pointer = std__Alloc_ptr_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Fake_allocator {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std__Fake_allocator() {
assert_eq!(
::std::mem::size_of::<std__Fake_allocator>(),
1usize,
concat!("Size of: ", stringify!(std__Fake_allocator))
);
assert_eq!(
::std::mem::align_of::<std__Fake_allocator>(),
1usize,
concat!("Alignment of ", stringify!(std__Fake_allocator))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Container_base0 {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std__Container_base0() {
assert_eq!(
::std::mem::size_of::<std__Container_base0>(),
1usize,
concat!("Size of: ", stringify!(std__Container_base0))
);
assert_eq!(
::std::mem::align_of::<std__Container_base0>(),
1usize,
concat!("Alignment of ", stringify!(std__Container_base0))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Iterator_base0 {
pub _address: u8,
}
pub const std__Iterator_base0__Unwrap_when_unverified: bool = true;
#[test]
fn bindgen_test_layout_std__Iterator_base0() {
assert_eq!(
::std::mem::size_of::<std__Iterator_base0>(),
1usize,
concat!("Size of: ", stringify!(std__Iterator_base0))
);
assert_eq!(
::std::mem::align_of::<std__Iterator_base0>(),
1usize,
concat!("Alignment of ", stringify!(std__Iterator_base0))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Container_proxy {
pub _Mycont: *const std__Container_base12,
pub _Myfirstiter: *mut std__Iterator_base12,
}
#[test]
fn bindgen_test_layout_std__Container_proxy() {
assert_eq!(
::std::mem::size_of::<std__Container_proxy>(),
16usize,
concat!("Size of: ", stringify!(std__Container_proxy))
);
assert_eq!(
::std::mem::align_of::<std__Container_proxy>(),
8usize,
concat!("Alignment of ", stringify!(std__Container_proxy))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<std__Container_proxy>()))._Mycont as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(std__Container_proxy),
"::",
stringify!(_Mycont)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<std__Container_proxy>()))._Myfirstiter as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(std__Container_proxy),
"::",
stringify!(_Myfirstiter)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Container_base12 {
pub _Myproxy: *mut std__Container_proxy,
}
#[test]
fn bindgen_test_layout_std__Container_base12() {
assert_eq!(
::std::mem::size_of::<std__Container_base12>(),
8usize,
concat!("Size of: ", stringify!(std__Container_base12))
);
assert_eq!(
::std::mem::align_of::<std__Container_base12>(),
8usize,
concat!("Alignment of ", stringify!(std__Container_base12))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<std__Container_base12>()))._Myproxy as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(std__Container_base12),
"::",
stringify!(_Myproxy)
)
);
}
extern "C" {
#[link_name = "\u{1}?_Orphan_all@_Container_base12@std@@QEAAXXZ"]
pub fn std__Container_base12__Orphan_all(this: *mut std__Container_base12);
}
extern "C" {
#[link_name = "\u{1}?_Swap_proxy_and_iterators@_Container_base12@std@@QEAAXAEAU12@@Z"]
pub fn std__Container_base12__Swap_proxy_and_iterators(
this: *mut std__Container_base12,
arg1: *mut std__Container_base12,
);
}
impl std__Container_base12 {
#[inline]
pub unsafe fn _Orphan_all(&mut self) {
std__Container_base12__Orphan_all(self)
}
#[inline]
pub unsafe fn _Swap_proxy_and_iterators(&mut self, arg1: *mut std__Container_base12) {
std__Container_base12__Swap_proxy_and_iterators(self, arg1)
}
}
#[repr(C)]
#[derive(Debug)]
pub struct std__Iterator_base12 {
pub _Myproxy: *mut std__Container_proxy,
pub _Mynextiter: *mut std__Iterator_base12,
}
pub const std__Iterator_base12__Unwrap_when_unverified: bool = true;
#[test]
fn bindgen_test_layout_std__Iterator_base12() {
assert_eq!(
::std::mem::size_of::<std__Iterator_base12>(),
16usize,
concat!("Size of: ", stringify!(std__Iterator_base12))
);
assert_eq!(
::std::mem::align_of::<std__Iterator_base12>(),
8usize,
concat!("Alignment of ", stringify!(std__Iterator_base12))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<std__Iterator_base12>()))._Myproxy as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(std__Iterator_base12),
"::",
stringify!(_Myproxy)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<std__Iterator_base12>()))._Mynextiter as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(std__Iterator_base12),
"::",
stringify!(_Mynextiter)
)
);
}
pub type std__Container_base = std__Container_base0;
pub type std__Iterator_base = std__Iterator_base0;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Leave_proxy_unbound {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std__Leave_proxy_unbound() {
assert_eq!(
::std::mem::size_of::<std__Leave_proxy_unbound>(),
1usize,
concat!("Size of: ", stringify!(std__Leave_proxy_unbound))
);
assert_eq!(
::std::mem::align_of::<std__Leave_proxy_unbound>(),
1usize,
concat!("Alignment of ", stringify!(std__Leave_proxy_unbound))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Fake_proxy_ptr_impl {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std__Fake_proxy_ptr_impl() {
assert_eq!(
::std::mem::size_of::<std__Fake_proxy_ptr_impl>(),
1usize,
concat!("Size of: ", stringify!(std__Fake_proxy_ptr_impl))
);
assert_eq!(
::std::mem::align_of::<std__Fake_proxy_ptr_impl>(),
1usize,
concat!("Alignment of ", stringify!(std__Fake_proxy_ptr_impl))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Basic_container_proxy_ptr12 {
pub _Ptr: *mut std__Container_proxy,
}
#[test]
fn bindgen_test_layout_std__Basic_container_proxy_ptr12() {
assert_eq!(
::std::mem::size_of::<std__Basic_container_proxy_ptr12>(),
8usize,
concat!("Size of: ", stringify!(std__Basic_container_proxy_ptr12))
);
assert_eq!(
::std::mem::align_of::<std__Basic_container_proxy_ptr12>(),
8usize,
concat!(
"Alignment of ",
stringify!(std__Basic_container_proxy_ptr12)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<std__Basic_container_proxy_ptr12>()))._Ptr as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(std__Basic_container_proxy_ptr12),
"::",
stringify!(_Ptr)
)
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std__Container_proxy_ptr12<_Alloc> {
pub _base: std__Basic_container_proxy_ptr12,
pub _Al: *mut _Alloc,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Alloc>>,
}
pub type std__Container_proxy_ptr = std__Fake_proxy_ptr_impl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Zero_then_variadic_args_t {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std__Zero_then_variadic_args_t() {
assert_eq!(
::std::mem::size_of::<std__Zero_then_variadic_args_t>(),
1usize,
concat!("Size of: ", stringify!(std__Zero_then_variadic_args_t))
);
assert_eq!(
::std::mem::align_of::<std__Zero_then_variadic_args_t>(),
1usize,
concat!("Alignment of ", stringify!(std__Zero_then_variadic_args_t))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__One_then_variadic_args_t {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std__One_then_variadic_args_t() {
assert_eq!(
::std::mem::size_of::<std__One_then_variadic_args_t>(),
1usize,
concat!("Size of: ", stringify!(std__One_then_variadic_args_t))
);
assert_eq!(
::std::mem::align_of::<std__One_then_variadic_args_t>(),
1usize,
concat!("Alignment of ", stringify!(std__One_then_variadic_args_t))
);
}
pub type std__Compressed_pair__Mybase<_Ty1> = _Ty1;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Move_allocator_tag {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std__Move_allocator_tag() {
assert_eq!(
::std::mem::size_of::<std__Move_allocator_tag>(),
1usize,
concat!("Size of: ", stringify!(std__Move_allocator_tag))
);
assert_eq!(
::std::mem::align_of::<std__Move_allocator_tag>(),
1usize,
concat!("Alignment of ", stringify!(std__Move_allocator_tag))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std__Uninitialized_backout<_NoThrowFwdIt> {
pub _First: _NoThrowFwdIt,
pub _Last: _NoThrowFwdIt,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_NoThrowFwdIt>>,
}
#[repr(C)]
#[derive(Debug)]
pub struct std__Uninitialized_backout_al<_Alloc> {
pub _First: std__Uninitialized_backout_al_pointer,
pub _Last: std__Uninitialized_backout_al_pointer,
pub _Al: *mut _Alloc,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Alloc>>,
}
pub type std__Uninitialized_backout_al_pointer = std__Alloc_ptr_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__In_place_key_extract_set {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__In_place_key_extract_map {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Wrap<_Ty> {
pub _Value: _Ty,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Ty>>,
}
#[repr(C)]
pub struct std__Alloc_temporary<_Alloc> {
pub _Al: *mut _Alloc,
pub __bindgen_anon_1: std__Alloc_temporary__bindgen_ty_1,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Alloc>>,
}
pub type std__Alloc_temporary_value_type = [u8; 0usize];
pub type std__Alloc_temporary__Traits = std_allocator_traits;
#[repr(C)]
pub struct std__Alloc_temporary__bindgen_ty_1 {
pub _Storage: __BindgenUnionField<std__Wrap<std__Alloc_temporary_value_type>>,
pub bindgen_union_field: [u8; 0usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Char_traits {
pub _address: u8,
}
pub type std__Char_traits_char_type<_Elem> = _Elem;
pub type std__Char_traits_int_type<_Int_type> = _Int_type;
pub type std__Char_traits_pos_type = std_streampos;
pub type std__Char_traits_off_type = std_streamoff;
pub type std__Char_traits_state_type = _Mbstatet;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__WChar_traits {
pub _address: u8,
}
pub type std__WChar_traits_char_type<_Elem> = _Elem;
pub type std__WChar_traits_int_type = ::std::os::raw::c_ushort;
pub type std__WChar_traits_pos_type = std_streampos;
pub type std__WChar_traits_off_type = std_streamoff;
pub type std__WChar_traits_state_type = mbstate_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_char_traits {
pub _address: u8,
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char16_t_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
pub type std_u16streampos = std_streampos;
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char32_t_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
pub type std_u32streampos = std_streampos;
#[test]
fn __bindgen_test_layout_std_char_traits_open0_wchar_t_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_unsigned_short_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Narrow_char_traits {
pub _address: u8,
}
pub type std__Narrow_char_traits_char_type<_Elem> = _Elem;
pub type std__Narrow_char_traits_int_type<_Int_type> = _Int_type;
pub type std__Narrow_char_traits_pos_type = std_streampos;
pub type std__Narrow_char_traits_off_type = std_streamoff;
pub type std__Narrow_char_traits_state_type = mbstate_t;
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Char_traits_eq {
pub _address: u8,
}
pub type std__Char_traits_eq__Elem = [u8; 0usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Char_traits_lt {
pub _address: u8,
}
pub type std__Char_traits_lt__Elem = [u8; 0usize];
pub type std__Traits_ch_t = [u8; 0usize];
pub type std__Traits_ptr_t = *const [u8; 0usize];
#[repr(C)]
pub struct std__String_const_iterator {
pub _Ptr: std__String_const_iterator_pointer,
}
pub type std__String_const_iterator_iterator_category = std_random_access_iterator_tag;
pub type std__String_const_iterator_value_type = [u8; 0usize];
pub type std__String_const_iterator_difference_type = [u8; 0usize];
pub type std__String_const_iterator_pointer = [u8; 0usize];
pub type std__String_const_iterator_reference = *const std__String_const_iterator_value_type;
pub type std__String_const_iterator__Prevent_inheriting_unwrap = std__String_const_iterator;
#[repr(C)]
pub struct std__String_iterator {
pub _base: std__String_const_iterator,
}
pub type std__String_iterator__Mybase = std__String_const_iterator;
pub type std__String_iterator_iterator_category = std_random_access_iterator_tag;
pub type std__String_iterator_value_type = [u8; 0usize];
pub type std__String_iterator_difference_type = [u8; 0usize];
pub type std__String_iterator_pointer = [u8; 0usize];
pub type std__String_iterator_reference = *mut std__String_iterator_value_type;
pub type std__String_iterator__Prevent_inheriting_unwrap = std__String_iterator;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__String_iter_types {
pub _address: u8,
}
pub type std__String_iter_types_value_type<_Value_type> = _Value_type;
pub type std__String_iter_types_size_type<_Size_type> = _Size_type;
pub type std__String_iter_types_difference_type<_Difference_type> = _Difference_type;
pub type std__String_iter_types_pointer<_Pointer> = _Pointer;
pub type std__String_iter_types_const_pointer<_Const_pointer> = _Const_pointer;
#[repr(C)]
pub struct std__String_val {
pub _Bx: std__String_val__Bxty,
pub _Mysize: std__String_val_size_type,
pub _Myres: std__String_val_size_type,
}
pub type std__String_val_value_type = [u8; 0usize];
pub type std__String_val_size_type = [u8; 0usize];
pub type std__String_val_difference_type = [u8; 0usize];
pub type std__String_val_pointer = [u8; 0usize];
pub type std__String_val_const_pointer = [u8; 0usize];
pub type std__String_val_reference = *mut std__String_val_value_type;
pub type std__String_val_const_reference = *const std__String_val_value_type;
#[repr(C)]
pub struct std__String_val__Bxty {
pub _Buf: __BindgenUnionField<*mut std__String_val_value_type>,
pub _Ptr: __BindgenUnionField<std__String_val_pointer>,
pub _Alias: __BindgenUnionField<*mut ::std::os::raw::c_char>,
pub bindgen_union_field: u64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__String_constructor_concat_tag {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std__String_constructor_concat_tag() {
assert_eq!(
::std::mem::size_of::<std__String_constructor_concat_tag>(),
1usize,
concat!("Size of: ", stringify!(std__String_constructor_concat_tag))
);
assert_eq!(
::std::mem::align_of::<std__String_constructor_concat_tag>(),
1usize,
concat!(
"Alignment of ",
stringify!(std__String_constructor_concat_tag)
)
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std_basic_string {
pub _Mypair: u8,
}
pub type std_basic_string__Alty = std__Rebind_alloc_t;
pub type std_basic_string__Alty_traits = std_allocator_traits;
pub type std_basic_string__Scary_val = std__String_val;
pub type std_basic_string_traits_type<_Traits> = _Traits;
pub type std_basic_string_allocator_type<_Alloc> = _Alloc;
pub type std_basic_string_value_type<_Elem> = _Elem;
pub type std_basic_string_size_type = std_basic_string__Alty_traits;
pub type std_basic_string_difference_type = std_basic_string__Alty_traits;
pub type std_basic_string_pointer = std_basic_string__Alty_traits;
pub type std_basic_string_const_pointer = std_basic_string__Alty_traits;
pub type std_basic_string_reference<_Elem> = *mut std_basic_string_value_type<_Elem>;
pub type std_basic_string_const_reference<_Elem> = *const std_basic_string_value_type<_Elem>;
pub type std_basic_string_iterator = std__String_iterator;
pub type std_basic_string_const_iterator = std__String_const_iterator;
pub type std_basic_string_reverse_iterator = std_reverse_iterator<std_basic_string_iterator>;
pub type std_basic_string_const_reverse_iterator =
std_reverse_iterator<std_basic_string_const_iterator>;
pub type std_basic_string__Is_elem_cptr = std_bool_constant;
pub type std_string = std_basic_string;
pub type std_wstring = std_basic_string;
pub type std_u16string = std_basic_string;
pub type std_u32string = std_basic_string;
#[repr(C)]
#[derive(Debug)]
pub struct std_logic_error {
pub _base: std_exception,
}
pub type std_logic_error__Mybase = std_exception;
#[test]
fn bindgen_test_layout_std_logic_error() {
assert_eq!(
::std::mem::size_of::<std_logic_error>(),
24usize,
concat!("Size of: ", stringify!(std_logic_error))
);
assert_eq!(
::std::mem::align_of::<std_logic_error>(),
8usize,
concat!("Alignment of ", stringify!(std_logic_error))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std_domain_error {
pub _base: std_logic_error,
}
pub type std_domain_error__Mybase = std_logic_error;
#[test]
fn bindgen_test_layout_std_domain_error() {
assert_eq!(
::std::mem::size_of::<std_domain_error>(),
24usize,
concat!("Size of: ", stringify!(std_domain_error))
);
assert_eq!(
::std::mem::align_of::<std_domain_error>(),
8usize,
concat!("Alignment of ", stringify!(std_domain_error))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std_invalid_argument {
pub _base: std_logic_error,
}
pub type std_invalid_argument__Mybase = std_logic_error;
#[test]
fn bindgen_test_layout_std_invalid_argument() {
assert_eq!(
::std::mem::size_of::<std_invalid_argument>(),
24usize,
concat!("Size of: ", stringify!(std_invalid_argument))
);
assert_eq!(
::std::mem::align_of::<std_invalid_argument>(),
8usize,
concat!("Alignment of ", stringify!(std_invalid_argument))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std_length_error {
pub _base: std_logic_error,
}
pub type std_length_error__Mybase = std_logic_error;
#[test]
fn bindgen_test_layout_std_length_error() {
assert_eq!(
::std::mem::size_of::<std_length_error>(),
24usize,
concat!("Size of: ", stringify!(std_length_error))
);
assert_eq!(
::std::mem::align_of::<std_length_error>(),
8usize,
concat!("Alignment of ", stringify!(std_length_error))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std_out_of_range {
pub _base: std_logic_error,
}
pub type std_out_of_range__Mybase = std_logic_error;
#[test]
fn bindgen_test_layout_std_out_of_range() {
assert_eq!(
::std::mem::size_of::<std_out_of_range>(),
24usize,
concat!("Size of: ", stringify!(std_out_of_range))
);
assert_eq!(
::std::mem::align_of::<std_out_of_range>(),
8usize,
concat!("Alignment of ", stringify!(std_out_of_range))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std_runtime_error {
pub _base: std_exception,
}
pub type std_runtime_error__Mybase = std_exception;
#[test]
fn bindgen_test_layout_std_runtime_error() {
assert_eq!(
::std::mem::size_of::<std_runtime_error>(),
24usize,
concat!("Size of: ", stringify!(std_runtime_error))
);
assert_eq!(
::std::mem::align_of::<std_runtime_error>(),
8usize,
concat!("Alignment of ", stringify!(std_runtime_error))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std_overflow_error {
pub _base: std_runtime_error,
}
pub type std_overflow_error__Mybase = std_runtime_error;
#[test]
fn bindgen_test_layout_std_overflow_error() {
assert_eq!(
::std::mem::size_of::<std_overflow_error>(),
24usize,
concat!("Size of: ", stringify!(std_overflow_error))
);
assert_eq!(
::std::mem::align_of::<std_overflow_error>(),
8usize,
concat!("Alignment of ", stringify!(std_overflow_error))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std_underflow_error {
pub _base: std_runtime_error,
}
pub type std_underflow_error__Mybase = std_runtime_error;
#[test]
fn bindgen_test_layout_std_underflow_error() {
assert_eq!(
::std::mem::size_of::<std_underflow_error>(),
24usize,
concat!("Size of: ", stringify!(std_underflow_error))
);
assert_eq!(
::std::mem::align_of::<std_underflow_error>(),
8usize,
concat!("Alignment of ", stringify!(std_underflow_error))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std_range_error {
pub _base: std_runtime_error,
}
pub type std_range_error__Mybase = std_runtime_error;
#[test]
fn bindgen_test_layout_std_range_error() {
assert_eq!(
::std::mem::size_of::<std_range_error>(),
24usize,
concat!("Size of: ", stringify!(std_range_error))
);
assert_eq!(
::std::mem::align_of::<std_range_error>(),
8usize,
concat!("Alignment of ", stringify!(std_range_error))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std_bad_cast {
pub _base: std_exception,
}
#[test]
fn bindgen_test_layout_std_bad_cast() {
assert_eq!(
::std::mem::size_of::<std_bad_cast>(),
24usize,
concat!("Size of: ", stringify!(std_bad_cast))
);
assert_eq!(
::std::mem::align_of::<std_bad_cast>(),
8usize,
concat!("Alignment of ", stringify!(std_bad_cast))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std_bad_typeid {
pub _base: std_exception,
}
#[test]
fn bindgen_test_layout_std_bad_typeid() {
assert_eq!(
::std::mem::size_of::<std_bad_typeid>(),
24usize,
concat!("Size of: ", stringify!(std_bad_typeid))
);
assert_eq!(
::std::mem::align_of::<std_bad_typeid>(),
8usize,
concat!("Alignment of ", stringify!(std_bad_typeid))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std___non_rtti_object {
pub _base: std_bad_typeid,
}
#[test]
fn bindgen_test_layout_std___non_rtti_object() {
assert_eq!(
::std::mem::size_of::<std___non_rtti_object>(),
24usize,
concat!("Size of: ", stringify!(std___non_rtti_object))
);
assert_eq!(
::std::mem::align_of::<std___non_rtti_object>(),
8usize,
concat!("Alignment of ", stringify!(std___non_rtti_object))
);
}
pub const std__Small_object_num_ptrs: ::std::os::raw::c_int = 8;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_raw_storage_iterator<_OutIt> {
pub _Next: _OutIt,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_OutIt>>,
}
pub type std_raw_storage_iterator_iterator_category = std_output_iterator_tag;
pub type std_raw_storage_iterator_value_type = ::std::os::raw::c_void;
pub type std_raw_storage_iterator_difference_type = ::std::os::raw::c_void;
pub type std_raw_storage_iterator_pointer = ::std::os::raw::c_void;
pub type std_raw_storage_iterator_reference = ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_auto_ptr_ref<_Ty> {
pub _Ref: *mut _Ty,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Ty>>,
}
#[repr(C)]
#[derive(Debug)]
pub struct std_auto_ptr<_Ty> {
pub _Myptr: *mut _Ty,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Ty>>,
}
pub type std_auto_ptr_element_type<_Ty> = _Ty;
#[test]
fn __bindgen_test_layout_std_auto_ptr_open0_void_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_auto_ptr<::std::os::raw::c_void>>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_auto_ptr<::std::os::raw::c_void>)
)
);
assert_eq!(
::std::mem::align_of::<std_auto_ptr<::std::os::raw::c_void>>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_auto_ptr<::std::os::raw::c_void>)
)
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std_bad_weak_ptr {
pub _base: std_exception,
}
#[test]
fn bindgen_test_layout_std_bad_weak_ptr() {
assert_eq!(
::std::mem::size_of::<std_bad_weak_ptr>(),
24usize,
concat!("Size of: ", stringify!(std_bad_weak_ptr))
);
assert_eq!(
::std::mem::align_of::<std_bad_weak_ptr>(),
8usize,
concat!("Alignment of ", stringify!(std_bad_weak_ptr))
);
}
#[repr(C)]
pub struct std__Ref_count_base__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug)]
pub struct std__Ref_count_base {
pub vtable_: *const std__Ref_count_base__bindgen_vtable,
pub _Uses: std__Atomic_counter_t,
pub _Weaks: std__Atomic_counter_t,
}
#[test]
fn bindgen_test_layout_std__Ref_count_base() {
assert_eq!(
::std::mem::size_of::<std__Ref_count_base>(),
16usize,
concat!("Size of: ", stringify!(std__Ref_count_base))
);
assert_eq!(
::std::mem::align_of::<std__Ref_count_base>(),
8usize,
concat!("Alignment of ", stringify!(std__Ref_count_base))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<std__Ref_count_base>()))._Uses as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(std__Ref_count_base),
"::",
stringify!(_Uses)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<std__Ref_count_base>()))._Weaks as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(std__Ref_count_base),
"::",
stringify!(_Weaks)
)
);
}
#[repr(C)]
#[derive(Debug)]
pub struct std__Ref_count<_Ty> {
pub _base: std__Ref_count_base,
pub _Ptr: *mut _Ty,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Ty>>,
}
#[repr(C)]
#[derive(Debug)]
pub struct std__Ref_count_resource {
pub _base: std__Ref_count_base,
pub _Mypair: u8,
}
#[repr(C)]
#[derive(Debug)]
pub struct std__Ref_count_resource_alloc {
pub _base: std__Ref_count_base,
pub _Mypair: u8,
}
pub type std__Ref_count_resource_alloc__Myalty = std__Rebind_alloc_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Can_enable_shared {
pub _base: std_false_type,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Exception_ptr_access {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug)]
pub struct std__Ptr_base {
pub _Ptr: *mut std__Ptr_base_element_type,
pub _Rep: *mut std__Ref_count_base,
}
pub type std__Ptr_base_element_type = std_remove_extent_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Can_scalar_delete {
pub _base: std_false_type,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Can_array_delete {
pub _base: std_false_type,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Can_call_function_object {
pub _base: std_false_type,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__SP_convertible {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__SP_pointer_compatible {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug)]
pub struct std__Temporary_owner<_Ux> {
pub _Ptr: *mut _Ux,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Ux>>,
}
#[repr(C)]
#[derive(Debug)]
pub struct std__Temporary_owner_del<_UxptrOrNullptr, _Dx> {
pub _Ptr: _UxptrOrNullptr,
pub _Dt: *mut _Dx,
pub _Call_deleter: bool,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_UxptrOrNullptr>>,
pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Dx>>,
}
#[repr(C)]
#[derive(Debug)]
pub struct std_shared_ptr {
pub _base: std__Ptr_base,
}
pub type std_shared_ptr__Mybase = std__Ptr_base;
#[repr(C)]
pub struct std__Ref_count_obj2<_Ty> {
pub _base: std__Ref_count_base,
pub __bindgen_anon_1: std__Ref_count_obj2__bindgen_ty_1<_Ty>,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Ty>>,
}
#[repr(C)]
pub union std__Ref_count_obj2__bindgen_ty_1<_Ty> {
pub _Storage: std::mem::ManuallyDrop<std__Wrap<_Ty>>,
_bindgen_union_align: [u8; 0usize],
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Ty>>,
}
pub type std__Ebco_base__Mybase<_Ty> = _Ty;
#[repr(C)]
pub struct std__Ref_count_obj_alloc3<_Ty> {
pub _base_1: std__Ref_count_base,
pub __bindgen_anon_1: std__Ref_count_obj_alloc3__bindgen_ty_1<_Ty>,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Ty>>,
}
pub type std__Ref_count_obj_alloc3__Rebound = std__Rebind_alloc_t;
#[repr(C)]
pub union std__Ref_count_obj_alloc3__bindgen_ty_1<_Ty> {
pub _Storage: std::mem::ManuallyDrop<std__Wrap<_Ty>>,
_bindgen_union_align: [u8; 0usize],
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Ty>>,
}
#[repr(C)]
#[derive(Debug)]
pub struct std_weak_ptr {
pub _base: std__Ptr_base,
}
#[repr(C)]
#[derive(Debug)]
pub struct std_enable_shared_from_this {
pub _Wptr: std_weak_ptr,
}
pub type std_enable_shared_from_this__Esft_type = std_enable_shared_from_this;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_default_delete {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Get_deleter_pointer_type {
pub _address: u8,
}
pub type std__Get_deleter_pointer_type_type<_Ty> = *mut _Ty;
pub type std__Unique_ptr_enable_default_t = std_enable_if_t;
#[repr(C)]
#[derive(Debug)]
pub struct std_unique_ptr {
pub _Mypair: u8,
}
pub type std_unique_ptr_pointer = std__Get_deleter_pointer_type;
pub type std_unique_ptr_element_type<_Ty> = _Ty;
pub type std_unique_ptr_deleter_type<_Dx> = _Dx;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Can_stream_unique_ptr {
pub _base: std_false_type,
}
pub const std_pointer_safety_relaxed: std_pointer_safety = 0;
pub const std_pointer_safety_preferred: std_pointer_safety = 1;
pub const std_pointer_safety_strict: std_pointer_safety = 2;
pub type std_pointer_safety = i32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_owner_less {
pub _address: u8,
}
#[test]
fn __bindgen_test_layout_std_owner_less_open0_void_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_owner_less>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_owner_less)
)
);
assert_eq!(
::std::mem::align_of::<std_owner_less>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_owner_less)
)
);
}
extern "C" {
#[link_name = "\u{1}_Lock_shared_ptr_spin_lock"]
pub fn std__Lock_shared_ptr_spin_lock();
}
extern "C" {
#[link_name = "\u{1}_Unlock_shared_ptr_spin_lock"]
pub fn std__Unlock_shared_ptr_spin_lock();
}
#[repr(C)]
#[derive(Debug)]
pub struct std__Shared_ptr_spin_lock {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std__Shared_ptr_spin_lock() {
assert_eq!(
::std::mem::size_of::<std__Shared_ptr_spin_lock>(),
1usize,
concat!("Size of: ", stringify!(std__Shared_ptr_spin_lock))
);
assert_eq!(
::std::mem::align_of::<std__Shared_ptr_spin_lock>(),
1usize,
concat!("Alignment of ", stringify!(std__Shared_ptr_spin_lock))
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char_close0_instantiation_1() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char16_t_close0_instantiation_1() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char32_t_close0_instantiation_1() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_wchar_t_close0_instantiation_1() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_unsigned_short_close0_instantiation_1() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
pub type _HFILE = *mut ::std::os::raw::c_void;
pub type _CRT_REPORT_HOOK = ::std::option::Option<
unsafe extern "C" fn(
arg1: ::std::os::raw::c_int,
arg2: *mut ::std::os::raw::c_char,
arg3: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
pub type _CRT_REPORT_HOOKW = ::std::option::Option<
unsafe extern "C" fn(
arg1: ::std::os::raw::c_int,
arg2: *mut u16,
arg3: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
pub type _CRT_ALLOC_HOOK = ::std::option::Option<
unsafe extern "C" fn(
arg1: ::std::os::raw::c_int,
arg2: *mut ::std::os::raw::c_void,
arg3: size_t,
arg4: ::std::os::raw::c_int,
arg5: ::std::os::raw::c_long,
arg6: *const ::std::os::raw::c_uchar,
arg7: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
pub type _CRT_DUMP_CLIENT =
::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void, arg2: size_t)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _CrtMemBlockHeader {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _CrtMemState {
pub pBlockHeader: *mut _CrtMemBlockHeader,
pub lCounts: [size_t; 5usize],
pub lSizes: [size_t; 5usize],
pub lHighWaterCount: size_t,
pub lTotalCount: size_t,
}
#[test]
fn bindgen_test_layout__CrtMemState() {
assert_eq!(
::std::mem::size_of::<_CrtMemState>(),
104usize,
concat!("Size of: ", stringify!(_CrtMemState))
);
assert_eq!(
::std::mem::align_of::<_CrtMemState>(),
8usize,
concat!("Alignment of ", stringify!(_CrtMemState))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_CrtMemState>())).pBlockHeader as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_CrtMemState),
"::",
stringify!(pBlockHeader)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_CrtMemState>())).lCounts as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_CrtMemState),
"::",
stringify!(lCounts)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_CrtMemState>())).lSizes as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_CrtMemState),
"::",
stringify!(lSizes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_CrtMemState>())).lHighWaterCount as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_CrtMemState),
"::",
stringify!(lHighWaterCount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_CrtMemState>())).lTotalCount as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_CrtMemState),
"::",
stringify!(lTotalCount)
)
);
}
extern "C" {
pub fn _errno() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn _set_errno(_Value: ::std::os::raw::c_int) -> errno_t;
}
extern "C" {
pub fn _get_errno(_Value: *mut ::std::os::raw::c_int) -> errno_t;
}
extern "C" {
pub fn __threadid() -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn __threadhandle() -> usize;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _exception {
pub type_: ::std::os::raw::c_int,
pub name: *mut ::std::os::raw::c_char,
pub arg1: f64,
pub arg2: f64,
pub retval: f64,
}
#[test]
fn bindgen_test_layout__exception() {
assert_eq!(
::std::mem::size_of::<_exception>(),
40usize,
concat!("Size of: ", stringify!(_exception))
);
assert_eq!(
::std::mem::align_of::<_exception>(),
8usize,
concat!("Alignment of ", stringify!(_exception))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_exception>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_exception),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_exception>())).name as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_exception),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_exception>())).arg1 as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_exception),
"::",
stringify!(arg1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_exception>())).arg2 as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_exception),
"::",
stringify!(arg2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_exception>())).retval as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_exception),
"::",
stringify!(retval)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _complex {
pub x: f64,
pub y: f64,
}
#[test]
fn bindgen_test_layout__complex() {
assert_eq!(
::std::mem::size_of::<_complex>(),
16usize,
concat!("Size of: ", stringify!(_complex))
);
assert_eq!(
::std::mem::align_of::<_complex>(),
8usize,
concat!("Alignment of ", stringify!(_complex))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_complex>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_complex),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_complex>())).y as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_complex),
"::",
stringify!(y)
)
);
}
pub type float_t = f32;
pub type double_t = f64;
extern "C" {
pub static _HUGE: f64;
}
extern "C" {
pub fn _fperrraise(_Except: ::std::os::raw::c_int);
}
extern "C" {
pub fn _dclass(_X: f64) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _ldclass(_X: f64) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _fdclass(_X: f32) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _dsign(_X: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _ldsign(_X: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fdsign(_X: f32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _dpcomp(_X: f64, _Y: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _ldpcomp(_X: f64, _Y: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fdpcomp(_X: f32, _Y: f32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _dtest(_Px: *mut f64) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _ldtest(_Px: *mut f64) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _fdtest(_Px: *mut f32) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _d_int(_Px: *mut f64, _Xexp: ::std::os::raw::c_short) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _ld_int(_Px: *mut f64, _Xexp: ::std::os::raw::c_short) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _fd_int(_Px: *mut f32, _Xexp: ::std::os::raw::c_short) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _dscale(_Px: *mut f64, _Lexp: ::std::os::raw::c_long) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _ldscale(_Px: *mut f64, _Lexp: ::std::os::raw::c_long) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _fdscale(_Px: *mut f32, _Lexp: ::std::os::raw::c_long) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _dunscale(_Pex: *mut ::std::os::raw::c_short, _Px: *mut f64) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _ldunscale(_Pex: *mut ::std::os::raw::c_short, _Px: *mut f64)
-> ::std::os::raw::c_short;
}
extern "C" {
pub fn _fdunscale(_Pex: *mut ::std::os::raw::c_short, _Px: *mut f32)
-> ::std::os::raw::c_short;
}
extern "C" {
pub fn _dexp(_Px: *mut f64, _Y: f64, _Eoff: ::std::os::raw::c_long) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _ldexp(_Px: *mut f64, _Y: f64, _Eoff: ::std::os::raw::c_long)
-> ::std::os::raw::c_short;
}
extern "C" {
pub fn _fdexp(_Px: *mut f32, _Y: f32, _Eoff: ::std::os::raw::c_long)
-> ::std::os::raw::c_short;
}
extern "C" {
pub fn _dnorm(_Ps: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _fdnorm(_Ps: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _dpoly(_X: f64, _Tab: *const f64, _N: ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn _ldpoly(_X: f64, _Tab: *const f64, _N: ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn _fdpoly(_X: f32, _Tab: *const f32, _N: ::std::os::raw::c_int) -> f32;
}
extern "C" {
pub fn _dlog(_X: f64, _Baseflag: ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn _ldlog(_X: f64, _Baseflag: ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn _fdlog(_X: f32, _Baseflag: ::std::os::raw::c_int) -> f32;
}
extern "C" {
pub fn _dsin(_X: f64, _Qoff: ::std::os::raw::c_uint) -> f64;
}
extern "C" {
pub fn _ldsin(_X: f64, _Qoff: ::std::os::raw::c_uint) -> f64;
}
extern "C" {
pub fn _fdsin(_X: f32, _Qoff: ::std::os::raw::c_uint) -> f32;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _double_val {
pub _Sh: [::std::os::raw::c_ushort; 4usize],
pub _Val: f64,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout__double_val() {
assert_eq!(
::std::mem::size_of::<_double_val>(),
8usize,
concat!("Size of: ", stringify!(_double_val))
);
assert_eq!(
::std::mem::align_of::<_double_val>(),
8usize,
concat!("Alignment of ", stringify!(_double_val))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_double_val>()))._Sh as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_double_val),
"::",
stringify!(_Sh)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_double_val>()))._Val as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_double_val),
"::",
stringify!(_Val)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _float_val {
pub _Sh: [::std::os::raw::c_ushort; 2usize],
pub _Val: f32,
_bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout__float_val() {
assert_eq!(
::std::mem::size_of::<_float_val>(),
4usize,
concat!("Size of: ", stringify!(_float_val))
);
assert_eq!(
::std::mem::align_of::<_float_val>(),
4usize,
concat!("Alignment of ", stringify!(_float_val))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_float_val>()))._Sh as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_float_val),
"::",
stringify!(_Sh)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_float_val>()))._Val as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_float_val),
"::",
stringify!(_Val)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _ldouble_val {
pub _Sh: [::std::os::raw::c_ushort; 4usize],
pub _Val: f64,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout__ldouble_val() {
assert_eq!(
::std::mem::size_of::<_ldouble_val>(),
8usize,
concat!("Size of: ", stringify!(_ldouble_val))
);
assert_eq!(
::std::mem::align_of::<_ldouble_val>(),
8usize,
concat!("Alignment of ", stringify!(_ldouble_val))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ldouble_val>()))._Sh as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ldouble_val),
"::",
stringify!(_Sh)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ldouble_val>()))._Val as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ldouble_val),
"::",
stringify!(_Val)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _float_const {
pub _Word: [::std::os::raw::c_ushort; 4usize],
pub _Float: f32,
pub _Double: f64,
pub _Long_double: f64,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout__float_const() {
assert_eq!(
::std::mem::size_of::<_float_const>(),
8usize,
concat!("Size of: ", stringify!(_float_const))
);
assert_eq!(
::std::mem::align_of::<_float_const>(),
8usize,
concat!("Alignment of ", stringify!(_float_const))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_float_const>()))._Word as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_float_const),
"::",
stringify!(_Word)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_float_const>()))._Float as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_float_const),
"::",
stringify!(_Float)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_float_const>()))._Double as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_float_const),
"::",
stringify!(_Double)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_float_const>()))._Long_double as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_float_const),
"::",
stringify!(_Long_double)
)
);
}
extern "C" {
pub static _Denorm_C: _float_const;
}
extern "C" {
pub static _Inf_C: _float_const;
}
extern "C" {
pub static _Nan_C: _float_const;
}
extern "C" {
pub static _Snan_C: _float_const;
}
extern "C" {
pub static _Hugeval_C: _float_const;
}
extern "C" {
pub static _FDenorm_C: _float_const;
}
extern "C" {
pub static _FInf_C: _float_const;
}
extern "C" {
pub static _FNan_C: _float_const;
}
extern "C" {
pub static _FSnan_C: _float_const;
}
extern "C" {
pub static _LDenorm_C: _float_const;
}
extern "C" {
pub static _LInf_C: _float_const;
}
extern "C" {
pub static _LNan_C: _float_const;
}
extern "C" {
pub static _LSnan_C: _float_const;
}
extern "C" {
pub static _Eps_C: _float_const;
}
extern "C" {
pub static _Rteps_C: _float_const;
}
extern "C" {
pub static _FEps_C: _float_const;
}
extern "C" {
pub static _FRteps_C: _float_const;
}
extern "C" {
pub static _LEps_C: _float_const;
}
extern "C" {
pub static _LRteps_C: _float_const;
}
extern "C" {
pub static _Zero_C: f64;
}
extern "C" {
pub static _Xbig_C: f64;
}
extern "C" {
pub static _FZero_C: f32;
}
extern "C" {
pub static _FXbig_C: f32;
}
extern "C" {
pub static _LZero_C: f64;
}
extern "C" {
pub static _LXbig_C: f64;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _Combined_type {
pub _address: u8,
}
pub type _Combined_type__Type = f32;
#[test]
fn __bindgen_test_layout__Combined_type_open0_float_double_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<_Combined_type>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(_Combined_type)
)
);
assert_eq!(
::std::mem::align_of::<_Combined_type>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(_Combined_type)
)
);
}
#[test]
fn __bindgen_test_layout__Combined_type_open0_float_long_double_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<_Combined_type>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(_Combined_type)
)
);
assert_eq!(
::std::mem::align_of::<_Combined_type>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(_Combined_type)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _Real_widened {
pub _address: u8,
}
pub type _Real_widened__Type = f64;
#[test]
fn __bindgen_test_layout__Real_widened_open0_float_float_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<_Real_widened>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(_Real_widened)
)
);
assert_eq!(
::std::mem::align_of::<_Real_widened>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(_Real_widened)
)
);
}
#[test]
fn __bindgen_test_layout__Real_widened_open0_float_double_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<_Real_widened>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(_Real_widened)
)
);
assert_eq!(
::std::mem::align_of::<_Real_widened>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(_Real_widened)
)
);
}
#[test]
fn __bindgen_test_layout__Real_widened_open0_double_float_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<_Real_widened>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(_Real_widened)
)
);
assert_eq!(
::std::mem::align_of::<_Real_widened>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(_Real_widened)
)
);
}
#[test]
fn __bindgen_test_layout__Real_widened_open0_double_double_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<_Real_widened>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(_Real_widened)
)
);
assert_eq!(
::std::mem::align_of::<_Real_widened>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(_Real_widened)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _Real_type {
pub _address: u8,
}
pub type _Real_type__Type = f64;
#[test]
fn __bindgen_test_layout__Real_type_open0_float_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<_Real_type>(),
1usize,
concat!("Size of template specialization: ", stringify!(_Real_type))
);
assert_eq!(
::std::mem::align_of::<_Real_type>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(_Real_type)
)
);
}
#[test]
fn __bindgen_test_layout__Real_type_open0_long_double_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<_Real_type>(),
1usize,
concat!("Size of template specialization: ", stringify!(_Real_type))
);
assert_eq!(
::std::mem::align_of::<_Real_type>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(_Real_type)
)
);
}
extern "C" {
pub fn abs(_X: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
pub fn labs(_X: ::std::os::raw::c_long) -> ::std::os::raw::c_long;
pub fn llabs(_X: ::std::os::raw::c_longlong) -> ::std::os::raw::c_longlong;
pub fn acos(_X: f64) -> f64;
pub fn asin(_X: f64) -> f64;
pub fn atan(_X: f64) -> f64;
pub fn atan2(_Y: f64, _X: f64) -> f64;
pub fn cos(_X: f64) -> f64;
pub fn cosh(_X: f64) -> f64;
pub fn exp(_X: f64) -> f64;
pub fn fabs(_X: f64) -> f64;
pub fn fmod(_X: f64, _Y: f64) -> f64;
pub fn log(_X: f64) -> f64;
pub fn log10(_X: f64) -> f64;
pub fn pow(_X: f64, _Y: f64) -> f64;
pub fn sin(_X: f64) -> f64;
pub fn sinh(_X: f64) -> f64;
pub fn sqrt(_X: f64) -> f64;
pub fn tan(_X: f64) -> f64;
pub fn tanh(_X: f64) -> f64;
pub fn acosh(_X: f64) -> f64;
pub fn asinh(_X: f64) -> f64;
pub fn atanh(_X: f64) -> f64;
pub fn atof(_String: *const ::std::os::raw::c_char) -> f64;
pub fn _atof_l(_String: *const ::std::os::raw::c_char, _Locale: _locale_t) -> f64;
pub fn _cabs(_Complex_value: _complex) -> f64;
pub fn cbrt(_X: f64) -> f64;
pub fn ceil(_X: f64) -> f64;
pub fn _chgsign(_X: f64) -> f64;
pub fn copysign(_Number: f64, _Sign: f64) -> f64;
pub fn _copysign(_Number: f64, _Sign: f64) -> f64;
pub fn erf(_X: f64) -> f64;
pub fn erfc(_X: f64) -> f64;
pub fn exp2(_X: f64) -> f64;
pub fn expm1(_X: f64) -> f64;
pub fn fdim(_X: f64, _Y: f64) -> f64;
pub fn floor(_X: f64) -> f64;
pub fn fma(_X: f64, _Y: f64, _Z: f64) -> f64;
pub fn fmax(_X: f64, _Y: f64) -> f64;
pub fn fmin(_X: f64, _Y: f64) -> f64;
pub fn frexp(_X: f64, _Y: *mut ::std::os::raw::c_int) -> f64;
pub fn hypot(_X: f64, _Y: f64) -> f64;
pub fn _hypot(_X: f64, _Y: f64) -> f64;
pub fn ilogb(_X: f64) -> ::std::os::raw::c_int;
pub fn ldexp(_X: f64, _Y: ::std::os::raw::c_int) -> f64;
pub fn lgamma(_X: f64) -> f64;
pub fn llrint(_X: f64) -> ::std::os::raw::c_longlong;
pub fn llround(_X: f64) -> ::std::os::raw::c_longlong;
pub fn log1p(_X: f64) -> f64;
pub fn log2(_X: f64) -> f64;
pub fn logb(_X: f64) -> f64;
pub fn lrint(_X: f64) -> ::std::os::raw::c_long;
pub fn lround(_X: f64) -> ::std::os::raw::c_long;
pub fn _matherr(_Except: *mut _exception) -> ::std::os::raw::c_int;
pub fn modf(_X: f64, _Y: *mut f64) -> f64;
pub fn nan(_X: *const ::std::os::raw::c_char) -> f64;
pub fn nearbyint(_X: f64) -> f64;
pub fn nextafter(_X: f64, _Y: f64) -> f64;
pub fn nexttoward(_X: f64, _Y: f64) -> f64;
pub fn remainder(_X: f64, _Y: f64) -> f64;
pub fn remquo(_X: f64, _Y: f64, _Z: *mut ::std::os::raw::c_int) -> f64;
pub fn rint(_X: f64) -> f64;
pub fn round(_X: f64) -> f64;
pub fn scalbln(_X: f64, _Y: ::std::os::raw::c_long) -> f64;
pub fn scalbn(_X: f64, _Y: ::std::os::raw::c_int) -> f64;
pub fn tgamma(_X: f64) -> f64;
pub fn trunc(_X: f64) -> f64;
pub fn _j0(_X: f64) -> f64;
pub fn _j1(_X: f64) -> f64;
pub fn _jn(_X: ::std::os::raw::c_int, _Y: f64) -> f64;
pub fn _y0(_X: f64) -> f64;
pub fn _y1(_X: f64) -> f64;
pub fn _yn(_X: ::std::os::raw::c_int, _Y: f64) -> f64;
pub fn acoshf(_X: f32) -> f32;
pub fn asinhf(_X: f32) -> f32;
pub fn atanhf(_X: f32) -> f32;
pub fn cbrtf(_X: f32) -> f32;
pub fn _chgsignf(_X: f32) -> f32;
pub fn copysignf(_Number: f32, _Sign: f32) -> f32;
pub fn _copysignf(_Number: f32, _Sign: f32) -> f32;
pub fn erff(_X: f32) -> f32;
pub fn erfcf(_X: f32) -> f32;
pub fn expm1f(_X: f32) -> f32;
pub fn exp2f(_X: f32) -> f32;
pub fn fdimf(_X: f32, _Y: f32) -> f32;
pub fn fmaf(_X: f32, _Y: f32, _Z: f32) -> f32;
pub fn fmaxf(_X: f32, _Y: f32) -> f32;
pub fn fminf(_X: f32, _Y: f32) -> f32;
pub fn _hypotf(_X: f32, _Y: f32) -> f32;
pub fn ilogbf(_X: f32) -> ::std::os::raw::c_int;
pub fn lgammaf(_X: f32) -> f32;
pub fn llrintf(_X: f32) -> ::std::os::raw::c_longlong;
pub fn llroundf(_X: f32) -> ::std::os::raw::c_longlong;
pub fn log1pf(_X: f32) -> f32;
pub fn log2f(_X: f32) -> f32;
pub fn logbf(_X: f32) -> f32;
pub fn lrintf(_X: f32) -> ::std::os::raw::c_long;
pub fn lroundf(_X: f32) -> ::std::os::raw::c_long;
pub fn nanf(_X: *const ::std::os::raw::c_char) -> f32;
pub fn nearbyintf(_X: f32) -> f32;
pub fn nextafterf(_X: f32, _Y: f32) -> f32;
pub fn nexttowardf(_X: f32, _Y: f64) -> f32;
pub fn remainderf(_X: f32, _Y: f32) -> f32;
pub fn remquof(_X: f32, _Y: f32, _Z: *mut ::std::os::raw::c_int) -> f32;
pub fn rintf(_X: f32) -> f32;
pub fn roundf(_X: f32) -> f32;
pub fn scalblnf(_X: f32, _Y: ::std::os::raw::c_long) -> f32;
pub fn scalbnf(_X: f32, _Y: ::std::os::raw::c_int) -> f32;
pub fn tgammaf(_X: f32) -> f32;
pub fn truncf(_X: f32) -> f32;
pub fn _logbf(_X: f32) -> f32;
pub fn _nextafterf(_X: f32, _Y: f32) -> f32;
pub fn _finitef(_X: f32) -> ::std::os::raw::c_int;
pub fn _isnanf(_X: f32) -> ::std::os::raw::c_int;
pub fn _fpclassf(_X: f32) -> ::std::os::raw::c_int;
pub fn _set_FMA3_enable(_Flag: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
pub fn _get_FMA3_enable() -> ::std::os::raw::c_int;
pub fn acosf(_X: f32) -> f32;
pub fn asinf(_X: f32) -> f32;
pub fn atan2f(_Y: f32, _X: f32) -> f32;
pub fn atanf(_X: f32) -> f32;
pub fn ceilf(_X: f32) -> f32;
pub fn cosf(_X: f32) -> f32;
pub fn coshf(_X: f32) -> f32;
pub fn expf(_X: f32) -> f32;
pub fn floorf(_X: f32) -> f32;
pub fn fmodf(_X: f32, _Y: f32) -> f32;
pub fn log10f(_X: f32) -> f32;
pub fn logf(_X: f32) -> f32;
pub fn modff(_X: f32, _Y: *mut f32) -> f32;
pub fn powf(_X: f32, _Y: f32) -> f32;
pub fn sinf(_X: f32) -> f32;
pub fn sinhf(_X: f32) -> f32;
pub fn sqrtf(_X: f32) -> f32;
pub fn tanf(_X: f32) -> f32;
pub fn tanhf(_X: f32) -> f32;
pub fn acoshl(_X: f64) -> f64;
pub fn asinhl(_X: f64) -> f64;
pub fn atanhl(_X: f64) -> f64;
pub fn cbrtl(_X: f64) -> f64;
pub fn copysignl(_Number: f64, _Sign: f64) -> f64;
pub fn erfl(_X: f64) -> f64;
pub fn erfcl(_X: f64) -> f64;
pub fn exp2l(_X: f64) -> f64;
pub fn expm1l(_X: f64) -> f64;
pub fn fdiml(_X: f64, _Y: f64) -> f64;
pub fn fmal(_X: f64, _Y: f64, _Z: f64) -> f64;
pub fn fmaxl(_X: f64, _Y: f64) -> f64;
pub fn fminl(_X: f64, _Y: f64) -> f64;
pub fn ilogbl(_X: f64) -> ::std::os::raw::c_int;
pub fn lgammal(_X: f64) -> f64;
pub fn llrintl(_X: f64) -> ::std::os::raw::c_longlong;
pub fn llroundl(_X: f64) -> ::std::os::raw::c_longlong;
pub fn log1pl(_X: f64) -> f64;
pub fn log2l(_X: f64) -> f64;
pub fn logbl(_X: f64) -> f64;
pub fn lrintl(_X: f64) -> ::std::os::raw::c_long;
pub fn lroundl(_X: f64) -> ::std::os::raw::c_long;
pub fn nanl(_X: *const ::std::os::raw::c_char) -> f64;
pub fn nearbyintl(_X: f64) -> f64;
pub fn nextafterl(_X: f64, _Y: f64) -> f64;
pub fn nexttowardl(_X: f64, _Y: f64) -> f64;
pub fn remainderl(_X: f64, _Y: f64) -> f64;
pub fn remquol(_X: f64, _Y: f64, _Z: *mut ::std::os::raw::c_int) -> f64;
pub fn rintl(_X: f64) -> f64;
pub fn roundl(_X: f64) -> f64;
pub fn scalblnl(_X: f64, _Y: ::std::os::raw::c_long) -> f64;
pub fn scalbnl(_X: f64, _Y: ::std::os::raw::c_int) -> f64;
pub fn tgammal(_X: f64) -> f64;
pub fn truncl(_X: f64) -> f64;
pub static mut HUGE: f64;
pub fn j0(_X: f64) -> f64;
pub fn j1(_X: f64) -> f64;
pub fn jn(_X: ::std::os::raw::c_int, _Y: f64) -> f64;
pub fn y0(_X: f64) -> f64;
pub fn y1(_X: f64) -> f64;
pub fn yn(_X: ::std::os::raw::c_int, _Y: f64) -> f64;
pub fn _calloc_base(_Count: size_t, _Size: size_t) -> *mut ::std::os::raw::c_void;
pub fn calloc(_Count: size_t, _Size: size_t) -> *mut ::std::os::raw::c_void;
pub fn _callnewh(_Size: size_t) -> ::std::os::raw::c_int;
pub fn _expand(
_Block: *mut ::std::os::raw::c_void,
_Size: size_t,
) -> *mut ::std::os::raw::c_void;
pub fn _free_base(_Block: *mut ::std::os::raw::c_void);
pub fn free(_Block: *mut ::std::os::raw::c_void);
pub fn _malloc_base(_Size: size_t) -> *mut ::std::os::raw::c_void;
pub fn malloc(_Size: size_t) -> *mut ::std::os::raw::c_void;
pub fn _msize_base(_Block: *mut ::std::os::raw::c_void) -> size_t;
pub fn _msize(_Block: *mut ::std::os::raw::c_void) -> size_t;
pub fn _realloc_base(
_Block: *mut ::std::os::raw::c_void,
_Size: size_t,
) -> *mut ::std::os::raw::c_void;
pub fn realloc(
_Block: *mut ::std::os::raw::c_void,
_Size: size_t,
) -> *mut ::std::os::raw::c_void;
pub fn _recalloc_base(
_Block: *mut ::std::os::raw::c_void,
_Count: size_t,
_Size: size_t,
) -> *mut ::std::os::raw::c_void;
pub fn _recalloc(
_Block: *mut ::std::os::raw::c_void,
_Count: size_t,
_Size: size_t,
) -> *mut ::std::os::raw::c_void;
pub fn _aligned_free(_Block: *mut ::std::os::raw::c_void);
pub fn _aligned_malloc(_Size: size_t, _Alignment: size_t) -> *mut ::std::os::raw::c_void;
pub fn _aligned_offset_malloc(
_Size: size_t,
_Alignment: size_t,
_Offset: size_t,
) -> *mut ::std::os::raw::c_void;
pub fn _aligned_msize(
_Block: *mut ::std::os::raw::c_void,
_Alignment: size_t,
_Offset: size_t,
) -> size_t;
pub fn _aligned_offset_realloc(
_Block: *mut ::std::os::raw::c_void,
_Size: size_t,
_Alignment: size_t,
_Offset: size_t,
) -> *mut ::std::os::raw::c_void;
pub fn _aligned_offset_recalloc(
_Block: *mut ::std::os::raw::c_void,
_Count: size_t,
_Size: size_t,
_Alignment: size_t,
_Offset: size_t,
) -> *mut ::std::os::raw::c_void;
pub fn _aligned_realloc(
_Block: *mut ::std::os::raw::c_void,
_Size: size_t,
_Alignment: size_t,
) -> *mut ::std::os::raw::c_void;
pub fn _aligned_recalloc(
_Block: *mut ::std::os::raw::c_void,
_Count: size_t,
_Size: size_t,
_Alignment: size_t,
) -> *mut ::std::os::raw::c_void;
}
pub type _CoreCrtSecureSearchSortCompareFunction = ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut ::std::os::raw::c_void,
arg2: *const ::std::os::raw::c_void,
arg3: *const ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
pub type _CoreCrtNonSecureSearchSortCompareFunction = ::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" {
pub fn bsearch_s(
_Key: *const ::std::os::raw::c_void,
_Base: *const ::std::os::raw::c_void,
_NumOfElements: rsize_t,
_SizeOfElements: rsize_t,
_CompareFunction: _CoreCrtSecureSearchSortCompareFunction,
_Context: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void;
pub fn qsort_s(
_Base: *mut ::std::os::raw::c_void,
_NumOfElements: rsize_t,
_SizeOfElements: rsize_t,
_CompareFunction: _CoreCrtSecureSearchSortCompareFunction,
_Context: *mut ::std::os::raw::c_void,
);
pub fn bsearch(
_Key: *const ::std::os::raw::c_void,
_Base: *const ::std::os::raw::c_void,
_NumOfElements: size_t,
_SizeOfElements: size_t,
_CompareFunction: _CoreCrtNonSecureSearchSortCompareFunction,
) -> *mut ::std::os::raw::c_void;
pub fn qsort(
_Base: *mut ::std::os::raw::c_void,
_NumOfElements: size_t,
_SizeOfElements: size_t,
_CompareFunction: _CoreCrtNonSecureSearchSortCompareFunction,
);
pub fn _lfind_s(
_Key: *const ::std::os::raw::c_void,
_Base: *const ::std::os::raw::c_void,
_NumOfElements: *mut ::std::os::raw::c_uint,
_SizeOfElements: size_t,
_CompareFunction: _CoreCrtSecureSearchSortCompareFunction,
_Context: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn _lfind(
_Key: *const ::std::os::raw::c_void,
_Base: *const ::std::os::raw::c_void,
_NumOfElements: *mut ::std::os::raw::c_uint,
_SizeOfElements: ::std::os::raw::c_uint,
_CompareFunction: _CoreCrtNonSecureSearchSortCompareFunction,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn _lsearch_s(
_Key: *const ::std::os::raw::c_void,
_Base: *mut ::std::os::raw::c_void,
_NumOfElements: *mut ::std::os::raw::c_uint,
_SizeOfElements: size_t,
_CompareFunction: _CoreCrtSecureSearchSortCompareFunction,
_Context: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn _lsearch(
_Key: *const ::std::os::raw::c_void,
_Base: *mut ::std::os::raw::c_void,
_NumOfElements: *mut ::std::os::raw::c_uint,
_SizeOfElements: ::std::os::raw::c_uint,
_CompareFunction: _CoreCrtNonSecureSearchSortCompareFunction,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn lfind(
_Key: *const ::std::os::raw::c_void,
_Base: *const ::std::os::raw::c_void,
_NumOfElements: *mut ::std::os::raw::c_uint,
_SizeOfElements: ::std::os::raw::c_uint,
_CompareFunction: _CoreCrtNonSecureSearchSortCompareFunction,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn lsearch(
_Key: *const ::std::os::raw::c_void,
_Base: *mut ::std::os::raw::c_void,
_NumOfElements: *mut ::std::os::raw::c_uint,
_SizeOfElements: ::std::os::raw::c_uint,
_CompareFunction: _CoreCrtNonSecureSearchSortCompareFunction,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn _itow_s(
_Value: ::std::os::raw::c_int,
_Buffer: *mut u16,
_BufferCount: size_t,
_Radix: ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn _itow(
_Value: ::std::os::raw::c_int,
_Buffer: *mut u16,
_Radix: ::std::os::raw::c_int,
) -> *mut u16;
}
extern "C" {
pub fn _ltow_s(
_Value: ::std::os::raw::c_long,
_Buffer: *mut u16,
_BufferCount: size_t,
_Radix: ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn _ltow(
_Value: ::std::os::raw::c_long,
_Buffer: *mut u16,
_Radix: ::std::os::raw::c_int,
) -> *mut u16;
}
extern "C" {
pub fn _ultow_s(
_Value: ::std::os::raw::c_ulong,
_Buffer: *mut u16,
_BufferCount: size_t,
_Radix: ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn _ultow(
_Value: ::std::os::raw::c_ulong,
_Buffer: *mut u16,
_Radix: ::std::os::raw::c_int,
) -> *mut u16;
}
extern "C" {
pub fn wcstod(_String: *const u16, _EndPtr: *mut *mut u16) -> f64;
}
extern "C" {
pub fn _wcstod_l(_String: *const u16, _EndPtr: *mut *mut u16, _Locale: _locale_t) -> f64;
}
extern "C" {
pub fn wcstol(
_String: *const u16,
_EndPtr: *mut *mut u16,
_Radix: ::std::os::raw::c_int,
) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn _wcstol_l(
_String: *const u16,
_EndPtr: *mut *mut u16,
_Radix: ::std::os::raw::c_int,
_Locale: _locale_t,
) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn wcstoll(
_String: *const u16,
_EndPtr: *mut *mut u16,
_Radix: ::std::os::raw::c_int,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _wcstoll_l(
_String: *const u16,
_EndPtr: *mut *mut u16,
_Radix: ::std::os::raw::c_int,
_Locale: _locale_t,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn wcstoul(
_String: *const u16,
_EndPtr: *mut *mut u16,
_Radix: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn _wcstoul_l(
_String: *const u16,
_EndPtr: *mut *mut u16,
_Radix: ::std::os::raw::c_int,
_Locale: _locale_t,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn wcstoull(
_String: *const u16,
_EndPtr: *mut *mut u16,
_Radix: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn _wcstoull_l(
_String: *const u16,
_EndPtr: *mut *mut u16,
_Radix: ::std::os::raw::c_int,
_Locale: _locale_t,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn wcstold(_String: *const u16, _EndPtr: *mut *mut u16) -> f64;
}
extern "C" {
pub fn _wcstold_l(_String: *const u16, _EndPtr: *mut *mut u16, _Locale: _locale_t) -> f64;
}
extern "C" {
pub fn wcstof(_String: *const u16, _EndPtr: *mut *mut u16) -> f32;
}
extern "C" {
pub fn _wcstof_l(_String: *const u16, _EndPtr: *mut *mut u16, _Locale: _locale_t) -> f32;
}
extern "C" {
pub fn _wtof(_String: *const u16) -> f64;
}
extern "C" {
pub fn _wtof_l(_String: *const u16, _Locale: _locale_t) -> f64;
}
extern "C" {
pub fn _wtoi(_String: *const u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wtoi_l(_String: *const u16, _Locale: _locale_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wtol(_String: *const u16) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn _wtol_l(_String: *const u16, _Locale: _locale_t) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn _wtoll(_String: *const u16) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _wtoll_l(_String: *const u16, _Locale: _locale_t) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _i64tow_s(
_Value: ::std::os::raw::c_longlong,
_Buffer: *mut u16,
_BufferCount: size_t,
_Radix: ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn _i64tow(
_Value: ::std::os::raw::c_longlong,
_Buffer: *mut u16,
_Radix: ::std::os::raw::c_int,
) -> *mut u16;
}
extern "C" {
pub fn _ui64tow_s(
_Value: ::std::os::raw::c_ulonglong,
_Buffer: *mut u16,
_BufferCount: size_t,
_Radix: ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn _ui64tow(
_Value: ::std::os::raw::c_ulonglong,
_Buffer: *mut u16,
_Radix: ::std::os::raw::c_int,
) -> *mut u16;
}
extern "C" {
pub fn _wtoi64(_String: *const u16) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _wtoi64_l(_String: *const u16, _Locale: _locale_t) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _wcstoi64(
_String: *const u16,
_EndPtr: *mut *mut u16,
_Radix: ::std::os::raw::c_int,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _wcstoi64_l(
_String: *const u16,
_EndPtr: *mut *mut u16,
_Radix: ::std::os::raw::c_int,
_Locale: _locale_t,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _wcstoui64(
_String: *const u16,
_EndPtr: *mut *mut u16,
_Radix: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn _wcstoui64_l(
_String: *const u16,
_EndPtr: *mut *mut u16,
_Radix: ::std::os::raw::c_int,
_Locale: _locale_t,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn _wfullpath(_Buffer: *mut u16, _Path: *const u16, _BufferCount: size_t) -> *mut u16;
}
extern "C" {
pub fn _wmakepath_s(
_Buffer: *mut u16,
_BufferCount: size_t,
_Drive: *const u16,
_Dir: *const u16,
_Filename: *const u16,
_Ext: *const u16,
) -> errno_t;
}
extern "C" {
pub fn _wmakepath(
_Buffer: *mut u16,
_Drive: *const u16,
_Dir: *const u16,
_Filename: *const u16,
_Ext: *const u16,
);
}
extern "C" {
pub fn _wperror(_ErrorMessage: *const u16);
}
extern "C" {
pub fn _wsplitpath(
_FullPath: *const u16,
_Drive: *mut u16,
_Dir: *mut u16,
_Filename: *mut u16,
_Ext: *mut u16,
);
}
extern "C" {
pub fn _wsplitpath_s(
_FullPath: *const u16,
_Drive: *mut u16,
_DriveCount: size_t,
_Dir: *mut u16,
_DirCount: size_t,
_Filename: *mut u16,
_FilenameCount: size_t,
_Ext: *mut u16,
_ExtCount: size_t,
) -> errno_t;
}
extern "C" {
pub fn _wdupenv_s(
_Buffer: *mut *mut u16,
_BufferCount: *mut size_t,
_VarName: *const u16,
) -> errno_t;
}
extern "C" {
pub fn _wgetenv(_VarName: *const u16) -> *mut u16;
}
extern "C" {
pub fn _wgetenv_s(
_RequiredCount: *mut size_t,
_Buffer: *mut u16,
_BufferCount: size_t,
_VarName: *const u16,
) -> errno_t;
}
extern "C" {
pub fn _wputenv(_EnvString: *const u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wputenv_s(_Name: *const u16, _Value: *const u16) -> errno_t;
}
extern "C" {
pub fn _wsearchenv_s(
_Filename: *const u16,
_VarName: *const u16,
_Buffer: *mut u16,
_BufferCount: size_t,
) -> errno_t;
}
extern "C" {
pub fn _wsearchenv(_Filename: *const u16, _VarName: *const u16, _ResultPath: *mut u16);
}
extern "C" {
pub fn _wsystem(_Command: *const u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _swab(
_Buf1: *mut ::std::os::raw::c_char,
_Buf2: *mut ::std::os::raw::c_char,
_SizeInBytes: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn exit(_Code: ::std::os::raw::c_int);
}
extern "C" {
pub fn _exit(_Code: ::std::os::raw::c_int);
}
extern "C" {
pub fn _Exit(_Code: ::std::os::raw::c_int);
}
extern "C" {
pub fn quick_exit(_Code: ::std::os::raw::c_int);
}
extern "C" {
pub fn abort();
}
extern "C" {
pub fn _set_abort_behavior(
_Flags: ::std::os::raw::c_uint,
_Mask: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_uint;
}
pub type _onexit_t = ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_int>;
extern "C" {
pub fn atexit(arg1: ::std::option::Option<unsafe extern "C" fn()>) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _onexit(_Func: _onexit_t) -> _onexit_t;
}
extern "C" {
pub fn at_quick_exit(
arg1: ::std::option::Option<unsafe extern "C" fn()>,
) -> ::std::os::raw::c_int;
}
pub type _purecall_handler = ::std::option::Option<unsafe extern "C" fn()>;
pub type _invalid_parameter_handler = ::std::option::Option<
unsafe extern "C" fn(
arg1: *const u16,
arg2: *const u16,
arg3: *const u16,
arg4: ::std::os::raw::c_uint,
arg5: usize,
),
>;
extern "C" {
pub fn _set_purecall_handler(_Handler: _purecall_handler) -> _purecall_handler;
}
extern "C" {
pub fn _get_purecall_handler() -> _purecall_handler;
}
extern "C" {
pub fn _set_invalid_parameter_handler(
_Handler: _invalid_parameter_handler,
) -> _invalid_parameter_handler;
}
extern "C" {
pub fn _get_invalid_parameter_handler() -> _invalid_parameter_handler;
}
extern "C" {
pub fn _set_thread_local_invalid_parameter_handler(
_Handler: _invalid_parameter_handler,
) -> _invalid_parameter_handler;
}
extern "C" {
pub fn _get_thread_local_invalid_parameter_handler() -> _invalid_parameter_handler;
}
extern "C" {
pub fn _set_error_mode(_Mode: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __doserrno() -> *mut ::std::os::raw::c_ulong;
}
extern "C" {
pub fn _set_doserrno(_Value: ::std::os::raw::c_ulong) -> errno_t;
}
extern "C" {
pub fn _get_doserrno(_Value: *mut ::std::os::raw::c_ulong) -> errno_t;
}
extern "C" {
pub fn __sys_errlist() -> *mut *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn __sys_nerr() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn perror(_ErrMsg: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn __p__pgmptr() -> *mut *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn __p__wpgmptr() -> *mut *mut u16;
}
extern "C" {
pub fn __p__fmode() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn _get_pgmptr(_Value: *mut *mut ::std::os::raw::c_char) -> errno_t;
}
extern "C" {
pub fn _get_wpgmptr(_Value: *mut *mut u16) -> errno_t;
}
extern "C" {
pub fn _set_fmode(_Mode: ::std::os::raw::c_int) -> errno_t;
}
extern "C" {
pub fn _get_fmode(_PMode: *mut ::std::os::raw::c_int) -> errno_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _div_t {
pub quot: ::std::os::raw::c_int,
pub rem: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__div_t() {
assert_eq!(
::std::mem::size_of::<_div_t>(),
8usize,
concat!("Size of: ", stringify!(_div_t))
);
assert_eq!(
::std::mem::align_of::<_div_t>(),
4usize,
concat!("Alignment of ", stringify!(_div_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_div_t>())).quot as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_div_t),
"::",
stringify!(quot)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_div_t>())).rem as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_div_t),
"::",
stringify!(rem)
)
);
}
pub type div_t = _div_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ldiv_t {
pub quot: ::std::os::raw::c_long,
pub rem: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout__ldiv_t() {
assert_eq!(
::std::mem::size_of::<_ldiv_t>(),
8usize,
concat!("Size of: ", stringify!(_ldiv_t))
);
assert_eq!(
::std::mem::align_of::<_ldiv_t>(),
4usize,
concat!("Alignment of ", stringify!(_ldiv_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ldiv_t>())).quot as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ldiv_t),
"::",
stringify!(quot)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ldiv_t>())).rem as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_ldiv_t),
"::",
stringify!(rem)
)
);
}
pub type ldiv_t = _ldiv_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _lldiv_t {
pub quot: ::std::os::raw::c_longlong,
pub rem: ::std::os::raw::c_longlong,
}
#[test]
fn bindgen_test_layout__lldiv_t() {
assert_eq!(
::std::mem::size_of::<_lldiv_t>(),
16usize,
concat!("Size of: ", stringify!(_lldiv_t))
);
assert_eq!(
::std::mem::align_of::<_lldiv_t>(),
8usize,
concat!("Alignment of ", stringify!(_lldiv_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_lldiv_t>())).quot as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_lldiv_t),
"::",
stringify!(quot)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_lldiv_t>())).rem as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_lldiv_t),
"::",
stringify!(rem)
)
);
}
pub type lldiv_t = _lldiv_t;
extern "C" {
pub fn _abs64(_Number: ::std::os::raw::c_longlong) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _byteswap_ushort(_Number: ::std::os::raw::c_ushort) -> ::std::os::raw::c_ushort;
}
extern "C" {
pub fn _byteswap_ulong(_Number: ::std::os::raw::c_ulong) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn _byteswap_uint64(_Number: ::std::os::raw::c_ulonglong) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn div(_Numerator: ::std::os::raw::c_int, _Denominator: ::std::os::raw::c_int) -> div_t;
}
extern "C" {
pub fn ldiv(_Numerator: ::std::os::raw::c_long, _Denominator: ::std::os::raw::c_long)
-> ldiv_t;
}
extern "C" {
pub fn lldiv(
_Numerator: ::std::os::raw::c_longlong,
_Denominator: ::std::os::raw::c_longlong,
) -> lldiv_t;
}
extern "C" {
pub fn _rotl(
_Value: ::std::os::raw::c_uint,
_Shift: ::std::os::raw::c_int,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn _lrotl(
_Value: ::std::os::raw::c_ulong,
_Shift: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn _rotl64(
_Value: ::std::os::raw::c_ulonglong,
_Shift: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn _rotr(
_Value: ::std::os::raw::c_uint,
_Shift: ::std::os::raw::c_int,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn _lrotr(
_Value: ::std::os::raw::c_ulong,
_Shift: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn _rotr64(
_Value: ::std::os::raw::c_ulonglong,
_Shift: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn srand(_Seed: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rand() -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _LDOUBLE {
pub ld: [::std::os::raw::c_uchar; 10usize],
}
#[test]
fn bindgen_test_layout__LDOUBLE() {
assert_eq!(
::std::mem::size_of::<_LDOUBLE>(),
10usize,
concat!("Size of: ", stringify!(_LDOUBLE))
);
assert_eq!(
::std::mem::align_of::<_LDOUBLE>(),
1usize,
concat!("Alignment of ", stringify!(_LDOUBLE))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_LDOUBLE>())).ld as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_LDOUBLE),
"::",
stringify!(ld)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _CRT_DOUBLE {
pub x: f64,
}
#[test]
fn bindgen_test_layout__CRT_DOUBLE() {
assert_eq!(
::std::mem::size_of::<_CRT_DOUBLE>(),
8usize,
concat!("Size of: ", stringify!(_CRT_DOUBLE))
);
assert_eq!(
::std::mem::align_of::<_CRT_DOUBLE>(),
8usize,
concat!("Alignment of ", stringify!(_CRT_DOUBLE))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_CRT_DOUBLE>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_CRT_DOUBLE),
"::",
stringify!(x)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _CRT_FLOAT {
pub f: f32,
}
#[test]
fn bindgen_test_layout__CRT_FLOAT() {
assert_eq!(
::std::mem::size_of::<_CRT_FLOAT>(),
4usize,
concat!("Size of: ", stringify!(_CRT_FLOAT))
);
assert_eq!(
::std::mem::align_of::<_CRT_FLOAT>(),
4usize,
concat!("Alignment of ", stringify!(_CRT_FLOAT))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_CRT_FLOAT>())).f as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_CRT_FLOAT),
"::",
stringify!(f)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _LONGDOUBLE {
pub x: f64,
}
#[test]
fn bindgen_test_layout__LONGDOUBLE() {
assert_eq!(
::std::mem::size_of::<_LONGDOUBLE>(),
8usize,
concat!("Size of: ", stringify!(_LONGDOUBLE))
);
assert_eq!(
::std::mem::align_of::<_LONGDOUBLE>(),
8usize,
concat!("Alignment of ", stringify!(_LONGDOUBLE))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_LONGDOUBLE>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_LONGDOUBLE),
"::",
stringify!(x)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _LDBL12 {
pub ld12: [::std::os::raw::c_uchar; 12usize],
}
#[test]
fn bindgen_test_layout__LDBL12() {
assert_eq!(
::std::mem::size_of::<_LDBL12>(),
12usize,
concat!("Size of: ", stringify!(_LDBL12))
);
assert_eq!(
::std::mem::align_of::<_LDBL12>(),
1usize,
concat!("Alignment of ", stringify!(_LDBL12))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_LDBL12>())).ld12 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_LDBL12),
"::",
stringify!(ld12)
)
);
}
extern "C" {
pub fn atoi(_String: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn atol(_String: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn atoll(_String: *const ::std::os::raw::c_char) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _atoi64(_String: *const ::std::os::raw::c_char) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _atoi_l(
_String: *const ::std::os::raw::c_char,
_Locale: _locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _atol_l(
_String: *const ::std::os::raw::c_char,
_Locale: _locale_t,
) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn _atoll_l(
_String: *const ::std::os::raw::c_char,
_Locale: _locale_t,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _atoi64_l(
_String: *const ::std::os::raw::c_char,
_Locale: _locale_t,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _atoflt(
_Result: *mut _CRT_FLOAT,
_String: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _atodbl(
_Result: *mut _CRT_DOUBLE,
_String: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _atoldbl(
_Result: *mut _LDOUBLE,
_String: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _atoflt_l(
_Result: *mut _CRT_FLOAT,
_String: *const ::std::os::raw::c_char,
_Locale: _locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _atodbl_l(
_Result: *mut _CRT_DOUBLE,
_String: *mut ::std::os::raw::c_char,
_Locale: _locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _atoldbl_l(
_Result: *mut _LDOUBLE,
_String: *mut ::std::os::raw::c_char,
_Locale: _locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strtof(
_String: *const ::std::os::raw::c_char,
_EndPtr: *mut *mut ::std::os::raw::c_char,
) -> f32;
}
extern "C" {
pub fn _strtof_l(
_String: *const ::std::os::raw::c_char,
_EndPtr: *mut *mut ::std::os::raw::c_char,
_Locale: _locale_t,
) -> f32;
}
extern "C" {
pub fn strtod(
_String: *const ::std::os::raw::c_char,
_EndPtr: *mut *mut ::std::os::raw::c_char,
) -> f64;
}
extern "C" {
pub fn _strtod_l(
_String: *const ::std::os::raw::c_char,
_EndPtr: *mut *mut ::std::os::raw::c_char,
_Locale: _locale_t,
) -> f64;
}
extern "C" {
pub fn strtold(
_String: *const ::std::os::raw::c_char,
_EndPtr: *mut *mut ::std::os::raw::c_char,
) -> f64;
}
extern "C" {
pub fn _strtold_l(
_String: *const ::std::os::raw::c_char,
_EndPtr: *mut *mut ::std::os::raw::c_char,
_Locale: _locale_t,
) -> f64;
}
extern "C" {
pub fn strtol(
_String: *const ::std::os::raw::c_char,
_EndPtr: *mut *mut ::std::os::raw::c_char,
_Radix: ::std::os::raw::c_int,
) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn _strtol_l(
_String: *const ::std::os::raw::c_char,
_EndPtr: *mut *mut ::std::os::raw::c_char,
_Radix: ::std::os::raw::c_int,
_Locale: _locale_t,
) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn strtoll(
_String: *const ::std::os::raw::c_char,
_EndPtr: *mut *mut ::std::os::raw::c_char,
_Radix: ::std::os::raw::c_int,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _strtoll_l(
_String: *const ::std::os::raw::c_char,
_EndPtr: *mut *mut ::std::os::raw::c_char,
_Radix: ::std::os::raw::c_int,
_Locale: _locale_t,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn strtoul(
_String: *const ::std::os::raw::c_char,
_EndPtr: *mut *mut ::std::os::raw::c_char,
_Radix: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn _strtoul_l(
_String: *const ::std::os::raw::c_char,
_EndPtr: *mut *mut ::std::os::raw::c_char,
_Radix: ::std::os::raw::c_int,
_Locale: _locale_t,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn strtoull(
_String: *const ::std::os::raw::c_char,
_EndPtr: *mut *mut ::std::os::raw::c_char,
_Radix: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn _strtoull_l(
_String: *const ::std::os::raw::c_char,
_EndPtr: *mut *mut ::std::os::raw::c_char,
_Radix: ::std::os::raw::c_int,
_Locale: _locale_t,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn _strtoi64(
_String: *const ::std::os::raw::c_char,
_EndPtr: *mut *mut ::std::os::raw::c_char,
_Radix: ::std::os::raw::c_int,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _strtoi64_l(
_String: *const ::std::os::raw::c_char,
_EndPtr: *mut *mut ::std::os::raw::c_char,
_Radix: ::std::os::raw::c_int,
_Locale: _locale_t,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _strtoui64(
_String: *const ::std::os::raw::c_char,
_EndPtr: *mut *mut ::std::os::raw::c_char,
_Radix: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn _strtoui64_l(
_String: *const ::std::os::raw::c_char,
_EndPtr: *mut *mut ::std::os::raw::c_char,
_Radix: ::std::os::raw::c_int,
_Locale: _locale_t,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn _itoa_s(
_Value: ::std::os::raw::c_int,
_Buffer: *mut ::std::os::raw::c_char,
_BufferCount: size_t,
_Radix: ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn _itoa(
_Value: ::std::os::raw::c_int,
_Buffer: *mut ::std::os::raw::c_char,
_Radix: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _ltoa_s(
_Value: ::std::os::raw::c_long,
_Buffer: *mut ::std::os::raw::c_char,
_BufferCount: size_t,
_Radix: ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn _ltoa(
_Value: ::std::os::raw::c_long,
_Buffer: *mut ::std::os::raw::c_char,
_Radix: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _ultoa_s(
_Value: ::std::os::raw::c_ulong,
_Buffer: *mut ::std::os::raw::c_char,
_BufferCount: size_t,
_Radix: ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn _ultoa(
_Value: ::std::os::raw::c_ulong,
_Buffer: *mut ::std::os::raw::c_char,
_Radix: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _i64toa_s(
_Value: ::std::os::raw::c_longlong,
_Buffer: *mut ::std::os::raw::c_char,
_BufferCount: size_t,
_Radix: ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn _i64toa(
_Value: ::std::os::raw::c_longlong,
_Buffer: *mut ::std::os::raw::c_char,
_Radix: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _ui64toa_s(
_Value: ::std::os::raw::c_ulonglong,
_Buffer: *mut ::std::os::raw::c_char,
_BufferCount: size_t,
_Radix: ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn _ui64toa(
_Value: ::std::os::raw::c_ulonglong,
_Buffer: *mut ::std::os::raw::c_char,
_Radix: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _ecvt_s(
_Buffer: *mut ::std::os::raw::c_char,
_BufferCount: size_t,
_Value: f64,
_DigitCount: ::std::os::raw::c_int,
_PtDec: *mut ::std::os::raw::c_int,
_PtSign: *mut ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn _ecvt(
_Value: f64,
_DigitCount: ::std::os::raw::c_int,
_PtDec: *mut ::std::os::raw::c_int,
_PtSign: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _fcvt_s(
_Buffer: *mut ::std::os::raw::c_char,
_BufferCount: size_t,
_Value: f64,
_FractionalDigitCount: ::std::os::raw::c_int,
_PtDec: *mut ::std::os::raw::c_int,
_PtSign: *mut ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn _fcvt(
_Value: f64,
_FractionalDigitCount: ::std::os::raw::c_int,
_PtDec: *mut ::std::os::raw::c_int,
_PtSign: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _gcvt_s(
_Buffer: *mut ::std::os::raw::c_char,
_BufferCount: size_t,
_Value: f64,
_DigitCount: ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn _gcvt(
_Value: f64,
_DigitCount: ::std::os::raw::c_int,
_Buffer: *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn ___mb_cur_max_func() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ___mb_cur_max_l_func(_Locale: _locale_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mblen(_Ch: *const ::std::os::raw::c_char, _MaxCount: size_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _mblen_l(
_Ch: *const ::std::os::raw::c_char,
_MaxCount: size_t,
_Locale: _locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _mbstrlen(_String: *const ::std::os::raw::c_char) -> size_t;
}
extern "C" {
pub fn _mbstrlen_l(_String: *const ::std::os::raw::c_char, _Locale: _locale_t) -> size_t;
}
extern "C" {
pub fn _mbstrnlen(_String: *const ::std::os::raw::c_char, _MaxCount: size_t) -> size_t;
}
extern "C" {
pub fn _mbstrnlen_l(
_String: *const ::std::os::raw::c_char,
_MaxCount: size_t,
_Locale: _locale_t,
) -> size_t;
}
extern "C" {
pub fn mbtowc(
_DstCh: *mut u16,
_SrcCh: *const ::std::os::raw::c_char,
_SrcSizeInBytes: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _mbtowc_l(
_DstCh: *mut u16,
_SrcCh: *const ::std::os::raw::c_char,
_SrcSizeInBytes: size_t,
_Locale: _locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mbstowcs_s(
_PtNumOfCharConverted: *mut size_t,
_DstBuf: *mut u16,
_SizeInWords: size_t,
_SrcBuf: *const ::std::os::raw::c_char,
_MaxCount: size_t,
) -> errno_t;
}
extern "C" {
pub fn mbstowcs(
_Dest: *mut u16,
_Source: *const ::std::os::raw::c_char,
_MaxCount: size_t,
) -> size_t;
}
extern "C" {
pub fn _mbstowcs_s_l(
_PtNumOfCharConverted: *mut size_t,
_DstBuf: *mut u16,
_SizeInWords: size_t,
_SrcBuf: *const ::std::os::raw::c_char,
_MaxCount: size_t,
_Locale: _locale_t,
) -> errno_t;
}
extern "C" {
pub fn _mbstowcs_l(
_Dest: *mut u16,
_Source: *const ::std::os::raw::c_char,
_MaxCount: size_t,
_Locale: _locale_t,
) -> size_t;
}
extern "C" {
pub fn wctomb(_MbCh: *mut ::std::os::raw::c_char, _WCh: u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wctomb_l(
_MbCh: *mut ::std::os::raw::c_char,
_WCh: u16,
_Locale: _locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn wctomb_s(
_SizeConverted: *mut ::std::os::raw::c_int,
_MbCh: *mut ::std::os::raw::c_char,
_SizeInBytes: rsize_t,
_WCh: u16,
) -> errno_t;
}
extern "C" {
pub fn _wctomb_s_l(
_SizeConverted: *mut ::std::os::raw::c_int,
_MbCh: *mut ::std::os::raw::c_char,
_SizeInBytes: size_t,
_WCh: u16,
_Locale: _locale_t,
) -> errno_t;
}
extern "C" {
pub fn wcstombs_s(
_PtNumOfCharConverted: *mut size_t,
_Dst: *mut ::std::os::raw::c_char,
_DstSizeInBytes: size_t,
_Src: *const u16,
_MaxCountInBytes: size_t,
) -> errno_t;
}
extern "C" {
pub fn wcstombs(
_Dest: *mut ::std::os::raw::c_char,
_Source: *const u16,
_MaxCount: size_t,
) -> size_t;
}
extern "C" {
pub fn _wcstombs_s_l(
_PtNumOfCharConverted: *mut size_t,
_Dst: *mut ::std::os::raw::c_char,
_DstSizeInBytes: size_t,
_Src: *const u16,
_MaxCountInBytes: size_t,
_Locale: _locale_t,
) -> errno_t;
}
extern "C" {
pub fn _wcstombs_l(
_Dest: *mut ::std::os::raw::c_char,
_Source: *const u16,
_MaxCount: size_t,
_Locale: _locale_t,
) -> size_t;
}
extern "C" {
pub fn _fullpath(
_Buffer: *mut ::std::os::raw::c_char,
_Path: *const ::std::os::raw::c_char,
_BufferCount: size_t,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _makepath_s(
_Buffer: *mut ::std::os::raw::c_char,
_BufferCount: size_t,
_Drive: *const ::std::os::raw::c_char,
_Dir: *const ::std::os::raw::c_char,
_Filename: *const ::std::os::raw::c_char,
_Ext: *const ::std::os::raw::c_char,
) -> errno_t;
}
extern "C" {
pub fn _makepath(
_Buffer: *mut ::std::os::raw::c_char,
_Drive: *const ::std::os::raw::c_char,
_Dir: *const ::std::os::raw::c_char,
_Filename: *const ::std::os::raw::c_char,
_Ext: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn _splitpath(
_FullPath: *const ::std::os::raw::c_char,
_Drive: *mut ::std::os::raw::c_char,
_Dir: *mut ::std::os::raw::c_char,
_Filename: *mut ::std::os::raw::c_char,
_Ext: *mut ::std::os::raw::c_char,
);
}
extern "C" {
pub fn _splitpath_s(
_FullPath: *const ::std::os::raw::c_char,
_Drive: *mut ::std::os::raw::c_char,
_DriveCount: size_t,
_Dir: *mut ::std::os::raw::c_char,
_DirCount: size_t,
_Filename: *mut ::std::os::raw::c_char,
_FilenameCount: size_t,
_Ext: *mut ::std::os::raw::c_char,
_ExtCount: size_t,
) -> errno_t;
}
extern "C" {
pub fn getenv_s(
_RequiredCount: *mut size_t,
_Buffer: *mut ::std::os::raw::c_char,
_BufferCount: rsize_t,
_VarName: *const ::std::os::raw::c_char,
) -> errno_t;
}
extern "C" {
pub fn __p___argc() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn __p___argv() -> *mut *mut *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn __p___wargv() -> *mut *mut *mut u16;
}
extern "C" {
pub fn __p__environ() -> *mut *mut *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn __p__wenviron() -> *mut *mut *mut u16;
}
extern "C" {
pub fn getenv(_VarName: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _dupenv_s(
_Buffer: *mut *mut ::std::os::raw::c_char,
_BufferCount: *mut size_t,
_VarName: *const ::std::os::raw::c_char,
) -> errno_t;
}
extern "C" {
pub fn system(_Command: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _putenv(_EnvString: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _putenv_s(
_Name: *const ::std::os::raw::c_char,
_Value: *const ::std::os::raw::c_char,
) -> errno_t;
}
extern "C" {
pub fn _searchenv_s(
_Filename: *const ::std::os::raw::c_char,
_VarName: *const ::std::os::raw::c_char,
_Buffer: *mut ::std::os::raw::c_char,
_BufferCount: size_t,
) -> errno_t;
}
extern "C" {
pub fn _searchenv(
_Filename: *const ::std::os::raw::c_char,
_VarName: *const ::std::os::raw::c_char,
_Buffer: *mut ::std::os::raw::c_char,
);
}
extern "C" {
pub fn _seterrormode(_Mode: ::std::os::raw::c_int);
}
extern "C" {
pub fn _beep(_Frequency: ::std::os::raw::c_uint, _Duration: ::std::os::raw::c_uint);
}
extern "C" {
pub fn _sleep(_Duration: ::std::os::raw::c_ulong);
}
extern "C" {
pub fn ecvt(
_Value: f64,
_DigitCount: ::std::os::raw::c_int,
_PtDec: *mut ::std::os::raw::c_int,
_PtSign: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn fcvt(
_Value: f64,
_FractionalDigitCount: ::std::os::raw::c_int,
_PtDec: *mut ::std::os::raw::c_int,
_PtSign: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn gcvt(
_Value: f64,
_DigitCount: ::std::os::raw::c_int,
_DstBuf: *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn itoa(
_Value: ::std::os::raw::c_int,
_Buffer: *mut ::std::os::raw::c_char,
_Radix: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn ltoa(
_Value: ::std::os::raw::c_long,
_Buffer: *mut ::std::os::raw::c_char,
_Radix: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn swab(
_Buf1: *mut ::std::os::raw::c_char,
_Buf2: *mut ::std::os::raw::c_char,
_SizeInBytes: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn ultoa(
_Value: ::std::os::raw::c_ulong,
_Buffer: *mut ::std::os::raw::c_char,
_Radix: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn putenv(_EnvString: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn onexit(_Func: _onexit_t) -> _onexit_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _heapinfo {
pub _pentry: *mut ::std::os::raw::c_int,
pub _size: size_t,
pub _useflag: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__heapinfo() {
assert_eq!(
::std::mem::size_of::<_heapinfo>(),
24usize,
concat!("Size of: ", stringify!(_heapinfo))
);
assert_eq!(
::std::mem::align_of::<_heapinfo>(),
8usize,
concat!("Alignment of ", stringify!(_heapinfo))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_heapinfo>()))._pentry as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_heapinfo),
"::",
stringify!(_pentry)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_heapinfo>()))._size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_heapinfo),
"::",
stringify!(_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_heapinfo>()))._useflag as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_heapinfo),
"::",
stringify!(_useflag)
)
);
}
pub type _HEAPINFO = _heapinfo;
extern "C" {
pub fn _alloca(_Size: size_t) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn _get_heap_handle() -> isize;
}
extern "C" {
pub fn _heapmin() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _heapwalk(_EntryInfo: *mut _HEAPINFO) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _heapchk() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _resetstkoflw() -> ::std::os::raw::c_int;
}
pub type terminate_handler = ::std::option::Option<unsafe extern "C" fn()>;
pub type terminate_function = ::std::option::Option<unsafe extern "C" fn()>;
extern "C" {
pub fn terminate();
}
extern "C" {
pub fn set_terminate(_NewTerminateHandler: terminate_handler) -> terminate_handler;
}
extern "C" {
pub fn _get_terminate() -> terminate_handler;
}
pub type unexpected_handler = ::std::option::Option<unsafe extern "C" fn()>;
pub type unexpected_function = ::std::option::Option<unsafe extern "C" fn()>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _EXCEPTION_POINTERS {
_unused: [u8; 0],
}
extern "C" {
pub fn unexpected();
}
extern "C" {
pub fn set_unexpected(_NewUnexpectedHandler: unexpected_handler) -> unexpected_handler;
}
extern "C" {
pub fn _get_unexpected() -> unexpected_handler;
}
pub type _se_translator_function = ::std::option::Option<
unsafe extern "C" fn(arg1: ::std::os::raw::c_uint, arg2: *mut _EXCEPTION_POINTERS),
>;
extern "C" {
pub fn _set_se_translator(_NewSETranslator: _se_translator_function)
-> _se_translator_function;
}
extern "C" {
pub fn _is_exception_typeof(
_Type: *const type_info,
_ExceptionPtr: *mut _EXCEPTION_POINTERS,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __uncaught_exception() -> bool;
}
extern "C" {
pub fn __uncaught_exceptions() -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __std_exception_data {
pub _What: *const ::std::os::raw::c_char,
pub _DoFree: bool,
}
#[test]
fn bindgen_test_layout___std_exception_data() {
assert_eq!(
::std::mem::size_of::<__std_exception_data>(),
16usize,
concat!("Size of: ", stringify!(__std_exception_data))
);
assert_eq!(
::std::mem::align_of::<__std_exception_data>(),
8usize,
concat!("Alignment of ", stringify!(__std_exception_data))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__std_exception_data>()))._What as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__std_exception_data),
"::",
stringify!(_What)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__std_exception_data>()))._DoFree as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__std_exception_data),
"::",
stringify!(_DoFree)
)
);
}
extern "C" {
pub fn __std_exception_copy(_From: *const __std_exception_data, _To: *mut __std_exception_data);
}
extern "C" {
pub fn __std_exception_destroy(_Data: *mut __std_exception_data);
}
extern "C" {
#[link_name = "\u{1}?__ExceptionPtrCreate@@YAXPEAX@Z"]
pub fn __ExceptionPtrCreate(arg1: *mut ::std::os::raw::c_void);
}
extern "C" {
#[link_name = "\u{1}?__ExceptionPtrDestroy@@YAXPEAX@Z"]
pub fn __ExceptionPtrDestroy(arg1: *mut ::std::os::raw::c_void);
}
extern "C" {
#[link_name = "\u{1}?__ExceptionPtrCopy@@YAXPEAXPEBX@Z"]
pub fn __ExceptionPtrCopy(
arg1: *mut ::std::os::raw::c_void,
arg2: *const ::std::os::raw::c_void,
);
}
extern "C" {
#[link_name = "\u{1}?__ExceptionPtrAssign@@YAXPEAXPEBX@Z"]
pub fn __ExceptionPtrAssign(
arg1: *mut ::std::os::raw::c_void,
arg2: *const ::std::os::raw::c_void,
);
}
extern "C" {
#[link_name = "\u{1}?__ExceptionPtrCompare@@YA_NPEBX0@Z"]
pub fn __ExceptionPtrCompare(
arg1: *const ::std::os::raw::c_void,
arg2: *const ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
#[link_name = "\u{1}?__ExceptionPtrToBool@@YA_NPEBX@Z"]
pub fn __ExceptionPtrToBool(arg1: *const ::std::os::raw::c_void) -> bool;
}
extern "C" {
#[link_name = "\u{1}?__ExceptionPtrSwap@@YAXPEAX0@Z"]
pub fn __ExceptionPtrSwap(arg1: *mut ::std::os::raw::c_void, arg2: *mut ::std::os::raw::c_void);
}
extern "C" {
#[link_name = "\u{1}?__ExceptionPtrCurrentException@@YAXPEAX@Z"]
pub fn __ExceptionPtrCurrentException(arg1: *mut ::std::os::raw::c_void);
}
extern "C" {
#[link_name = "\u{1}?__ExceptionPtrRethrow@@YAXPEBX@Z"]
pub fn __ExceptionPtrRethrow(arg1: *const ::std::os::raw::c_void);
}
extern "C" {
#[link_name = "\u{1}?__ExceptionPtrCopyException@@YAXPEAXPEBX1@Z"]
pub fn __ExceptionPtrCopyException(
arg1: *mut ::std::os::raw::c_void,
arg2: *const ::std::os::raw::c_void,
arg3: *const ::std::os::raw::c_void,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _iobuf {
pub _Placeholder: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__iobuf() {
assert_eq!(
::std::mem::size_of::<_iobuf>(),
8usize,
concat!("Size of: ", stringify!(_iobuf))
);
assert_eq!(
::std::mem::align_of::<_iobuf>(),
8usize,
concat!("Alignment of ", stringify!(_iobuf))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_iobuf>()))._Placeholder as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_iobuf),
"::",
stringify!(_Placeholder)
)
);
}
pub type FILE = _iobuf;
extern "C" {
pub fn __acrt_iob_func(_Ix: ::std::os::raw::c_uint) -> *mut FILE;
}
extern "C" {
pub fn fgetwc(_Stream: *mut FILE) -> wint_t;
}
extern "C" {
pub fn _fgetwchar() -> wint_t;
}
extern "C" {
pub fn fputwc(_Character: u16, _Stream: *mut FILE) -> wint_t;
}
extern "C" {
pub fn _fputwchar(_Character: u16) -> wint_t;
}
extern "C" {
pub fn getwc(_Stream: *mut FILE) -> wint_t;
}
extern "C" {
pub fn getwchar() -> wint_t;
}
extern "C" {
pub fn fgetws(
_Buffer: *mut u16,
_BufferCount: ::std::os::raw::c_int,
_Stream: *mut FILE,
) -> *mut u16;
}
extern "C" {
pub fn fputws(_Buffer: *const u16, _Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _getws_s(_Buffer: *mut u16, _BufferCount: size_t) -> *mut u16;
}
extern "C" {
pub fn putwc(_Character: u16, _Stream: *mut FILE) -> wint_t;
}
extern "C" {
pub fn putwchar(_Character: u16) -> wint_t;
}
extern "C" {
pub fn _putws(_Buffer: *const u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ungetwc(_Character: wint_t, _Stream: *mut FILE) -> wint_t;
}
extern "C" {
pub fn _wfdopen(_FileHandle: ::std::os::raw::c_int, _Mode: *const u16) -> *mut FILE;
}
extern "C" {
pub fn _wfopen(_FileName: *const u16, _Mode: *const u16) -> *mut FILE;
}
extern "C" {
pub fn _wfopen_s(_Stream: *mut *mut FILE, _FileName: *const u16, _Mode: *const u16) -> errno_t;
}
extern "C" {
pub fn _wfreopen(_FileName: *const u16, _Mode: *const u16, _OldStream: *mut FILE) -> *mut FILE;
}
extern "C" {
pub fn _wfreopen_s(
_Stream: *mut *mut FILE,
_FileName: *const u16,
_Mode: *const u16,
_OldStream: *mut FILE,
) -> errno_t;
}
extern "C" {
pub fn _wfsopen(
_FileName: *const u16,
_Mode: *const u16,
_ShFlag: ::std::os::raw::c_int,
) -> *mut FILE;
}
extern "C" {
pub fn _wpopen(_Command: *const u16, _Mode: *const u16) -> *mut FILE;
}
extern "C" {
pub fn _wremove(_FileName: *const u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wtempnam(_Directory: *const u16, _FilePrefix: *const u16) -> *mut u16;
}
extern "C" {
pub fn _wtmpnam_s(_Buffer: *mut u16, _BufferCount: size_t) -> errno_t;
}
extern "C" {
pub fn _wtmpnam(_Buffer: *mut u16) -> *mut u16;
}
extern "C" {
pub fn _fgetwc_nolock(_Stream: *mut FILE) -> wint_t;
}
extern "C" {
pub fn _fputwc_nolock(_Character: u16, _Stream: *mut FILE) -> wint_t;
}
extern "C" {
pub fn _getwc_nolock(_Stream: *mut FILE) -> wint_t;
}
extern "C" {
pub fn _putwc_nolock(_Character: u16, _Stream: *mut FILE) -> wint_t;
}
extern "C" {
pub fn _ungetwc_nolock(_Character: wint_t, _Stream: *mut FILE) -> wint_t;
}
extern "C" {
pub fn __stdio_common_vfwprintf(
_Options: ::std::os::raw::c_ulonglong,
_Stream: *mut FILE,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vfwprintf_s(
_Options: ::std::os::raw::c_ulonglong,
_Stream: *mut FILE,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vfwprintf_p(
_Options: ::std::os::raw::c_ulonglong,
_Stream: *mut FILE,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vfwscanf(
_Options: ::std::os::raw::c_ulonglong,
_Stream: *mut FILE,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vswprintf(
_Options: ::std::os::raw::c_ulonglong,
_Buffer: *mut u16,
_BufferCount: size_t,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vswprintf_s(
_Options: ::std::os::raw::c_ulonglong,
_Buffer: *mut u16,
_BufferCount: size_t,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vsnwprintf_s(
_Options: ::std::os::raw::c_ulonglong,
_Buffer: *mut u16,
_BufferCount: size_t,
_MaxCount: size_t,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vswprintf_p(
_Options: ::std::os::raw::c_ulonglong,
_Buffer: *mut u16,
_BufferCount: size_t,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vswscanf(
_Options: ::std::os::raw::c_ulonglong,
_Buffer: *const u16,
_BufferCount: size_t,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
pub type fpos_t = ::std::os::raw::c_longlong;
extern "C" {
pub fn _get_stream_buffer_pointers(
_Stream: *mut FILE,
_Base: *mut *mut *mut ::std::os::raw::c_char,
_Pointer: *mut *mut *mut ::std::os::raw::c_char,
_Count: *mut *mut ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn clearerr_s(_Stream: *mut FILE) -> errno_t;
}
extern "C" {
pub fn fopen_s(
_Stream: *mut *mut FILE,
_FileName: *const ::std::os::raw::c_char,
_Mode: *const ::std::os::raw::c_char,
) -> errno_t;
}
extern "C" {
pub fn fread_s(
_Buffer: *mut ::std::os::raw::c_void,
_BufferSize: size_t,
_ElementSize: size_t,
_ElementCount: size_t,
_Stream: *mut FILE,
) -> size_t;
}
extern "C" {
pub fn freopen_s(
_Stream: *mut *mut FILE,
_FileName: *const ::std::os::raw::c_char,
_Mode: *const ::std::os::raw::c_char,
_OldStream: *mut FILE,
) -> errno_t;
}
extern "C" {
pub fn gets_s(
_Buffer: *mut ::std::os::raw::c_char,
_Size: rsize_t,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn tmpfile_s(_Stream: *mut *mut FILE) -> errno_t;
}
extern "C" {
pub fn tmpnam_s(_Buffer: *mut ::std::os::raw::c_char, _Size: rsize_t) -> errno_t;
}
extern "C" {
pub fn clearerr(_Stream: *mut FILE);
}
extern "C" {
pub fn fclose(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fcloseall() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fdopen(
_FileHandle: ::std::os::raw::c_int,
_Mode: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn feof(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ferror(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fflush(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fgetc(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fgetchar() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fgetpos(_Stream: *mut FILE, _Position: *mut fpos_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fgets(
_Buffer: *mut ::std::os::raw::c_char,
_MaxCount: ::std::os::raw::c_int,
_Stream: *mut FILE,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _fileno(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _flushall() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fopen(
_FileName: *const ::std::os::raw::c_char,
_Mode: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn fputc(_Character: ::std::os::raw::c_int, _Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fputchar(_Character: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fputs(
_Buffer: *const ::std::os::raw::c_char,
_Stream: *mut FILE,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fread(
_Buffer: *mut ::std::os::raw::c_void,
_ElementSize: size_t,
_ElementCount: size_t,
_Stream: *mut FILE,
) -> size_t;
}
extern "C" {
pub fn freopen(
_FileName: *const ::std::os::raw::c_char,
_Mode: *const ::std::os::raw::c_char,
_Stream: *mut FILE,
) -> *mut FILE;
}
extern "C" {
pub fn _fsopen(
_FileName: *const ::std::os::raw::c_char,
_Mode: *const ::std::os::raw::c_char,
_ShFlag: ::std::os::raw::c_int,
) -> *mut FILE;
}
extern "C" {
pub fn fsetpos(_Stream: *mut FILE, _Position: *const fpos_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fseek(
_Stream: *mut FILE,
_Offset: ::std::os::raw::c_long,
_Origin: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fseeki64(
_Stream: *mut FILE,
_Offset: ::std::os::raw::c_longlong,
_Origin: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ftell(_Stream: *mut FILE) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn _ftelli64(_Stream: *mut FILE) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn fwrite(
_Buffer: *const ::std::os::raw::c_void,
_ElementSize: size_t,
_ElementCount: size_t,
_Stream: *mut FILE,
) -> size_t;
}
extern "C" {
pub fn getc(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getchar() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _getmaxstdio() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _getw(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _pclose(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _popen(
_Command: *const ::std::os::raw::c_char,
_Mode: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn putc(_Character: ::std::os::raw::c_int, _Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn putchar(_Character: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn puts(_Buffer: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _putw(_Word: ::std::os::raw::c_int, _Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn remove(_FileName: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rename(
_OldFileName: *const ::std::os::raw::c_char,
_NewFileName: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _unlink(_FileName: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn unlink(_FileName: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rewind(_Stream: *mut FILE);
}
extern "C" {
pub fn _rmtmp() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn setbuf(_Stream: *mut FILE, _Buffer: *mut ::std::os::raw::c_char);
}
extern "C" {
pub fn _setmaxstdio(_Maximum: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn setvbuf(
_Stream: *mut FILE,
_Buffer: *mut ::std::os::raw::c_char,
_Mode: ::std::os::raw::c_int,
_Size: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _tempnam(
_DirectoryName: *const ::std::os::raw::c_char,
_FilePrefix: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn tmpfile() -> *mut FILE;
}
extern "C" {
pub fn tmpnam(_Buffer: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn ungetc(_Character: ::std::os::raw::c_int, _Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _lock_file(_Stream: *mut FILE);
}
extern "C" {
pub fn _unlock_file(_Stream: *mut FILE);
}
extern "C" {
pub fn _fclose_nolock(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fflush_nolock(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fgetc_nolock(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fputc_nolock(
_Character: ::std::os::raw::c_int,
_Stream: *mut FILE,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fread_nolock(
_Buffer: *mut ::std::os::raw::c_void,
_ElementSize: size_t,
_ElementCount: size_t,
_Stream: *mut FILE,
) -> size_t;
}
extern "C" {
pub fn _fread_nolock_s(
_Buffer: *mut ::std::os::raw::c_void,
_BufferSize: size_t,
_ElementSize: size_t,
_ElementCount: size_t,
_Stream: *mut FILE,
) -> size_t;
}
extern "C" {
pub fn _fseek_nolock(
_Stream: *mut FILE,
_Offset: ::std::os::raw::c_long,
_Origin: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fseeki64_nolock(
_Stream: *mut FILE,
_Offset: ::std::os::raw::c_longlong,
_Origin: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _ftell_nolock(_Stream: *mut FILE) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn _ftelli64_nolock(_Stream: *mut FILE) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _fwrite_nolock(
_Buffer: *const ::std::os::raw::c_void,
_ElementSize: size_t,
_ElementCount: size_t,
_Stream: *mut FILE,
) -> size_t;
}
extern "C" {
pub fn _getc_nolock(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _putc_nolock(
_Character: ::std::os::raw::c_int,
_Stream: *mut FILE,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _ungetc_nolock(
_Character: ::std::os::raw::c_int,
_Stream: *mut FILE,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __p__commode() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vfprintf(
_Options: ::std::os::raw::c_ulonglong,
_Stream: *mut FILE,
_Format: *const ::std::os::raw::c_char,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vfprintf_s(
_Options: ::std::os::raw::c_ulonglong,
_Stream: *mut FILE,
_Format: *const ::std::os::raw::c_char,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vfprintf_p(
_Options: ::std::os::raw::c_ulonglong,
_Stream: *mut FILE,
_Format: *const ::std::os::raw::c_char,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _set_printf_count_output(_Value: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _get_printf_count_output() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vfscanf(
_Options: ::std::os::raw::c_ulonglong,
_Stream: *mut FILE,
_Format: *const ::std::os::raw::c_char,
_Locale: _locale_t,
_Arglist: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vsprintf(
_Options: ::std::os::raw::c_ulonglong,
_Buffer: *mut ::std::os::raw::c_char,
_BufferCount: size_t,
_Format: *const ::std::os::raw::c_char,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vsprintf_s(
_Options: ::std::os::raw::c_ulonglong,
_Buffer: *mut ::std::os::raw::c_char,
_BufferCount: size_t,
_Format: *const ::std::os::raw::c_char,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vsnprintf_s(
_Options: ::std::os::raw::c_ulonglong,
_Buffer: *mut ::std::os::raw::c_char,
_BufferCount: size_t,
_MaxCount: size_t,
_Format: *const ::std::os::raw::c_char,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vsprintf_p(
_Options: ::std::os::raw::c_ulonglong,
_Buffer: *mut ::std::os::raw::c_char,
_BufferCount: size_t,
_Format: *const ::std::os::raw::c_char,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vsscanf(
_Options: ::std::os::raw::c_ulonglong,
_Buffer: *const ::std::os::raw::c_char,
_BufferCount: size_t,
_Format: *const ::std::os::raw::c_char,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn tempnam(
_Directory: *const ::std::os::raw::c_char,
_FilePrefix: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn fcloseall() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fdopen(
_FileHandle: ::std::os::raw::c_int,
_Format: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn fgetchar() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fileno(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn flushall() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fputchar(_Ch: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getw(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn putw(_Ch: ::std::os::raw::c_int, _Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rmtmp() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn memchr(
_Buf: *const ::std::os::raw::c_void,
_Val: ::std::os::raw::c_int,
_MaxCount: size_t,
) -> *const ::std::os::raw::c_void;
}
extern "C" {
pub fn memcmp(
_Buf1: *const ::std::os::raw::c_void,
_Buf2: *const ::std::os::raw::c_void,
_Size: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn memcpy(
_Dst: *mut ::std::os::raw::c_void,
_Src: *const ::std::os::raw::c_void,
_Size: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn memmove(
_Dst: *mut ::std::os::raw::c_void,
_Src: *const ::std::os::raw::c_void,
_Size: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn memset(
_Dst: *mut ::std::os::raw::c_void,
_Val: ::std::os::raw::c_int,
_Size: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn strchr(
_Str: *const ::std::os::raw::c_char,
_Val: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn strrchr(
_Str: *const ::std::os::raw::c_char,
_Ch: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn strstr(
_Str: *const ::std::os::raw::c_char,
_SubStr: *const ::std::os::raw::c_char,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn wcschr(_Str: *const u16, _Ch: u16) -> *const u16;
}
extern "C" {
pub fn wcsrchr(_Str: *const u16, _Ch: u16) -> *const u16;
}
extern "C" {
pub fn wcsstr(_Str: *const u16, _SubStr: *const u16) -> *const u16;
}
extern "C" {
pub fn _memicmp(
_Buf1: *const ::std::os::raw::c_void,
_Buf2: *const ::std::os::raw::c_void,
_Size: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _memicmp_l(
_Buf1: *const ::std::os::raw::c_void,
_Buf2: *const ::std::os::raw::c_void,
_Size: size_t,
_Locale: _locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn memccpy(
_Dst: *mut ::std::os::raw::c_void,
_Src: *const ::std::os::raw::c_void,
_Val: ::std::os::raw::c_int,
_Size: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn memicmp(
_Buf1: *const ::std::os::raw::c_void,
_Buf2: *const ::std::os::raw::c_void,
_Size: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn wcscat_s(_Destination: *mut u16, _SizeInWords: rsize_t, _Source: *const u16) -> errno_t;
}
extern "C" {
pub fn wcscpy_s(_Destination: *mut u16, _SizeInWords: rsize_t, _Source: *const u16) -> errno_t;
}
extern "C" {
pub fn wcsncat_s(
_Destination: *mut u16,
_SizeInWords: rsize_t,
_Source: *const u16,
_MaxCount: rsize_t,
) -> errno_t;
}
extern "C" {
pub fn wcsncpy_s(
_Destination: *mut u16,
_SizeInWords: rsize_t,
_Source: *const u16,
_MaxCount: rsize_t,
) -> errno_t;
}
extern "C" {
pub fn wcstok_s(_String: *mut u16, _Delimiter: *const u16, _Context: *mut *mut u16)
-> *mut u16;
}
extern "C" {
pub fn _wcsdup(_String: *const u16) -> *mut u16;
}
extern "C" {
pub fn wcscat(_Destination: *mut u16, _Source: *const u16) -> *mut u16;
}
extern "C" {
pub fn wcscmp(_String1: *const u16, _String2: *const u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn wcscpy(_Destination: *mut u16, _Source: *const u16) -> *mut u16;
}
extern "C" {
pub fn wcscspn(_String: *const u16, _Control: *const u16) -> size_t;
}
extern "C" {
pub fn wcslen(_String: *const u16) -> size_t;
}
extern "C" {
pub fn wcsnlen(_Source: *const u16, _MaxCount: size_t) -> size_t;
}
extern "C" {
pub fn wcsncat(_Destination: *mut u16, _Source: *const u16, _Count: size_t) -> *mut u16;
}
extern "C" {
pub fn wcsncmp(
_String1: *const u16,
_String2: *const u16,
_MaxCount: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn wcsncpy(_Destination: *mut u16, _Source: *const u16, _Count: size_t) -> *mut u16;
}
extern "C" {
pub fn wcspbrk(_String: *const u16, _Control: *const u16) -> *const u16;
}
extern "C" {
pub fn wcsspn(_String: *const u16, _Control: *const u16) -> size_t;
}
extern "C" {
pub fn wcstok(_String: *mut u16, _Delimiter: *const u16, _Context: *mut *mut u16) -> *mut u16;
}
extern "C" {
pub fn _wcserror(_ErrorNumber: ::std::os::raw::c_int) -> *mut u16;
}
extern "C" {
pub fn _wcserror_s(
_Buffer: *mut u16,
_SizeInWords: size_t,
_ErrorNumber: ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn __wcserror(_String: *const u16) -> *mut u16;
}
extern "C" {
pub fn __wcserror_s(
_Buffer: *mut u16,
_SizeInWords: size_t,
_ErrorMessage: *const u16,
) -> errno_t;
}
extern "C" {
pub fn _wcsicmp(_String1: *const u16, _String2: *const u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wcsicmp_l(
_String1: *const u16,
_String2: *const u16,
_Locale: _locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wcsnicmp(
_String1: *const u16,
_String2: *const u16,
_MaxCount: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wcsnicmp_l(
_String1: *const u16,
_String2: *const u16,
_MaxCount: size_t,
_Locale: _locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wcsnset_s(
_Destination: *mut u16,
_SizeInWords: size_t,
_Value: u16,
_MaxCount: size_t,
) -> errno_t;
}
extern "C" {
pub fn _wcsnset(_String: *mut u16, _Value: u16, _MaxCount: size_t) -> *mut u16;
}
extern "C" {
pub fn _wcsrev(_String: *mut u16) -> *mut u16;
}
extern "C" {
pub fn _wcsset_s(_Destination: *mut u16, _SizeInWords: size_t, _Value: u16) -> errno_t;
}
extern "C" {
pub fn _wcsset(_String: *mut u16, _Value: u16) -> *mut u16;
}
extern "C" {
pub fn _wcslwr_s(_String: *mut u16, _SizeInWords: size_t) -> errno_t;
}
extern "C" {
pub fn _wcslwr(_String: *mut u16) -> *mut u16;
}
extern "C" {
pub fn _wcslwr_s_l(_String: *mut u16, _SizeInWords: size_t, _Locale: _locale_t) -> errno_t;
}
extern "C" {
pub fn _wcslwr_l(_String: *mut u16, _Locale: _locale_t) -> *mut u16;
}
extern "C" {
pub fn _wcsupr_s(_String: *mut u16, _Size: size_t) -> errno_t;
}
extern "C" {
pub fn _wcsupr(_String: *mut u16) -> *mut u16;
}
extern "C" {
pub fn _wcsupr_s_l(_String: *mut u16, _Size: size_t, _Locale: _locale_t) -> errno_t;
}
extern "C" {
pub fn _wcsupr_l(_String: *mut u16, _Locale: _locale_t) -> *mut u16;
}
extern "C" {
pub fn wcsxfrm(_Destination: *mut u16, _Source: *const u16, _MaxCount: size_t) -> size_t;
}
extern "C" {
pub fn _wcsxfrm_l(
_Destination: *mut u16,
_Source: *const u16,
_MaxCount: size_t,
_Locale: _locale_t,
) -> size_t;
}
extern "C" {
pub fn wcscoll(_String1: *const u16, _String2: *const u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wcscoll_l(
_String1: *const u16,
_String2: *const u16,
_Locale: _locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wcsicoll(_String1: *const u16, _String2: *const u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wcsicoll_l(
_String1: *const u16,
_String2: *const u16,
_Locale: _locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wcsncoll(
_String1: *const u16,
_String2: *const u16,
_MaxCount: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wcsncoll_l(
_String1: *const u16,
_String2: *const u16,
_MaxCount: size_t,
_Locale: _locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wcsnicoll(
_String1: *const u16,
_String2: *const u16,
_MaxCount: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wcsnicoll_l(
_String1: *const u16,
_String2: *const u16,
_MaxCount: size_t,
_Locale: _locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn wcsdup(_String: *const u16) -> *mut u16;
}
extern "C" {
pub fn wcsicmp(_String1: *const u16, _String2: *const u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn wcsnicmp(
_String1: *const u16,
_String2: *const u16,
_MaxCount: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn wcsnset(_String: *mut u16, _Value: u16, _MaxCount: size_t) -> *mut u16;
}
extern "C" {
pub fn wcsrev(_String: *mut u16) -> *mut u16;
}
extern "C" {
pub fn wcsset(_String: *mut u16, _Value: u16) -> *mut u16;
}
extern "C" {
pub fn wcslwr(_String: *mut u16) -> *mut u16;
}
extern "C" {
pub fn wcsupr(_String: *mut u16) -> *mut u16;
}
extern "C" {
pub fn wcsicoll(_String1: *const u16, _String2: *const u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strcpy_s(
_Destination: *mut ::std::os::raw::c_char,
_SizeInBytes: rsize_t,
_Source: *const ::std::os::raw::c_char,
) -> errno_t;
}
extern "C" {
pub fn strcat_s(
_Destination: *mut ::std::os::raw::c_char,
_SizeInBytes: rsize_t,
_Source: *const ::std::os::raw::c_char,
) -> errno_t;
}
extern "C" {
pub fn strerror_s(
_Buffer: *mut ::std::os::raw::c_char,
_SizeInBytes: size_t,
_ErrorNumber: ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn strncat_s(
_Destination: *mut ::std::os::raw::c_char,
_SizeInBytes: rsize_t,
_Source: *const ::std::os::raw::c_char,
_MaxCount: rsize_t,
) -> errno_t;
}
extern "C" {
pub fn strncpy_s(
_Destination: *mut ::std::os::raw::c_char,
_SizeInBytes: rsize_t,
_Source: *const ::std::os::raw::c_char,
_MaxCount: rsize_t,
) -> errno_t;
}
extern "C" {
pub fn strtok_s(
_String: *mut ::std::os::raw::c_char,
_Delimiter: *const ::std::os::raw::c_char,
_Context: *mut *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _memccpy(
_Dst: *mut ::std::os::raw::c_void,
_Src: *const ::std::os::raw::c_void,
_Val: ::std::os::raw::c_int,
_MaxCount: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn strcat(
_Destination: *mut ::std::os::raw::c_char,
_Source: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strcmp(
_Str1: *const ::std::os::raw::c_char,
_Str2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _strcmpi(
_String1: *const ::std::os::raw::c_char,
_String2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strcoll(
_String1: *const ::std::os::raw::c_char,
_String2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _strcoll_l(
_String1: *const ::std::os::raw::c_char,
_String2: *const ::std::os::raw::c_char,
_Locale: _locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strcpy(
_Destination: *mut ::std::os::raw::c_char,
_Source: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strcspn(
_Str: *const ::std::os::raw::c_char,
_Control: *const ::std::os::raw::c_char,
) -> size_t;
}
extern "C" {
pub fn _strdup(_Source: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _strerror(_ErrorMessage: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _strerror_s(
_Buffer: *mut ::std::os::raw::c_char,
_SizeInBytes: size_t,
_ErrorMessage: *const ::std::os::raw::c_char,
) -> errno_t;
}
extern "C" {
pub fn strerror(_ErrorMessage: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _stricmp(
_String1: *const ::std::os::raw::c_char,
_String2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _stricoll(
_String1: *const ::std::os::raw::c_char,
_String2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _stricoll_l(
_String1: *const ::std::os::raw::c_char,
_String2: *const ::std::os::raw::c_char,
_Locale: _locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _stricmp_l(
_String1: *const ::std::os::raw::c_char,
_String2: *const ::std::os::raw::c_char,
_Locale: _locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strlen(_Str: *const ::std::os::raw::c_char) -> size_t;
}
extern "C" {
pub fn _strlwr_s(_String: *mut ::std::os::raw::c_char, _Size: size_t) -> errno_t;
}
extern "C" {
pub fn _strlwr(_String: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _strlwr_s_l(
_String: *mut ::std::os::raw::c_char,
_Size: size_t,
_Locale: _locale_t,
) -> errno_t;
}
extern "C" {
pub fn _strlwr_l(
_String: *mut ::std::os::raw::c_char,
_Locale: _locale_t,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strncat(
_Destination: *mut ::std::os::raw::c_char,
_Source: *const ::std::os::raw::c_char,
_Count: size_t,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strncmp(
_Str1: *const ::std::os::raw::c_char,
_Str2: *const ::std::os::raw::c_char,
_MaxCount: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _strnicmp(
_String1: *const ::std::os::raw::c_char,
_String2: *const ::std::os::raw::c_char,
_MaxCount: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _strnicmp_l(
_String1: *const ::std::os::raw::c_char,
_String2: *const ::std::os::raw::c_char,
_MaxCount: size_t,
_Locale: _locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _strnicoll(
_String1: *const ::std::os::raw::c_char,
_String2: *const ::std::os::raw::c_char,
_MaxCount: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _strnicoll_l(
_String1: *const ::std::os::raw::c_char,
_String2: *const ::std::os::raw::c_char,
_MaxCount: size_t,
_Locale: _locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _strncoll(
_String1: *const ::std::os::raw::c_char,
_String2: *const ::std::os::raw::c_char,
_MaxCount: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _strncoll_l(
_String1: *const ::std::os::raw::c_char,
_String2: *const ::std::os::raw::c_char,
_MaxCount: size_t,
_Locale: _locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __strncnt(_String: *const ::std::os::raw::c_char, _Count: size_t) -> size_t;
}
extern "C" {
pub fn strncpy(
_Destination: *mut ::std::os::raw::c_char,
_Source: *const ::std::os::raw::c_char,
_Count: size_t,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strnlen(_String: *const ::std::os::raw::c_char, _MaxCount: size_t) -> size_t;
}
extern "C" {
pub fn _strnset_s(
_String: *mut ::std::os::raw::c_char,
_SizeInBytes: size_t,
_Value: ::std::os::raw::c_int,
_MaxCount: size_t,
) -> errno_t;
}
extern "C" {
pub fn _strnset(
_Destination: *mut ::std::os::raw::c_char,
_Value: ::std::os::raw::c_int,
_Count: size_t,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strpbrk(
_Str: *const ::std::os::raw::c_char,
_Control: *const ::std::os::raw::c_char,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn _strrev(_Str: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _strset_s(
_Destination: *mut ::std::os::raw::c_char,
_DestinationSize: size_t,
_Value: ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn _strset(
_Destination: *mut ::std::os::raw::c_char,
_Value: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strspn(
_Str: *const ::std::os::raw::c_char,
_Control: *const ::std::os::raw::c_char,
) -> size_t;
}
extern "C" {
pub fn strtok(
_String: *mut ::std::os::raw::c_char,
_Delimiter: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _strupr_s(_String: *mut ::std::os::raw::c_char, _Size: size_t) -> errno_t;
}
extern "C" {
pub fn _strupr(_String: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _strupr_s_l(
_String: *mut ::std::os::raw::c_char,
_Size: size_t,
_Locale: _locale_t,
) -> errno_t;
}
extern "C" {
pub fn _strupr_l(
_String: *mut ::std::os::raw::c_char,
_Locale: _locale_t,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strxfrm(
_Destination: *mut ::std::os::raw::c_char,
_Source: *const ::std::os::raw::c_char,
_MaxCount: size_t,
) -> size_t;
}
extern "C" {
pub fn _strxfrm_l(
_Destination: *mut ::std::os::raw::c_char,
_Source: *const ::std::os::raw::c_char,
_MaxCount: size_t,
_Locale: _locale_t,
) -> size_t;
}
extern "C" {
pub fn strdup(_String: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strcmpi(
_String1: *const ::std::os::raw::c_char,
_String2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn stricmp(
_String1: *const ::std::os::raw::c_char,
_String2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strlwr(_String: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strnicmp(
_String1: *const ::std::os::raw::c_char,
_String2: *const ::std::os::raw::c_char,
_MaxCount: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strnset(
_String: *mut ::std::os::raw::c_char,
_Value: ::std::os::raw::c_int,
_MaxCount: size_t,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strrev(_String: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strset(
_String: *mut ::std::os::raw::c_char,
_Value: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strupr(_String: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _cgetws_s(_Buffer: *mut u16, _BufferCount: size_t, _SizeRead: *mut size_t) -> errno_t;
}
extern "C" {
pub fn _cputws(_Buffer: *const u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _getwch() -> wint_t;
}
extern "C" {
pub fn _getwche() -> wint_t;
}
extern "C" {
pub fn _putwch(_Character: u16) -> wint_t;
}
extern "C" {
pub fn _ungetwch(_Character: wint_t) -> wint_t;
}
extern "C" {
pub fn _getwch_nolock() -> wint_t;
}
extern "C" {
pub fn _getwche_nolock() -> wint_t;
}
extern "C" {
pub fn _putwch_nolock(_Character: u16) -> wint_t;
}
extern "C" {
pub fn _ungetwch_nolock(_Character: wint_t) -> wint_t;
}
extern "C" {
pub fn __conio_common_vcwprintf(
_Options: ::std::os::raw::c_ulonglong,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __conio_common_vcwprintf_s(
_Options: ::std::os::raw::c_ulonglong,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __conio_common_vcwprintf_p(
_Options: ::std::os::raw::c_ulonglong,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __conio_common_vcwscanf(
_Options: ::std::os::raw::c_ulonglong,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __pctype_func() -> *const ::std::os::raw::c_ushort;
}
extern "C" {
pub fn __pwctype_func() -> *const wctype_t;
}
extern "C" {
pub fn iswalnum(_C: wint_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn iswalpha(_C: wint_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn iswascii(_C: wint_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn iswblank(_C: wint_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn iswcntrl(_C: wint_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn iswdigit(_C: wint_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn iswgraph(_C: wint_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn iswlower(_C: wint_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn iswprint(_C: wint_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn iswpunct(_C: wint_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn iswspace(_C: wint_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn iswupper(_C: wint_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn iswxdigit(_C: wint_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __iswcsymf(_C: wint_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __iswcsym(_C: wint_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _iswalnum_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _iswalpha_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _iswblank_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _iswcntrl_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _iswdigit_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _iswgraph_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _iswlower_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _iswprint_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _iswpunct_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _iswspace_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _iswupper_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _iswxdigit_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _iswcsymf_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _iswcsym_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn towupper(_C: wint_t) -> wint_t;
}
extern "C" {
pub fn towlower(_C: wint_t) -> wint_t;
}
extern "C" {
pub fn iswctype(_C: wint_t, _Type: wctype_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _towupper_l(_C: wint_t, _Locale: _locale_t) -> wint_t;
}
extern "C" {
pub fn _towlower_l(_C: wint_t, _Locale: _locale_t) -> wint_t;
}
extern "C" {
pub fn _iswctype_l(_C: wint_t, _Type: wctype_t, _Locale: _locale_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn isleadbyte(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _isleadbyte_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn is_wctype(_C: wint_t, _Type: wctype_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wgetcwd(_DstBuf: *mut u16, _SizeInWords: ::std::os::raw::c_int) -> *mut u16;
}
extern "C" {
pub fn _wgetdcwd(
_Drive: ::std::os::raw::c_int,
_DstBuf: *mut u16,
_SizeInWords: ::std::os::raw::c_int,
) -> *mut u16;
}
extern "C" {
pub fn _wchdir(_Path: *const u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wmkdir(_Path: *const u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wrmdir(_Path: *const u16) -> ::std::os::raw::c_int;
}
pub type _fsize_t = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _wfinddata32_t {
pub attrib: ::std::os::raw::c_uint,
pub time_create: __time32_t,
pub time_access: __time32_t,
pub time_write: __time32_t,
pub size: _fsize_t,
pub name: [u16; 260usize],
}
#[test]
fn bindgen_test_layout__wfinddata32_t() {
assert_eq!(
::std::mem::size_of::<_wfinddata32_t>(),
540usize,
concat!("Size of: ", stringify!(_wfinddata32_t))
);
assert_eq!(
::std::mem::align_of::<_wfinddata32_t>(),
4usize,
concat!("Alignment of ", stringify!(_wfinddata32_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata32_t>())).attrib as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata32_t),
"::",
stringify!(attrib)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata32_t>())).time_create as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata32_t),
"::",
stringify!(time_create)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata32_t>())).time_access as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata32_t),
"::",
stringify!(time_access)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata32_t>())).time_write as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata32_t),
"::",
stringify!(time_write)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata32_t>())).size as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata32_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata32_t>())).name as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata32_t),
"::",
stringify!(name)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _wfinddata32i64_t {
pub attrib: ::std::os::raw::c_uint,
pub time_create: __time32_t,
pub time_access: __time32_t,
pub time_write: __time32_t,
pub size: ::std::os::raw::c_longlong,
pub name: [u16; 260usize],
}
#[test]
fn bindgen_test_layout__wfinddata32i64_t() {
assert_eq!(
::std::mem::size_of::<_wfinddata32i64_t>(),
544usize,
concat!("Size of: ", stringify!(_wfinddata32i64_t))
);
assert_eq!(
::std::mem::align_of::<_wfinddata32i64_t>(),
8usize,
concat!("Alignment of ", stringify!(_wfinddata32i64_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata32i64_t>())).attrib as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata32i64_t),
"::",
stringify!(attrib)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata32i64_t>())).time_create as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata32i64_t),
"::",
stringify!(time_create)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata32i64_t>())).time_access as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata32i64_t),
"::",
stringify!(time_access)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata32i64_t>())).time_write as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata32i64_t),
"::",
stringify!(time_write)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata32i64_t>())).size as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata32i64_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata32i64_t>())).name as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata32i64_t),
"::",
stringify!(name)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _wfinddata64i32_t {
pub attrib: ::std::os::raw::c_uint,
pub time_create: __time64_t,
pub time_access: __time64_t,
pub time_write: __time64_t,
pub size: _fsize_t,
pub name: [u16; 260usize],
}
#[test]
fn bindgen_test_layout__wfinddata64i32_t() {
assert_eq!(
::std::mem::size_of::<_wfinddata64i32_t>(),
560usize,
concat!("Size of: ", stringify!(_wfinddata64i32_t))
);
assert_eq!(
::std::mem::align_of::<_wfinddata64i32_t>(),
8usize,
concat!("Alignment of ", stringify!(_wfinddata64i32_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata64i32_t>())).attrib as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata64i32_t),
"::",
stringify!(attrib)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata64i32_t>())).time_create as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata64i32_t),
"::",
stringify!(time_create)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata64i32_t>())).time_access as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata64i32_t),
"::",
stringify!(time_access)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata64i32_t>())).time_write as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata64i32_t),
"::",
stringify!(time_write)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata64i32_t>())).size as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata64i32_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata64i32_t>())).name as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata64i32_t),
"::",
stringify!(name)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _wfinddata64_t {
pub attrib: ::std::os::raw::c_uint,
pub time_create: __time64_t,
pub time_access: __time64_t,
pub time_write: __time64_t,
pub size: ::std::os::raw::c_longlong,
pub name: [u16; 260usize],
}
#[test]
fn bindgen_test_layout__wfinddata64_t() {
assert_eq!(
::std::mem::size_of::<_wfinddata64_t>(),
560usize,
concat!("Size of: ", stringify!(_wfinddata64_t))
);
assert_eq!(
::std::mem::align_of::<_wfinddata64_t>(),
8usize,
concat!("Alignment of ", stringify!(_wfinddata64_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata64_t>())).attrib as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata64_t),
"::",
stringify!(attrib)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata64_t>())).time_create as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata64_t),
"::",
stringify!(time_create)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata64_t>())).time_access as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata64_t),
"::",
stringify!(time_access)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata64_t>())).time_write as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata64_t),
"::",
stringify!(time_write)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata64_t>())).size as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata64_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_wfinddata64_t>())).name as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_wfinddata64_t),
"::",
stringify!(name)
)
);
}
extern "C" {
pub fn _waccess(
_FileName: *const u16,
_AccessMode: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _waccess_s(_FileName: *const u16, _AccessMode: ::std::os::raw::c_int) -> errno_t;
}
extern "C" {
pub fn _wchmod(_FileName: *const u16, _Mode: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wcreat(
_FileName: *const u16,
_PermissionMode: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wfindfirst32(_FileName: *const u16, _FindData: *mut _wfinddata32_t) -> isize;
}
extern "C" {
pub fn _wfindnext32(
_FindHandle: isize,
_FindData: *mut _wfinddata32_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wunlink(_FileName: *const u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wrename(_OldFileName: *const u16, _NewFileName: *const u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wmktemp_s(_TemplateName: *mut u16, _SizeInWords: size_t) -> errno_t;
}
extern "C" {
pub fn _wmktemp(_TemplateName: *mut u16) -> *mut u16;
}
extern "C" {
pub fn _wfindfirst32i64(_FileName: *const u16, _FindData: *mut _wfinddata32i64_t) -> isize;
}
extern "C" {
pub fn _wfindfirst64i32(_FileName: *const u16, _FindData: *mut _wfinddata64i32_t) -> isize;
}
extern "C" {
pub fn _wfindfirst64(_FileName: *const u16, _FindData: *mut _wfinddata64_t) -> isize;
}
extern "C" {
pub fn _wfindnext32i64(
_FindHandle: isize,
_FindData: *mut _wfinddata32i64_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wfindnext64i32(
_FindHandle: isize,
_FindData: *mut _wfinddata64i32_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wfindnext64(
_FindHandle: isize,
_FindData: *mut _wfinddata64_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wsopen_s(
_FileHandle: *mut ::std::os::raw::c_int,
_FileName: *const u16,
_OpenFlag: ::std::os::raw::c_int,
_ShareFlag: ::std::os::raw::c_int,
_PermissionFlag: ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn _wsopen_dispatch(
_FileName: *const u16,
_OFlag: ::std::os::raw::c_int,
_ShFlag: ::std::os::raw::c_int,
_PMode: ::std::os::raw::c_int,
_PFileHandle: *mut ::std::os::raw::c_int,
_BSecure: ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn _wexecl(_FileName: *const u16, _ArgList: *const u16, ...) -> isize;
}
extern "C" {
pub fn _wexecle(_FileName: *const u16, _ArgList: *const u16, ...) -> isize;
}
extern "C" {
pub fn _wexeclp(_FileName: *const u16, _ArgList: *const u16, ...) -> isize;
}
extern "C" {
pub fn _wexeclpe(_FileName: *const u16, _ArgList: *const u16, ...) -> isize;
}
extern "C" {
pub fn _wexecv(_FileName: *const u16, _ArgList: *const *const u16) -> isize;
}
extern "C" {
pub fn _wexecve(
_FileName: *const u16,
_ArgList: *const *const u16,
_Env: *const *const u16,
) -> isize;
}
extern "C" {
pub fn _wexecvp(_FileName: *const u16, _ArgList: *const *const u16) -> isize;
}
extern "C" {
pub fn _wexecvpe(
_FileName: *const u16,
_ArgList: *const *const u16,
_Env: *const *const u16,
) -> isize;
}
extern "C" {
pub fn _wspawnl(
_Mode: ::std::os::raw::c_int,
_FileName: *const u16,
_ArgList: *const u16,
...
) -> isize;
}
extern "C" {
pub fn _wspawnle(
_Mode: ::std::os::raw::c_int,
_FileName: *const u16,
_ArgList: *const u16,
...
) -> isize;
}
extern "C" {
pub fn _wspawnlp(
_Mode: ::std::os::raw::c_int,
_FileName: *const u16,
_ArgList: *const u16,
...
) -> isize;
}
extern "C" {
pub fn _wspawnlpe(
_Mode: ::std::os::raw::c_int,
_FileName: *const u16,
_ArgList: *const u16,
...
) -> isize;
}
extern "C" {
pub fn _wspawnv(
_Mode: ::std::os::raw::c_int,
_FileName: *const u16,
_ArgList: *const *const u16,
) -> isize;
}
extern "C" {
pub fn _wspawnve(
_Mode: ::std::os::raw::c_int,
_FileName: *const u16,
_ArgList: *const *const u16,
_Env: *const *const u16,
) -> isize;
}
extern "C" {
pub fn _wspawnvp(
_Mode: ::std::os::raw::c_int,
_FileName: *const u16,
_ArgList: *const *const u16,
) -> isize;
}
extern "C" {
pub fn _wspawnvpe(
_Mode: ::std::os::raw::c_int,
_FileName: *const u16,
_ArgList: *const *const u16,
_Env: *const *const u16,
) -> isize;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct tm {
pub tm_sec: ::std::os::raw::c_int,
pub tm_min: ::std::os::raw::c_int,
pub tm_hour: ::std::os::raw::c_int,
pub tm_mday: ::std::os::raw::c_int,
pub tm_mon: ::std::os::raw::c_int,
pub tm_year: ::std::os::raw::c_int,
pub tm_wday: ::std::os::raw::c_int,
pub tm_yday: ::std::os::raw::c_int,
pub tm_isdst: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_tm() {
assert_eq!(
::std::mem::size_of::<tm>(),
36usize,
concat!("Size of: ", stringify!(tm))
);
assert_eq!(
::std::mem::align_of::<tm>(),
4usize,
concat!("Alignment of ", stringify!(tm))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_sec as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_sec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_min as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_min)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_hour as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_hour)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_mday as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_mday)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_mon as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_mon)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_year as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_year)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_wday as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_wday)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_yday as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_yday)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_isdst as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_isdst)
)
);
}
extern "C" {
pub fn _wasctime(_Tm: *const tm) -> *mut u16;
}
extern "C" {
pub fn _wasctime_s(_Buffer: *mut u16, _SizeInWords: size_t, _Tm: *const tm) -> errno_t;
}
extern "C" {
pub fn wcsftime(
_Buffer: *mut u16,
_SizeInWords: size_t,
_Format: *const u16,
_Tm: *const tm,
) -> size_t;
}
extern "C" {
pub fn _wcsftime_l(
_Buffer: *mut u16,
_SizeInWords: size_t,
_Format: *const u16,
_Tm: *const tm,
_Locale: _locale_t,
) -> size_t;
}
extern "C" {
pub fn _wctime32(_Time: *const __time32_t) -> *mut u16;
}
extern "C" {
pub fn _wctime32_s(
_Buffer: *mut u16,
_SizeInWords: size_t,
_Time: *const __time32_t,
) -> errno_t;
}
extern "C" {
pub fn _wctime64(_Time: *const __time64_t) -> *mut u16;
}
extern "C" {
pub fn _wctime64_s(
_Buffer: *mut u16,
_SizeInWords: size_t,
_Time: *const __time64_t,
) -> errno_t;
}
extern "C" {
pub fn _wstrdate_s(_Buffer: *mut u16, _SizeInWords: size_t) -> errno_t;
}
extern "C" {
pub fn _wstrdate(_Buffer: *mut u16) -> *mut u16;
}
extern "C" {
pub fn _wstrtime_s(_Buffer: *mut u16, _SizeInWords: size_t) -> errno_t;
}
extern "C" {
pub fn _wstrtime(_Buffer: *mut u16) -> *mut u16;
}
pub type _ino_t = ::std::os::raw::c_ushort;
pub type ino_t = _ino_t;
pub type _dev_t = ::std::os::raw::c_uint;
pub type dev_t = _dev_t;
pub type _off_t = ::std::os::raw::c_long;
pub type off_t = _off_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _stat32 {
pub st_dev: _dev_t,
pub st_ino: _ino_t,
pub st_mode: ::std::os::raw::c_ushort,
pub st_nlink: ::std::os::raw::c_short,
pub st_uid: ::std::os::raw::c_short,
pub st_gid: ::std::os::raw::c_short,
pub st_rdev: _dev_t,
pub st_size: _off_t,
pub st_atime: __time32_t,
pub st_mtime: __time32_t,
pub st_ctime: __time32_t,
}
#[test]
fn bindgen_test_layout__stat32() {
assert_eq!(
::std::mem::size_of::<_stat32>(),
36usize,
concat!("Size of: ", stringify!(_stat32))
);
assert_eq!(
::std::mem::align_of::<_stat32>(),
4usize,
concat!("Alignment of ", stringify!(_stat32))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32>())).st_dev as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_stat32),
"::",
stringify!(st_dev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32>())).st_ino as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_stat32),
"::",
stringify!(st_ino)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32>())).st_mode as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(_stat32),
"::",
stringify!(st_mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32>())).st_nlink as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_stat32),
"::",
stringify!(st_nlink)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32>())).st_uid as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(_stat32),
"::",
stringify!(st_uid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32>())).st_gid as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_stat32),
"::",
stringify!(st_gid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32>())).st_rdev as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_stat32),
"::",
stringify!(st_rdev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32>())).st_size as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_stat32),
"::",
stringify!(st_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32>())).st_atime as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_stat32),
"::",
stringify!(st_atime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32>())).st_mtime as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(_stat32),
"::",
stringify!(st_mtime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32>())).st_ctime as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_stat32),
"::",
stringify!(st_ctime)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _stat32i64 {
pub st_dev: _dev_t,
pub st_ino: _ino_t,
pub st_mode: ::std::os::raw::c_ushort,
pub st_nlink: ::std::os::raw::c_short,
pub st_uid: ::std::os::raw::c_short,
pub st_gid: ::std::os::raw::c_short,
pub st_rdev: _dev_t,
pub st_size: ::std::os::raw::c_longlong,
pub st_atime: __time32_t,
pub st_mtime: __time32_t,
pub st_ctime: __time32_t,
}
#[test]
fn bindgen_test_layout__stat32i64() {
assert_eq!(
::std::mem::size_of::<_stat32i64>(),
48usize,
concat!("Size of: ", stringify!(_stat32i64))
);
assert_eq!(
::std::mem::align_of::<_stat32i64>(),
8usize,
concat!("Alignment of ", stringify!(_stat32i64))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32i64>())).st_dev as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_stat32i64),
"::",
stringify!(st_dev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32i64>())).st_ino as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_stat32i64),
"::",
stringify!(st_ino)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32i64>())).st_mode as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(_stat32i64),
"::",
stringify!(st_mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32i64>())).st_nlink as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_stat32i64),
"::",
stringify!(st_nlink)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32i64>())).st_uid as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(_stat32i64),
"::",
stringify!(st_uid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32i64>())).st_gid as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_stat32i64),
"::",
stringify!(st_gid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32i64>())).st_rdev as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_stat32i64),
"::",
stringify!(st_rdev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32i64>())).st_size as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_stat32i64),
"::",
stringify!(st_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32i64>())).st_atime as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_stat32i64),
"::",
stringify!(st_atime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32i64>())).st_mtime as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(_stat32i64),
"::",
stringify!(st_mtime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat32i64>())).st_ctime as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_stat32i64),
"::",
stringify!(st_ctime)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _stat64i32 {
pub st_dev: _dev_t,
pub st_ino: _ino_t,
pub st_mode: ::std::os::raw::c_ushort,
pub st_nlink: ::std::os::raw::c_short,
pub st_uid: ::std::os::raw::c_short,
pub st_gid: ::std::os::raw::c_short,
pub st_rdev: _dev_t,
pub st_size: _off_t,
pub st_atime: __time64_t,
pub st_mtime: __time64_t,
pub st_ctime: __time64_t,
}
#[test]
fn bindgen_test_layout__stat64i32() {
assert_eq!(
::std::mem::size_of::<_stat64i32>(),
48usize,
concat!("Size of: ", stringify!(_stat64i32))
);
assert_eq!(
::std::mem::align_of::<_stat64i32>(),
8usize,
concat!("Alignment of ", stringify!(_stat64i32))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64i32>())).st_dev as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_stat64i32),
"::",
stringify!(st_dev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64i32>())).st_ino as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_stat64i32),
"::",
stringify!(st_ino)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64i32>())).st_mode as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(_stat64i32),
"::",
stringify!(st_mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64i32>())).st_nlink as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_stat64i32),
"::",
stringify!(st_nlink)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64i32>())).st_uid as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(_stat64i32),
"::",
stringify!(st_uid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64i32>())).st_gid as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_stat64i32),
"::",
stringify!(st_gid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64i32>())).st_rdev as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_stat64i32),
"::",
stringify!(st_rdev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64i32>())).st_size as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_stat64i32),
"::",
stringify!(st_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64i32>())).st_atime as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_stat64i32),
"::",
stringify!(st_atime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64i32>())).st_mtime as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_stat64i32),
"::",
stringify!(st_mtime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64i32>())).st_ctime as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_stat64i32),
"::",
stringify!(st_ctime)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _stat64 {
pub st_dev: _dev_t,
pub st_ino: _ino_t,
pub st_mode: ::std::os::raw::c_ushort,
pub st_nlink: ::std::os::raw::c_short,
pub st_uid: ::std::os::raw::c_short,
pub st_gid: ::std::os::raw::c_short,
pub st_rdev: _dev_t,
pub st_size: ::std::os::raw::c_longlong,
pub st_atime: __time64_t,
pub st_mtime: __time64_t,
pub st_ctime: __time64_t,
}
#[test]
fn bindgen_test_layout__stat64() {
assert_eq!(
::std::mem::size_of::<_stat64>(),
56usize,
concat!("Size of: ", stringify!(_stat64))
);
assert_eq!(
::std::mem::align_of::<_stat64>(),
8usize,
concat!("Alignment of ", stringify!(_stat64))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64>())).st_dev as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_stat64),
"::",
stringify!(st_dev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64>())).st_ino as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_stat64),
"::",
stringify!(st_ino)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64>())).st_mode as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(_stat64),
"::",
stringify!(st_mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64>())).st_nlink as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_stat64),
"::",
stringify!(st_nlink)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64>())).st_uid as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(_stat64),
"::",
stringify!(st_uid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64>())).st_gid as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_stat64),
"::",
stringify!(st_gid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64>())).st_rdev as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_stat64),
"::",
stringify!(st_rdev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64>())).st_size as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_stat64),
"::",
stringify!(st_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64>())).st_atime as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_stat64),
"::",
stringify!(st_atime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64>())).st_mtime as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_stat64),
"::",
stringify!(st_mtime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_stat64>())).st_ctime as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_stat64),
"::",
stringify!(st_ctime)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct stat {
pub st_dev: _dev_t,
pub st_ino: _ino_t,
pub st_mode: ::std::os::raw::c_ushort,
pub st_nlink: ::std::os::raw::c_short,
pub st_uid: ::std::os::raw::c_short,
pub st_gid: ::std::os::raw::c_short,
pub st_rdev: _dev_t,
pub st_size: _off_t,
pub st_atime: time_t,
pub st_mtime: time_t,
pub st_ctime: time_t,
}
#[test]
fn bindgen_test_layout_stat() {
assert_eq!(
::std::mem::size_of::<stat>(),
48usize,
concat!("Size of: ", stringify!(stat))
);
assert_eq!(
::std::mem::align_of::<stat>(),
8usize,
concat!("Alignment of ", stringify!(stat))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<stat>())).st_dev as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(stat),
"::",
stringify!(st_dev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<stat>())).st_ino as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(stat),
"::",
stringify!(st_ino)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<stat>())).st_mode as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(stat),
"::",
stringify!(st_mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<stat>())).st_nlink as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(stat),
"::",
stringify!(st_nlink)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<stat>())).st_uid as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(stat),
"::",
stringify!(st_uid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<stat>())).st_gid as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(stat),
"::",
stringify!(st_gid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<stat>())).st_rdev as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(stat),
"::",
stringify!(st_rdev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<stat>())).st_size as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(stat),
"::",
stringify!(st_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<stat>())).st_atime as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(stat),
"::",
stringify!(st_atime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<stat>())).st_mtime as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(stat),
"::",
stringify!(st_mtime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<stat>())).st_ctime as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(stat),
"::",
stringify!(st_ctime)
)
);
}
extern "C" {
pub fn _fstat32(
_FileHandle: ::std::os::raw::c_int,
_Stat: *mut _stat32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fstat32i64(
_FileHandle: ::std::os::raw::c_int,
_Stat: *mut _stat32i64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fstat64i32(
_FileHandle: ::std::os::raw::c_int,
_Stat: *mut _stat64i32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fstat64(
_FileHandle: ::std::os::raw::c_int,
_Stat: *mut _stat64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _stat32(
_FileName: *const ::std::os::raw::c_char,
_Stat: *mut _stat32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _stat32i64(
_FileName: *const ::std::os::raw::c_char,
_Stat: *mut _stat32i64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _stat64i32(
_FileName: *const ::std::os::raw::c_char,
_Stat: *mut _stat64i32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _stat64(
_FileName: *const ::std::os::raw::c_char,
_Stat: *mut _stat64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wstat32(_FileName: *const u16, _Stat: *mut _stat32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wstat32i64(_FileName: *const u16, _Stat: *mut _stat32i64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wstat64i32(_FileName: *const u16, _Stat: *mut _stat64i32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wstat64(_FileName: *const u16, _Stat: *mut _stat64) -> ::std::os::raw::c_int;
}
pub type _Wint_t = u16;
extern "C" {
pub fn _wsetlocale(_Category: ::std::os::raw::c_int, _Locale: *const u16) -> *mut u16;
}
extern "C" {
pub fn _wcreate_locale(_Category: ::std::os::raw::c_int, _Locale: *const u16) -> _locale_t;
}
extern "C" {
pub fn btowc(_Ch: ::std::os::raw::c_int) -> wint_t;
}
extern "C" {
pub fn mbrlen(
_Ch: *const ::std::os::raw::c_char,
_SizeInBytes: size_t,
_State: *mut mbstate_t,
) -> size_t;
}
extern "C" {
pub fn mbrtowc(
_DstCh: *mut u16,
_SrcCh: *const ::std::os::raw::c_char,
_SizeInBytes: size_t,
_State: *mut mbstate_t,
) -> size_t;
}
extern "C" {
pub fn mbsrtowcs_s(
_Retval: *mut size_t,
_Dst: *mut u16,
_Size: size_t,
_PSrc: *mut *const ::std::os::raw::c_char,
_N: size_t,
_State: *mut mbstate_t,
) -> errno_t;
}
extern "C" {
pub fn mbsrtowcs(
_Dest: *mut u16,
_PSrc: *mut *const ::std::os::raw::c_char,
_Count: size_t,
_State: *mut mbstate_t,
) -> size_t;
}
extern "C" {
pub fn wcrtomb_s(
_Retval: *mut size_t,
_Dst: *mut ::std::os::raw::c_char,
_SizeInBytes: size_t,
_Ch: u16,
_State: *mut mbstate_t,
) -> errno_t;
}
extern "C" {
pub fn wcrtomb(
_Dest: *mut ::std::os::raw::c_char,
_Source: u16,
_State: *mut mbstate_t,
) -> size_t;
}
extern "C" {
pub fn wcsrtombs_s(
_Retval: *mut size_t,
_Dst: *mut ::std::os::raw::c_char,
_SizeInBytes: size_t,
_Src: *mut *const u16,
_Size: size_t,
_State: *mut mbstate_t,
) -> errno_t;
}
extern "C" {
pub fn wcsrtombs(
_Dest: *mut ::std::os::raw::c_char,
_PSource: *mut *const u16,
_Count: size_t,
_State: *mut mbstate_t,
) -> size_t;
}
extern "C" {
pub fn wctob(_WCh: wint_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn wmemcpy_s(_S1: *mut u16, _N1: rsize_t, _S2: *const u16, _N: rsize_t) -> errno_t;
}
extern "C" {
pub fn wmemmove_s(_S1: *mut u16, _N1: rsize_t, _S2: *const u16, _N: rsize_t) -> errno_t;
}
pub type int_least8_t = ::std::os::raw::c_schar;
pub type int_least16_t = ::std::os::raw::c_short;
pub type int_least32_t = ::std::os::raw::c_int;
pub type int_least64_t = ::std::os::raw::c_longlong;
pub type uint_least8_t = ::std::os::raw::c_uchar;
pub type uint_least16_t = ::std::os::raw::c_ushort;
pub type uint_least32_t = ::std::os::raw::c_uint;
pub type uint_least64_t = ::std::os::raw::c_ulonglong;
pub type int_fast8_t = ::std::os::raw::c_schar;
pub type int_fast16_t = ::std::os::raw::c_int;
pub type int_fast32_t = ::std::os::raw::c_int;
pub type int_fast64_t = ::std::os::raw::c_longlong;
pub type uint_fast8_t = ::std::os::raw::c_uchar;
pub type uint_fast16_t = ::std::os::raw::c_uint;
pub type uint_fast32_t = ::std::os::raw::c_uint;
pub type uint_fast64_t = ::std::os::raw::c_ulonglong;
pub type intmax_t = ::std::os::raw::c_longlong;
pub type uintmax_t = ::std::os::raw::c_ulonglong;
extern "C" {
pub fn _clearfp() -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn _controlfp(
_NewValue: ::std::os::raw::c_uint,
_Mask: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn _set_controlfp(_NewValue: ::std::os::raw::c_uint, _Mask: ::std::os::raw::c_uint);
}
extern "C" {
pub fn _controlfp_s(
_CurrentState: *mut ::std::os::raw::c_uint,
_NewValue: ::std::os::raw::c_uint,
_Mask: ::std::os::raw::c_uint,
) -> errno_t;
}
extern "C" {
pub fn _statusfp() -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn _fpreset();
}
extern "C" {
pub fn _control87(
_NewValue: ::std::os::raw::c_uint,
_Mask: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn __fpecode() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn __fpe_flt_rounds() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _scalb(_X: f64, _Y: ::std::os::raw::c_long) -> f64;
}
extern "C" {
pub fn _logb(_X: f64) -> f64;
}
extern "C" {
pub fn _nextafter(_X: f64, _Y: f64) -> f64;
}
extern "C" {
pub fn _finite(_X: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _isnan(_X: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fpclass(_X: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _scalbf(_X: f32, _Y: ::std::os::raw::c_long) -> f32;
}
extern "C" {
pub fn fpreset();
}
extern "C" {
pub fn _BitScanForward(
_Index: *mut ::std::os::raw::c_ulong,
_Mask: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_uchar;
}
extern "C" {
pub fn _BitScanForward64(
_Index: *mut ::std::os::raw::c_ulong,
_Mask: ::std::os::raw::c_ulonglong,
) -> ::std::os::raw::c_uchar;
}
extern "C" {
pub fn _BitScanReverse(
_Index: *mut ::std::os::raw::c_ulong,
_Mask: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_uchar;
}
extern "C" {
pub fn _BitScanReverse64(
_Index: *mut ::std::os::raw::c_ulong,
_Mask: ::std::os::raw::c_ulonglong,
) -> ::std::os::raw::c_uchar;
}
extern "C" {
pub fn _bittest(
arg1: *const ::std::os::raw::c_long,
arg2: ::std::os::raw::c_long,
) -> ::std::os::raw::c_uchar;
}
extern "C" {
pub fn _InterlockedAnd(
_Value: *mut ::std::os::raw::c_long,
_Mask: ::std::os::raw::c_long,
) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn _InterlockedAnd16(
_Value: *mut ::std::os::raw::c_short,
_Mask: ::std::os::raw::c_short,
) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _InterlockedAnd64(
_Value: *mut ::std::os::raw::c_longlong,
_Mask: ::std::os::raw::c_longlong,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _InterlockedAnd8(
_Value: *mut ::std::os::raw::c_char,
_Mask: ::std::os::raw::c_char,
) -> ::std::os::raw::c_char;
}
extern "C" {
pub fn _InterlockedCompareExchange(
_Destination: *mut ::std::os::raw::c_long,
_Exchange: ::std::os::raw::c_long,
_Comparand: ::std::os::raw::c_long,
) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn _InterlockedCompareExchange16(
_Destination: *mut ::std::os::raw::c_short,
_Exchange: ::std::os::raw::c_short,
_Comparand: ::std::os::raw::c_short,
) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _InterlockedCompareExchange64(
_Destination: *mut ::std::os::raw::c_longlong,
_Exchange: ::std::os::raw::c_longlong,
_Comparand: ::std::os::raw::c_longlong,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _InterlockedCompareExchange8(
_Destination: *mut ::std::os::raw::c_char,
_Exchange: ::std::os::raw::c_char,
_Comparand: ::std::os::raw::c_char,
) -> ::std::os::raw::c_char;
}
extern "C" {
pub fn _InterlockedDecrement(_Addend: *mut ::std::os::raw::c_long) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn _InterlockedDecrement16(
_Addend: *mut ::std::os::raw::c_short,
) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _InterlockedDecrement64(
_Addend: *mut ::std::os::raw::c_longlong,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _InterlockedExchange(
_Target: *mut ::std::os::raw::c_long,
_Value: ::std::os::raw::c_long,
) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn _InterlockedExchange16(
_Target: *mut ::std::os::raw::c_short,
_Value: ::std::os::raw::c_short,
) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _InterlockedExchange64(
_Target: *mut ::std::os::raw::c_longlong,
_Value: ::std::os::raw::c_longlong,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _InterlockedExchange8(
_Target: *mut ::std::os::raw::c_char,
_Value: ::std::os::raw::c_char,
) -> ::std::os::raw::c_char;
}
extern "C" {
pub fn _InterlockedExchangeAdd(
_Addend: *mut ::std::os::raw::c_long,
_Value: ::std::os::raw::c_long,
) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn _InterlockedExchangeAdd16(
_Addend: *mut ::std::os::raw::c_short,
_Value: ::std::os::raw::c_short,
) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _InterlockedExchangeAdd64(
_Addend: *mut ::std::os::raw::c_longlong,
_Value: ::std::os::raw::c_longlong,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _InterlockedExchangeAdd8(
_Addend: *mut ::std::os::raw::c_char,
_Value: ::std::os::raw::c_char,
) -> ::std::os::raw::c_char;
}
extern "C" {
pub fn _InterlockedIncrement(_Addend: *mut ::std::os::raw::c_long) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn _InterlockedIncrement16(
_Addend: *mut ::std::os::raw::c_short,
) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _InterlockedIncrement64(
_Addend: *mut ::std::os::raw::c_longlong,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _InterlockedOr(
_Value: *mut ::std::os::raw::c_long,
_Mask: ::std::os::raw::c_long,
) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn _InterlockedOr16(
_Value: *mut ::std::os::raw::c_short,
_Mask: ::std::os::raw::c_short,
) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _InterlockedOr64(
_Value: *mut ::std::os::raw::c_longlong,
_Mask: ::std::os::raw::c_longlong,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _InterlockedOr8(
_Value: *mut ::std::os::raw::c_char,
_Mask: ::std::os::raw::c_char,
) -> ::std::os::raw::c_char;
}
extern "C" {
pub fn _InterlockedXor(
_Value: *mut ::std::os::raw::c_long,
_Mask: ::std::os::raw::c_long,
) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn _InterlockedXor16(
_Value: *mut ::std::os::raw::c_short,
_Mask: ::std::os::raw::c_short,
) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _InterlockedXor64(
_Value: *mut ::std::os::raw::c_longlong,
_Mask: ::std::os::raw::c_longlong,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _InterlockedXor8(
_Value: *mut ::std::os::raw::c_char,
_Mask: ::std::os::raw::c_char,
) -> ::std::os::raw::c_char;
}
extern "C" {
pub fn _ReadWriteBarrier();
}
extern "C" {
pub fn __iso_volatile_load16(arg1: *const ::std::os::raw::c_short) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn __iso_volatile_load32(arg1: *const ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __iso_volatile_load64(
arg1: *const ::std::os::raw::c_longlong,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn __iso_volatile_load8(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_char;
}
extern "C" {
pub fn __iso_volatile_store16(
arg1: *mut ::std::os::raw::c_short,
arg2: ::std::os::raw::c_short,
);
}
extern "C" {
pub fn __iso_volatile_store32(arg1: *mut ::std::os::raw::c_int, arg2: ::std::os::raw::c_int);
}
extern "C" {
pub fn __iso_volatile_store64(
arg1: *mut ::std::os::raw::c_longlong,
arg2: ::std::os::raw::c_longlong,
);
}
extern "C" {
pub fn __iso_volatile_store8(arg1: *mut ::std::os::raw::c_char, arg2: ::std::os::raw::c_char);
}
extern "C" {
pub fn _interlockedbittestandset(
arg1: *mut ::std::os::raw::c_long,
arg2: ::std::os::raw::c_long,
) -> ::std::os::raw::c_uchar;
}
extern "C" {
pub fn __shiftright128(
_LowPart: ::std::os::raw::c_ulonglong,
_HighPart: ::std::os::raw::c_ulonglong,
_Shift: ::std::os::raw::c_uchar,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn _umul128(
_Multiplier: ::std::os::raw::c_ulonglong,
_Multiplicand: ::std::os::raw::c_ulonglong,
_HighProduct: *mut ::std::os::raw::c_ulonglong,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn __builtin_assume_aligned(
arg1: *const ::std::os::raw::c_void,
arg2: size_t,
...
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn __std_reverse_trivially_swappable_1(
_First: *mut ::std::os::raw::c_void,
_Last: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn __std_reverse_trivially_swappable_2(
_First: *mut ::std::os::raw::c_void,
_Last: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn __std_reverse_trivially_swappable_4(
_First: *mut ::std::os::raw::c_void,
_Last: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn __std_reverse_trivially_swappable_8(
_First: *mut ::std::os::raw::c_void,
_Last: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn __std_swap_ranges_trivially_swappable_noalias(
_First1: *mut ::std::os::raw::c_void,
_Last1: *mut ::std::os::raw::c_void,
_First2: *mut ::std::os::raw::c_void,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __type_info_node {
_unused: [u8; 0],
}
extern "C" {
#[link_name = "\u{1}?__type_info_root_node@@3U__type_info_node@@A"]
pub static mut __type_info_root_node: __type_info_node;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __std_type_info_data {
pub _UndecoratedName: *const ::std::os::raw::c_char,
pub _DecoratedName: [::std::os::raw::c_char; 1usize],
}
#[test]
fn bindgen_test_layout___std_type_info_data() {
assert_eq!(
::std::mem::size_of::<__std_type_info_data>(),
16usize,
concat!("Size of: ", stringify!(__std_type_info_data))
);
assert_eq!(
::std::mem::align_of::<__std_type_info_data>(),
8usize,
concat!("Alignment of ", stringify!(__std_type_info_data))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__std_type_info_data>()))._UndecoratedName as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__std_type_info_data),
"::",
stringify!(_UndecoratedName)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__std_type_info_data>()))._DecoratedName as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(__std_type_info_data),
"::",
stringify!(_DecoratedName)
)
);
}
extern "C" {
pub fn __std_type_info_compare(
_Lhs: *const __std_type_info_data,
_Rhs: *const __std_type_info_data,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __std_type_info_hash(_Data: *const __std_type_info_data) -> size_t;
}
extern "C" {
pub fn __std_type_info_name(
_Data: *mut __std_type_info_data,
_RootNode: *mut __type_info_node,
) -> *const ::std::os::raw::c_char;
}
#[repr(C)]
pub struct type_info__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug)]
pub struct type_info {
pub vtable_: *const type_info__bindgen_vtable,
pub _Data: __std_type_info_data,
}
#[test]
fn bindgen_test_layout_type_info() {
assert_eq!(
::std::mem::size_of::<type_info>(),
24usize,
concat!("Size of: ", stringify!(type_info))
);
assert_eq!(
::std::mem::align_of::<type_info>(),
8usize,
concat!("Alignment of ", stringify!(type_info))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<type_info>()))._Data as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(type_info),
"::",
stringify!(_Data)
)
);
}
extern "C" {
#[link_name = "\u{1}??_Dtype_info@@QEAAXXZ"]
pub fn type_info_type_info_destructor(this: *mut type_info);
}
pub type fmx_uint16 = ::std::os::raw::c_ushort;
pub type fmx_int16 = ::std::os::raw::c_short;
pub type fmx_uchar = ::std::os::raw::c_uchar;
pub type fmx_int32 = ::std::os::raw::c_int;
pub type fmx_uint32 = ::std::os::raw::c_uint;
pub type fmx_int64 = ::std::os::raw::c_longlong;
pub type fmx_uint64 = ::std::os::raw::c_ulonglong;
pub type fmx_ptrtype = fmx_uint64;
pub type fmx_unusedid = fmx_int16;
pub type fmx_errcode = ::std::os::raw::c_short;
pub type fmx_unichar16 = ::std::os::raw::c_ushort;
pub type fmx_unichar = fmx_unichar16;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fmx__fmxcpt {
pub m_vers: fmx_int32,
pub m_code: fmx_int32,
}
pub const fmx__fmxcpt_kNoErr: fmx__fmxcpt__bindgen_ty_1 = 0;
pub const fmx__fmxcpt_kBadAlloc: fmx__fmxcpt__bindgen_ty_1 = 1;
pub const fmx__fmxcpt_kUnknown: fmx__fmxcpt__bindgen_ty_1 = 2;
pub type fmx__fmxcpt__bindgen_ty_1 = i32;
#[test]
fn bindgen_test_layout_fmx__fmxcpt() {
assert_eq!(
::std::mem::size_of::<fmx__fmxcpt>(),
8usize,
concat!("Size of: ", stringify!(fmx__fmxcpt))
);
assert_eq!(
::std::mem::align_of::<fmx__fmxcpt>(),
4usize,
concat!("Alignment of ", stringify!(fmx__fmxcpt))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<fmx__fmxcpt>())).m_vers as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(fmx__fmxcpt),
"::",
stringify!(m_vers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<fmx__fmxcpt>())).m_code as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(fmx__fmxcpt),
"::",
stringify!(m_code)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fmx_QuadChar {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_fmx_QuadChar() {
assert_eq!(
::std::mem::size_of::<fmx_QuadChar>(),
1usize,
concat!("Size of: ", stringify!(fmx_QuadChar))
);
assert_eq!(
::std::mem::align_of::<fmx_QuadChar>(),
1usize,
concat!("Alignment of ", stringify!(fmx_QuadChar))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fmx_Locale {
pub _address: u8,
}
pub const fmx_Locale_Type_kType_None: fmx_Locale_Type = 0;
pub const fmx_Locale_Type_kType_System: fmx_Locale_Type = 1;
pub const fmx_Locale_Type_kType_UnicodeRaw: fmx_Locale_Type = 2;
pub const fmx_Locale_Type_kType_UnicodeStandard: fmx_Locale_Type = 3;
pub const fmx_Locale_Type_kType_Catalog: fmx_Locale_Type = 4;
pub const fmx_Locale_Type_kType_CAT: fmx_Locale_Type = 16;
pub const fmx_Locale_Type_kType_HRV: fmx_Locale_Type = 17;
pub const fmx_Locale_Type_kType_CES: fmx_Locale_Type = 18;
pub const fmx_Locale_Type_kType_DAN: fmx_Locale_Type = 19;
pub const fmx_Locale_Type_kType_NLD: fmx_Locale_Type = 20;
pub const fmx_Locale_Type_kType_ENG: fmx_Locale_Type = 21;
pub const fmx_Locale_Type_kType_FIN: fmx_Locale_Type = 22;
pub const fmx_Locale_Type_kType_FIN_fmi: fmx_Locale_Type = 23;
pub const fmx_Locale_Type_kType_FRA: fmx_Locale_Type = 24;
pub const fmx_Locale_Type_kType_DEU: fmx_Locale_Type = 25;
pub const fmx_Locale_Type_kType_DEU_dictionary: fmx_Locale_Type = 26;
pub const fmx_Locale_Type_kType_ELL: fmx_Locale_Type = 27;
pub const fmx_Locale_Type_kType_HUN: fmx_Locale_Type = 28;
pub const fmx_Locale_Type_kType_ISL: fmx_Locale_Type = 29;
pub const fmx_Locale_Type_kType_ITA: fmx_Locale_Type = 30;
pub const fmx_Locale_Type_kType_JPN: fmx_Locale_Type = 31;
pub const fmx_Locale_Type_kType_NOR: fmx_Locale_Type = 32;
pub const fmx_Locale_Type_kType_POL: fmx_Locale_Type = 33;
pub const fmx_Locale_Type_kType_POR: fmx_Locale_Type = 34;
pub const fmx_Locale_Type_kType_RON: fmx_Locale_Type = 35;
pub const fmx_Locale_Type_kType_RUS: fmx_Locale_Type = 36;
pub const fmx_Locale_Type_kType_SLK: fmx_Locale_Type = 37;
pub const fmx_Locale_Type_kType_SLV: fmx_Locale_Type = 38;
pub const fmx_Locale_Type_kType_SPA: fmx_Locale_Type = 39;
pub const fmx_Locale_Type_kType_SPA_traditional: fmx_Locale_Type = 40;
pub const fmx_Locale_Type_kType_SWE: fmx_Locale_Type = 41;
pub const fmx_Locale_Type_kType_SWE_fmi: fmx_Locale_Type = 42;
pub const fmx_Locale_Type_kType_TUR: fmx_Locale_Type = 43;
pub const fmx_Locale_Type_kType_UKR: fmx_Locale_Type = 44;
pub const fmx_Locale_Type_kType_CHI: fmx_Locale_Type = 45;
pub const fmx_Locale_Type_kType_CHI_stroke: fmx_Locale_Type = 46;
pub const fmx_Locale_Type_kType_KOR: fmx_Locale_Type = 76;
pub const fmx_Locale_Type_kType_HE: fmx_Locale_Type = 47;
pub const fmx_Locale_Type_kType_HI: fmx_Locale_Type = 48;
pub const fmx_Locale_Type_kType_AR: fmx_Locale_Type = 49;
pub const fmx_Locale_Type_kType_ET: fmx_Locale_Type = 50;
pub const fmx_Locale_Type_kType_LT: fmx_Locale_Type = 51;
pub const fmx_Locale_Type_kType_LV: fmx_Locale_Type = 52;
pub const fmx_Locale_Type_kType_SR: fmx_Locale_Type = 53;
pub const fmx_Locale_Type_kType_FA: fmx_Locale_Type = 54;
pub const fmx_Locale_Type_kType_BG: fmx_Locale_Type = 55;
pub const fmx_Locale_Type_kType_VI: fmx_Locale_Type = 56;
pub const fmx_Locale_Type_kType_TH: fmx_Locale_Type = 57;
pub const fmx_Locale_Type_kType_ELL_Mixed: fmx_Locale_Type = 58;
pub const fmx_Locale_Type_kType_BEN: fmx_Locale_Type = 59;
pub const fmx_Locale_Type_kType_TEL: fmx_Locale_Type = 60;
pub const fmx_Locale_Type_kType_MAR: fmx_Locale_Type = 61;
pub const fmx_Locale_Type_kType_TAM: fmx_Locale_Type = 62;
pub const fmx_Locale_Type_kType_GUJ: fmx_Locale_Type = 63;
pub const fmx_Locale_Type_kType_KAN: fmx_Locale_Type = 64;
pub const fmx_Locale_Type_kType_MAL: fmx_Locale_Type = 65;
pub const fmx_Locale_Type_kType_PAN: fmx_Locale_Type = 67;
pub const fmx_Locale_Type_kType_ORI: fmx_Locale_Type = 66;
pub const fmx_Locale_Type_kType_SIN: fmx_Locale_Type = 68;
pub const fmx_Locale_Type_kType_URD: fmx_Locale_Type = 69;
pub const fmx_Locale_Type_kType_DIV: fmx_Locale_Type = 70;
pub const fmx_Locale_Type_kType_BUR: fmx_Locale_Type = 71;
pub const fmx_Locale_Type_kType_SAN: fmx_Locale_Type = 72;
pub const fmx_Locale_Type_kType_LAO: fmx_Locale_Type = 73;
pub const fmx_Locale_Type_kType_KHM: fmx_Locale_Type = 74;
pub const fmx_Locale_Type_kType_BOD: fmx_Locale_Type = 75;
pub const fmx_Locale_Type_kType_Invalid: fmx_Locale_Type = 65535;
pub type fmx_Locale_Type = i32;
#[test]
fn bindgen_test_layout_fmx_Locale() {
assert_eq!(
::std::mem::size_of::<fmx_Locale>(),
1usize,
concat!("Size of: ", stringify!(fmx_Locale))
);
assert_eq!(
::std::mem::align_of::<fmx_Locale>(),
1usize,
concat!("Alignment of ", stringify!(fmx_Locale))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_QuadCharAutoPtr {
pub _base: std_auto_ptr<fmx_QuadChar>,
}
pub type fmx_QuadCharAutoPtr_UpCaster = fmx_QuadCharAutoPtr;
#[test]
fn bindgen_test_layout_fmx_QuadCharAutoPtr() {
assert_eq!(
::std::mem::size_of::<fmx_QuadCharAutoPtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_QuadCharAutoPtr))
);
assert_eq!(
::std::mem::align_of::<fmx_QuadCharAutoPtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_QuadCharAutoPtr))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_LocaleAutoPtr {
pub _base: std_auto_ptr<fmx_Locale>,
}
pub type fmx_LocaleAutoPtr_UpCaster = fmx_LocaleAutoPtr;
#[test]
fn bindgen_test_layout_fmx_LocaleAutoPtr() {
assert_eq!(
::std::mem::size_of::<fmx_LocaleAutoPtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_LocaleAutoPtr))
);
assert_eq!(
::std::mem::align_of::<fmx_LocaleAutoPtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_LocaleAutoPtr))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_QuadCharUniquePtr {
pub _base: std_unique_ptr,
}
pub type fmx_QuadCharUniquePtr_UpCaster = fmx_QuadCharUniquePtr;
#[test]
fn bindgen_test_layout_fmx_QuadCharUniquePtr() {
assert_eq!(
::std::mem::size_of::<fmx_QuadCharUniquePtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_QuadCharUniquePtr))
);
assert_eq!(
::std::mem::align_of::<fmx_QuadCharUniquePtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_QuadCharUniquePtr))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_LocaleUniquePtr {
pub _base: std_unique_ptr,
}
pub type fmx_LocaleUniquePtr_UpCaster = fmx_LocaleUniquePtr;
#[test]
fn bindgen_test_layout_fmx_LocaleUniquePtr() {
assert_eq!(
::std::mem::size_of::<fmx_LocaleUniquePtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_LocaleUniquePtr))
);
assert_eq!(
::std::mem::align_of::<fmx_LocaleUniquePtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_LocaleUniquePtr))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fmx_BinaryData {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_fmx_BinaryData() {
assert_eq!(
::std::mem::size_of::<fmx_BinaryData>(),
1usize,
concat!("Size of: ", stringify!(fmx_BinaryData))
);
assert_eq!(
::std::mem::align_of::<fmx_BinaryData>(),
1usize,
concat!("Alignment of ", stringify!(fmx_BinaryData))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_BinaryDataAutoPtr {
pub _base: std_auto_ptr<fmx_BinaryData>,
}
pub type fmx_BinaryDataAutoPtr_UpCaster = fmx_BinaryDataAutoPtr;
#[test]
fn bindgen_test_layout_fmx_BinaryDataAutoPtr() {
assert_eq!(
::std::mem::size_of::<fmx_BinaryDataAutoPtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_BinaryDataAutoPtr))
);
assert_eq!(
::std::mem::align_of::<fmx_BinaryDataAutoPtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_BinaryDataAutoPtr))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_BinaryDataUniquePtr {
pub _base: std_unique_ptr,
}
pub type fmx_BinaryDataUniquePtr_UpCaster = fmx_BinaryDataUniquePtr;
#[test]
fn bindgen_test_layout_fmx_BinaryDataUniquePtr() {
assert_eq!(
::std::mem::size_of::<fmx_BinaryDataUniquePtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_BinaryDataUniquePtr))
);
assert_eq!(
::std::mem::align_of::<fmx_BinaryDataUniquePtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_BinaryDataUniquePtr))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fmx_DataVect {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_fmx_DataVect() {
assert_eq!(
::std::mem::size_of::<fmx_DataVect>(),
1usize,
concat!("Size of: ", stringify!(fmx_DataVect))
);
assert_eq!(
::std::mem::align_of::<fmx_DataVect>(),
1usize,
concat!("Alignment of ", stringify!(fmx_DataVect))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fmx_RowVect {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_fmx_RowVect() {
assert_eq!(
::std::mem::size_of::<fmx_RowVect>(),
1usize,
concat!("Size of: ", stringify!(fmx_RowVect))
);
assert_eq!(
::std::mem::align_of::<fmx_RowVect>(),
1usize,
concat!("Alignment of ", stringify!(fmx_RowVect))
);
}
pub type fmx_ExtPluginType = ::std::option::Option<
unsafe extern "C" fn(
functionId: ::std::os::raw::c_short,
env: *const fmx_ExprEnv,
parms: *const fmx_DataVect,
result: *mut fmx_Data,
) -> fmx_errcode,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fmx_ExprEnv {
pub _address: u8,
}
pub const fmx_ExprEnv_kMayEvaluateOnServer: fmx_ExprEnv__bindgen_ty_1 = 1;
pub const fmx_ExprEnv_kDisplayCalcFields: fmx_ExprEnv__bindgen_ty_1 = 256;
pub const fmx_ExprEnv_kDisplayAutoEnter: fmx_ExprEnv__bindgen_ty_1 = 512;
pub const fmx_ExprEnv_kDisplayValidation: fmx_ExprEnv__bindgen_ty_1 = 1024;
pub const fmx_ExprEnv_kDisplayCustomFunctions: fmx_ExprEnv__bindgen_ty_1 = 2048;
pub const fmx_ExprEnv_kDisplayPrivileges: fmx_ExprEnv__bindgen_ty_1 = 4096;
pub const fmx_ExprEnv_kDisplayInFuture1: fmx_ExprEnv__bindgen_ty_1 = 8192;
pub const fmx_ExprEnv_kDisplayInFuture2: fmx_ExprEnv__bindgen_ty_1 = 16384;
pub const fmx_ExprEnv_kDisplayGeneric: fmx_ExprEnv__bindgen_ty_1 = 32768;
pub const fmx_ExprEnv_kDisplayInAllDialogs: fmx_ExprEnv__bindgen_ty_1 = 65280;
pub const fmx_ExprEnv_kMacCompatible: fmx_ExprEnv__bindgen_ty_1 = 2;
pub const fmx_ExprEnv_kWinCompatible: fmx_ExprEnv__bindgen_ty_1 = 4;
pub const fmx_ExprEnv_kServerCompatible: fmx_ExprEnv__bindgen_ty_1 = 8;
pub const fmx_ExprEnv_kIOSCompatible: fmx_ExprEnv__bindgen_ty_1 = 16;
pub const fmx_ExprEnv_kCustomWebCompatible: fmx_ExprEnv__bindgen_ty_1 = 32;
pub const fmx_ExprEnv_kWebDirectCompatible: fmx_ExprEnv__bindgen_ty_1 = 64;
pub const fmx_ExprEnv_kAllDeviceCompatible: fmx_ExprEnv__bindgen_ty_1 = 126;
pub const fmx_ExprEnv_kFutureCompatible: fmx_ExprEnv__bindgen_ty_1 = 16711806;
pub const fmx_ExprEnv_kPluginErrResult1: fmx_ExprEnv__bindgen_ty_1 = 1552;
pub const fmx_ExprEnv_kPluginErrResult2: fmx_ExprEnv__bindgen_ty_1 = 1553;
pub const fmx_ExprEnv_kPluginErrResult3: fmx_ExprEnv__bindgen_ty_1 = 1554;
pub const fmx_ExprEnv_kPluginErrResult4: fmx_ExprEnv__bindgen_ty_1 = 1555;
pub const fmx_ExprEnv_kPluginErrResult5: fmx_ExprEnv__bindgen_ty_1 = 1556;
pub const fmx_ExprEnv_kPluginErrResult6: fmx_ExprEnv__bindgen_ty_1 = 1557;
pub const fmx_ExprEnv_kPluginErrResult7: fmx_ExprEnv__bindgen_ty_1 = 1558;
pub const fmx_ExprEnv_kPluginErrResult8: fmx_ExprEnv__bindgen_ty_1 = 1559;
pub const fmx_ExprEnv_kGet_ApplicationVersion: fmx_ExprEnv__bindgen_ty_1 = 1001;
pub const fmx_ExprEnv_kGet_CurrentDate: fmx_ExprEnv__bindgen_ty_1 = 1002;
pub const fmx_ExprEnv_kGet_LastError: fmx_ExprEnv__bindgen_ty_1 = 1003;
pub const fmx_ExprEnv_kGet_ActiveFieldName: fmx_ExprEnv__bindgen_ty_1 = 1004;
pub const fmx_ExprEnv_kGet_FileName: fmx_ExprEnv__bindgen_ty_1 = 1005;
pub const fmx_ExprEnv_kGet_FileSize: fmx_ExprEnv__bindgen_ty_1 = 1006;
pub const fmx_ExprEnv_kGet_FoundCount: fmx_ExprEnv__bindgen_ty_1 = 1007;
pub const fmx_ExprEnv_kGet_HostName: fmx_ExprEnv__bindgen_ty_1 = 1008;
pub const fmx_ExprEnv_kGet_LayoutCount: fmx_ExprEnv__bindgen_ty_1 = 1009;
pub const fmx_ExprEnv_kGet_LayoutName: fmx_ExprEnv__bindgen_ty_1 = 1010;
pub const fmx_ExprEnv_kGet_LayoutNumber: fmx_ExprEnv__bindgen_ty_1 = 1011;
pub const fmx_ExprEnv_kGet_SystemLanguage: fmx_ExprEnv__bindgen_ty_1 = 1012;
pub const fmx_ExprEnv_kGet_WindowMode: fmx_ExprEnv__bindgen_ty_1 = 1013;
pub const fmx_ExprEnv_kGet_MultiUserState: fmx_ExprEnv__bindgen_ty_1 = 1014;
pub const fmx_ExprEnv_kGet_PageNumber: fmx_ExprEnv__bindgen_ty_1 = 1015;
pub const fmx_ExprEnv_kGet_SystemPlatform: fmx_ExprEnv__bindgen_ty_1 = 1016;
pub const fmx_ExprEnv_kGet_ActivePortalRowNumber: fmx_ExprEnv__bindgen_ty_1 = 1017;
pub const fmx_ExprEnv_kGet_PrinterName: fmx_ExprEnv__bindgen_ty_1 = 1018;
pub const fmx_ExprEnv_kGet_TotalRecordCount: fmx_ExprEnv__bindgen_ty_1 = 1019;
pub const fmx_ExprEnv_kGet_RecordNumber: fmx_ExprEnv__bindgen_ty_1 = 1020;
pub const fmx_ExprEnv_kGet_ActiveRepetitionNumber: fmx_ExprEnv__bindgen_ty_1 = 1021;
pub const fmx_ExprEnv_kGet_RequestCount: fmx_ExprEnv__bindgen_ty_1 = 1022;
pub const fmx_ExprEnv_kGet_ScreenDepth: fmx_ExprEnv__bindgen_ty_1 = 1023;
pub const fmx_ExprEnv_kGet_ScreenHeight: fmx_ExprEnv__bindgen_ty_1 = 1024;
pub const fmx_ExprEnv_kGet_ScreenWidth: fmx_ExprEnv__bindgen_ty_1 = 1025;
pub const fmx_ExprEnv_kGet_ScriptName: fmx_ExprEnv__bindgen_ty_1 = 1026;
pub const fmx_ExprEnv_kGet_SortState: fmx_ExprEnv__bindgen_ty_1 = 1027;
pub const fmx_ExprEnv_kGet_SystemVersion: fmx_ExprEnv__bindgen_ty_1 = 1028;
pub const fmx_ExprEnv_kGet_CurrentTime: fmx_ExprEnv__bindgen_ty_1 = 1029;
pub const fmx_ExprEnv_kGet_UserCount: fmx_ExprEnv__bindgen_ty_1 = 1030;
pub const fmx_ExprEnv_kGet_UserName: fmx_ExprEnv__bindgen_ty_1 = 1031;
pub const fmx_ExprEnv_kGet_AccountName: fmx_ExprEnv__bindgen_ty_1 = 1032;
pub const fmx_ExprEnv_kGet_LastMessageChoice: fmx_ExprEnv__bindgen_ty_1 = 1033;
pub const fmx_ExprEnv_kGet_CurrentPrivilegeSetName: fmx_ExprEnv__bindgen_ty_1 = 1034;
pub const fmx_ExprEnv_kGet_ActiveModifierKeys: fmx_ExprEnv__bindgen_ty_1 = 1035;
pub const fmx_ExprEnv_kGet_NetworkProtocol: fmx_ExprEnv__bindgen_ty_1 = 1036;
pub const fmx_ExprEnv_kGet_RecordID: fmx_ExprEnv__bindgen_ty_1 = 1037;
pub const fmx_ExprEnv_kGet_RecordModificationCount: fmx_ExprEnv__bindgen_ty_1 = 1038;
pub const fmx_ExprEnv_kGet_ActiveFieldContents: fmx_ExprEnv__bindgen_ty_1 = 1039;
pub const fmx_ExprEnv_kGet_FilePath: fmx_ExprEnv__bindgen_ty_1 = 1040;
pub const fmx_ExprEnv_kGet_LastExternalErrorDetail: fmx_ExprEnv__bindgen_ty_1 = 1041;
pub const fmx_ExprEnv_kGet_LayoutAccess: fmx_ExprEnv__bindgen_ty_1 = 1042;
pub const fmx_ExprEnv_kGet_RecordAccess: fmx_ExprEnv__bindgen_ty_1 = 1043;
pub const fmx_ExprEnv_kGet_HighContrastState: fmx_ExprEnv__bindgen_ty_1 = 1044;
pub const fmx_ExprEnv_kGet_HighContrastColor: fmx_ExprEnv__bindgen_ty_1 = 1045;
pub const fmx_ExprEnv_kGet_StatusAreaState: fmx_ExprEnv__bindgen_ty_1 = 1046;
pub const fmx_ExprEnv_kGet_LayoutViewState: fmx_ExprEnv__bindgen_ty_1 = 1047;
pub const fmx_ExprEnv_kGet_WindowName: fmx_ExprEnv__bindgen_ty_1 = 1048;
pub const fmx_ExprEnv_kGet_WindowHeight: fmx_ExprEnv__bindgen_ty_1 = 1049;
pub const fmx_ExprEnv_kGet_WindowLeft: fmx_ExprEnv__bindgen_ty_1 = 1050;
pub const fmx_ExprEnv_kGet_WindowTop: fmx_ExprEnv__bindgen_ty_1 = 1051;
pub const fmx_ExprEnv_kGet_WindowVisible: fmx_ExprEnv__bindgen_ty_1 = 1052;
pub const fmx_ExprEnv_kGet_WindowWidth: fmx_ExprEnv__bindgen_ty_1 = 1053;
pub const fmx_ExprEnv_kGet_SystemNICAddress: fmx_ExprEnv__bindgen_ty_1 = 1054;
pub const fmx_ExprEnv_kGet_SystemIpAddress: fmx_ExprEnv__bindgen_ty_1 = 1055;
pub const fmx_ExprEnv_kGet_ActiveFieldTableName: fmx_ExprEnv__bindgen_ty_1 = 1056;
pub const fmx_ExprEnv_kGet_ActiveSelectionSize: fmx_ExprEnv__bindgen_ty_1 = 1057;
pub const fmx_ExprEnv_kGet_ActiveSelectionStart: fmx_ExprEnv__bindgen_ty_1 = 1058;
pub const fmx_ExprEnv_kGet_ApplicationLanguage: fmx_ExprEnv__bindgen_ty_1 = 1059;
pub const fmx_ExprEnv_kGet_CurrentHostTimestamp: fmx_ExprEnv__bindgen_ty_1 = 1060;
pub const fmx_ExprEnv_kGet_LayoutTableName: fmx_ExprEnv__bindgen_ty_1 = 1061;
pub const fmx_ExprEnv_kGet_ScriptParameter: fmx_ExprEnv__bindgen_ty_1 = 1062;
pub const fmx_ExprEnv_kGet_CurrentTimeStamp: fmx_ExprEnv__bindgen_ty_1 = 1063;
pub const fmx_ExprEnv_kGet_WindowDesktopHeight: fmx_ExprEnv__bindgen_ty_1 = 1064;
pub const fmx_ExprEnv_kGet_WindowDesktopWidth: fmx_ExprEnv__bindgen_ty_1 = 1065;
pub const fmx_ExprEnv_kGet_WindowContentHeight: fmx_ExprEnv__bindgen_ty_1 = 1066;
pub const fmx_ExprEnv_kGet_WindowContentWidth: fmx_ExprEnv__bindgen_ty_1 = 1067;
pub const fmx_ExprEnv_kGet_CalculationRepetitionNumber: fmx_ExprEnv__bindgen_ty_1 = 1068;
pub const fmx_ExprEnv_kGet_CurrentExtendedPrivileges: fmx_ExprEnv__bindgen_ty_1 = 1069;
pub const fmx_ExprEnv_kGet_AllowAbortState: fmx_ExprEnv__bindgen_ty_1 = 1070;
pub const fmx_ExprEnv_kGet_ErrorCaptureState: fmx_ExprEnv__bindgen_ty_1 = 1071;
pub const fmx_ExprEnv_kGet_DesktopPath: fmx_ExprEnv__bindgen_ty_1 = 1072;
pub const fmx_ExprEnv_kGet_DocumentsPath: fmx_ExprEnv__bindgen_ty_1 = 1073;
pub const fmx_ExprEnv_kGet_FileMakerPath: fmx_ExprEnv__bindgen_ty_1 = 1074;
pub const fmx_ExprEnv_kGet_HostIPAddress: fmx_ExprEnv__bindgen_ty_1 = 1075;
pub const fmx_ExprEnv_kGet_RequestOmitState: fmx_ExprEnv__bindgen_ty_1 = 1076;
pub const fmx_ExprEnv_kGet_PreferencesPath: fmx_ExprEnv__bindgen_ty_1 = 1077;
pub const fmx_ExprEnv_kGet_RecordOpenCount: fmx_ExprEnv__bindgen_ty_1 = 1078;
pub const fmx_ExprEnv_kGet_RecordOpenState: fmx_ExprEnv__bindgen_ty_1 = 1079;
pub const fmx_ExprEnv_kGet_ScriptResult: fmx_ExprEnv__bindgen_ty_1 = 1080;
pub const fmx_ExprEnv_kGet_SystemDrive: fmx_ExprEnv__bindgen_ty_1 = 1081;
pub const fmx_ExprEnv_kGet_TextRulerVisible: fmx_ExprEnv__bindgen_ty_1 = 1082;
pub const fmx_ExprEnv_kGet_AllowFormattingBarState: fmx_ExprEnv__bindgen_ty_1 = 1083;
pub const fmx_ExprEnv_kGet_UseSystemFormatsState: fmx_ExprEnv__bindgen_ty_1 = 1084;
pub const fmx_ExprEnv_kGet_WindowZoomLevel: fmx_ExprEnv__bindgen_ty_1 = 1085;
pub const fmx_ExprEnv_kGet_CustomMenuSetName: fmx_ExprEnv__bindgen_ty_1 = 1086;
pub const fmx_ExprEnv_kGet_ActiveLayoutObjectName: fmx_ExprEnv__bindgen_ty_1 = 1088;
pub const fmx_ExprEnv_kGet_TemporaryPath: fmx_ExprEnv__bindgen_ty_1 = 1089;
pub const fmx_ExprEnv_kGet_HostApplicationVersion: fmx_ExprEnv__bindgen_ty_1 = 1090;
pub const fmx_ExprEnv_kGet_TriggerModifierKeys: fmx_ExprEnv__bindgen_ty_1 = 1091;
pub const fmx_ExprEnv_kGet_TriggerKeystroke: fmx_ExprEnv__bindgen_ty_1 = 1092;
pub const fmx_ExprEnv_kGet_DocumentsPathListing: fmx_ExprEnv__bindgen_ty_1 = 1093;
pub const fmx_ExprEnv_kGet_AccountPrivilegeSet: fmx_ExprEnv__bindgen_ty_1 = 1094;
pub const fmx_ExprEnv_kGet_AccountExtendedPrivileges: fmx_ExprEnv__bindgen_ty_1 = 1095;
pub const fmx_ExprEnv_kGet_QuickFindText: fmx_ExprEnv__bindgen_ty_1 = 1096;
pub const fmx_ExprEnv_kGet_TriggerCurrentPanel: fmx_ExprEnv__bindgen_ty_1 = 1097;
pub const fmx_ExprEnv_kGet_TriggerTargetPanel: fmx_ExprEnv__bindgen_ty_1 = 1098;
pub const fmx_ExprEnv_kGet_WindowStyle: fmx_ExprEnv__bindgen_ty_1 = 1099;
pub const fmx_ExprEnv_kGet_InstalledFMPlugins: fmx_ExprEnv__bindgen_ty_1 = 1100;
pub const fmx_ExprEnv_kGet_UUID: fmx_ExprEnv__bindgen_ty_1 = 1101;
pub const fmx_ExprEnv_kGet_PersistentID: fmx_ExprEnv__bindgen_ty_1 = 1102;
pub const fmx_ExprEnv_kGet_ConnectionState: fmx_ExprEnv__bindgen_ty_1 = 1103;
pub const fmx_ExprEnv_kGet_CurrentTimeUTCMilliseconds: fmx_ExprEnv__bindgen_ty_1 = 1104;
pub const fmx_ExprEnv_kGet_Device: fmx_ExprEnv__bindgen_ty_1 = 1105;
pub const fmx_ExprEnv_kGet_WindowOrientation: fmx_ExprEnv__bindgen_ty_1 = 1106;
pub const fmx_ExprEnv_kGet_TriggerGestureInfo: fmx_ExprEnv__bindgen_ty_1 = 1107;
pub const fmx_ExprEnv_kGet_EncryptionState: fmx_ExprEnv__bindgen_ty_1 = 1108;
pub const fmx_ExprEnv_kGet_ScriptAnimation: fmx_ExprEnv__bindgen_ty_1 = 1109;
pub const fmx_ExprEnv_kGet_ModifiedFields: fmx_ExprEnv__bindgen_ty_1 = 1110;
pub const fmx_ExprEnv_kGet_NetworkType: fmx_ExprEnv__bindgen_ty_1 = 1111;
pub const fmx_ExprEnv_kGet_ConnectionAttributes: fmx_ExprEnv__bindgen_ty_1 = 1112;
pub const fmx_ExprEnv_kGet_ScreenScaleFactor: fmx_ExprEnv__bindgen_ty_1 = 1113;
pub const fmx_ExprEnv_kGet_ApplicationArchitecture: fmx_ExprEnv__bindgen_ty_1 = 1115;
pub const fmx_ExprEnv_kGet_TriggerExternalEvent: fmx_ExprEnv__bindgen_ty_1 = 1116;
pub const fmx_ExprEnv_kGet_TouchKeyboardState: fmx_ExprEnv__bindgen_ty_1 = 1117;
pub const fmx_ExprEnv_kGet_MenubarState: fmx_ExprEnv__bindgen_ty_1 = 1118;
pub const fmx_ExprEnv_kGet_RegionMonitorEvents: fmx_ExprEnv__bindgen_ty_1 = 1119;
pub const fmx_ExprEnv_kGet_AccountGroupName: fmx_ExprEnv__bindgen_ty_1 = 1120;
pub const fmx_ExprEnv_kGet_ActiveRecordNumber: fmx_ExprEnv__bindgen_ty_1 = 1121;
pub const fmx_ExprEnv_kGet_UUIDNumber: fmx_ExprEnv__bindgen_ty_1 = 1122;
pub const fmx_ExprEnv_kGet_OpenDataFileInfo: fmx_ExprEnv__bindgen_ty_1 = 1123;
pub const fmx_ExprEnv_kGet_AccountType: fmx_ExprEnv__bindgen_ty_1 = 1124;
pub const fmx_ExprEnv_kGet_PageCount: fmx_ExprEnv__bindgen_ty_1 = 1125;
pub const fmx_ExprEnv_kConvert_PosixPath: fmx_ExprEnv__bindgen_ty_1 = 1;
pub const fmx_ExprEnv_kConvert_WinPath: fmx_ExprEnv__bindgen_ty_1 = 2;
pub const fmx_ExprEnv_kConvert_URLPath: fmx_ExprEnv__bindgen_ty_1 = 3;
pub type fmx_ExprEnv__bindgen_ty_1 = i32;
#[test]
fn bindgen_test_layout_fmx_ExprEnv() {
assert_eq!(
::std::mem::size_of::<fmx_ExprEnv>(),
1usize,
concat!("Size of: ", stringify!(fmx_ExprEnv))
);
assert_eq!(
::std::mem::align_of::<fmx_ExprEnv>(),
1usize,
concat!("Alignment of ", stringify!(fmx_ExprEnv))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_DataVectAutoPtr {
pub _base: std_auto_ptr<fmx_DataVect>,
}
pub type fmx_DataVectAutoPtr_UpCaster = fmx_DataVectAutoPtr;
#[test]
fn bindgen_test_layout_fmx_DataVectAutoPtr() {
assert_eq!(
::std::mem::size_of::<fmx_DataVectAutoPtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_DataVectAutoPtr))
);
assert_eq!(
::std::mem::align_of::<fmx_DataVectAutoPtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_DataVectAutoPtr))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_RowVectAutoPtr {
pub _base: std_auto_ptr<fmx_RowVect>,
}
pub type fmx_RowVectAutoPtr_UpCaster = fmx_RowVectAutoPtr;
#[test]
fn bindgen_test_layout_fmx_RowVectAutoPtr() {
assert_eq!(
::std::mem::size_of::<fmx_RowVectAutoPtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_RowVectAutoPtr))
);
assert_eq!(
::std::mem::align_of::<fmx_RowVectAutoPtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_RowVectAutoPtr))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_ExprEnvAutoPtr {
pub _base: std_auto_ptr<fmx_ExprEnv>,
}
pub type fmx_ExprEnvAutoPtr_UpCaster = fmx_ExprEnvAutoPtr;
#[test]
fn bindgen_test_layout_fmx_ExprEnvAutoPtr() {
assert_eq!(
::std::mem::size_of::<fmx_ExprEnvAutoPtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_ExprEnvAutoPtr))
);
assert_eq!(
::std::mem::align_of::<fmx_ExprEnvAutoPtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_ExprEnvAutoPtr))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_DataVectUniquePtr {
pub _base: std_unique_ptr,
}
pub type fmx_DataVectUniquePtr_UpCaster = fmx_DataVectUniquePtr;
#[test]
fn bindgen_test_layout_fmx_DataVectUniquePtr() {
assert_eq!(
::std::mem::size_of::<fmx_DataVectUniquePtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_DataVectUniquePtr))
);
assert_eq!(
::std::mem::align_of::<fmx_DataVectUniquePtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_DataVectUniquePtr))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_RowVectUniquePtr {
pub _base: std_unique_ptr,
}
pub type fmx_RowVectUniquePtr_UpCaster = fmx_RowVectUniquePtr;
#[test]
fn bindgen_test_layout_fmx_RowVectUniquePtr() {
assert_eq!(
::std::mem::size_of::<fmx_RowVectUniquePtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_RowVectUniquePtr))
);
assert_eq!(
::std::mem::align_of::<fmx_RowVectUniquePtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_RowVectUniquePtr))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_ExprEnvUniquePtr {
pub _base: std_unique_ptr,
}
pub type fmx_ExprEnvUniquePtr_UpCaster = fmx_ExprEnvUniquePtr;
#[test]
fn bindgen_test_layout_fmx_ExprEnvUniquePtr() {
assert_eq!(
::std::mem::size_of::<fmx_ExprEnvUniquePtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_ExprEnvUniquePtr))
);
assert_eq!(
::std::mem::align_of::<fmx_ExprEnvUniquePtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_ExprEnvUniquePtr))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fmx_CharacterStyle {
pub _address: u8,
}
pub type fmx_CharacterStyle_Face = ::std::os::raw::c_ushort;
pub type fmx_CharacterStyle_FontID = ::std::os::raw::c_ushort;
pub type fmx_CharacterStyle_FontSize = ::std::os::raw::c_ushort;
pub type fmx_CharacterStyle_ColorChannel = ::std::os::raw::c_uchar;
pub type fmx_CharacterStyle_ColorChannel16 = ::std::os::raw::c_ushort;
pub type fmx_CharacterStyle_FontScript = ::std::os::raw::c_ushort;
pub const fmx_CharacterStyle_kRoman: fmx_CharacterStyle__bindgen_ty_1 = 0;
pub const fmx_CharacterStyle_kGreek: fmx_CharacterStyle__bindgen_ty_1 = 1;
pub const fmx_CharacterStyle_kCyrillic: fmx_CharacterStyle__bindgen_ty_1 = 2;
pub const fmx_CharacterStyle_kCentralEurope: fmx_CharacterStyle__bindgen_ty_1 = 3;
pub const fmx_CharacterStyle_kShiftJIS: fmx_CharacterStyle__bindgen_ty_1 = 4;
pub const fmx_CharacterStyle_kTraditionalChinese: fmx_CharacterStyle__bindgen_ty_1 = 5;
pub const fmx_CharacterStyle_kSimplifiedChinese: fmx_CharacterStyle__bindgen_ty_1 = 6;
pub const fmx_CharacterStyle_kOEM: fmx_CharacterStyle__bindgen_ty_1 = 7;
pub const fmx_CharacterStyle_kSymbol: fmx_CharacterStyle__bindgen_ty_1 = 8;
pub const fmx_CharacterStyle_kNative: fmx_CharacterStyle__bindgen_ty_1 = 9;
pub const fmx_CharacterStyle_kOther: fmx_CharacterStyle__bindgen_ty_1 = 10;
pub const fmx_CharacterStyle_kKorean: fmx_CharacterStyle__bindgen_ty_1 = 11;
pub const fmx_CharacterStyle_kDingbats: fmx_CharacterStyle__bindgen_ty_1 = 12;
pub const fmx_CharacterStyle_kTurkish: fmx_CharacterStyle__bindgen_ty_1 = 13;
pub const fmx_CharacterStyle_kInvalidFont: fmx_CharacterStyle__bindgen_ty_1 = 65535;
pub type fmx_CharacterStyle__bindgen_ty_1 = i32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fmx_CharacterStyle_Color {
pub _address: u8,
}
pub const fmx_CharacterStyle_Color_kColorChannel_ON: fmx_CharacterStyle_Color__bindgen_ty_1 = 255;
pub const fmx_CharacterStyle_Color_kColorChannel_OFF: fmx_CharacterStyle_Color__bindgen_ty_1 = 0;
pub type fmx_CharacterStyle_Color__bindgen_ty_1 = i32;
#[test]
fn bindgen_test_layout_fmx_CharacterStyle_Color() {
assert_eq!(
::std::mem::size_of::<fmx_CharacterStyle_Color>(),
1usize,
concat!("Size of: ", stringify!(fmx_CharacterStyle_Color))
);
assert_eq!(
::std::mem::align_of::<fmx_CharacterStyle_Color>(),
1usize,
concat!("Alignment of ", stringify!(fmx_CharacterStyle_Color))
);
}
pub const fmx_CharacterStyle_kFace_Plain: fmx_CharacterStyle__bindgen_ty_2 = 0;
pub const fmx_CharacterStyle_kFace_Bold: fmx_CharacterStyle__bindgen_ty_2 = 256;
pub const fmx_CharacterStyle_kFace_Italic: fmx_CharacterStyle__bindgen_ty_2 = 512;
pub const fmx_CharacterStyle_kFace_Underline: fmx_CharacterStyle__bindgen_ty_2 = 1024;
pub const fmx_CharacterStyle_kFace_Outline: fmx_CharacterStyle__bindgen_ty_2 = 2048;
pub const fmx_CharacterStyle_kFace_Shadow: fmx_CharacterStyle__bindgen_ty_2 = 4096;
pub const fmx_CharacterStyle_kFace_Condense: fmx_CharacterStyle__bindgen_ty_2 = 8192;
pub const fmx_CharacterStyle_kFace_Extend: fmx_CharacterStyle__bindgen_ty_2 = 16384;
pub const fmx_CharacterStyle_kFace_Strikethrough: fmx_CharacterStyle__bindgen_ty_2 = 1;
pub const fmx_CharacterStyle_kFace_SmallCaps: fmx_CharacterStyle__bindgen_ty_2 = 2;
pub const fmx_CharacterStyle_kFace_Superscript: fmx_CharacterStyle__bindgen_ty_2 = 4;
pub const fmx_CharacterStyle_kFace_Subscript: fmx_CharacterStyle__bindgen_ty_2 = 8;
pub const fmx_CharacterStyle_kFace_Uppercase: fmx_CharacterStyle__bindgen_ty_2 = 16;
pub const fmx_CharacterStyle_kFace_Lowercase: fmx_CharacterStyle__bindgen_ty_2 = 32;
pub const fmx_CharacterStyle_kFace_Titlecase: fmx_CharacterStyle__bindgen_ty_2 = 48;
pub const fmx_CharacterStyle_kFace_WordUnderline: fmx_CharacterStyle__bindgen_ty_2 = 64;
pub const fmx_CharacterStyle_kFace_DoubleUnderline: fmx_CharacterStyle__bindgen_ty_2 = 128;
pub const fmx_CharacterStyle_kFace_AllStyles: fmx_CharacterStyle__bindgen_ty_2 = 32767;
pub type fmx_CharacterStyle__bindgen_ty_2 = i32;
#[test]
fn bindgen_test_layout_fmx_CharacterStyle() {
assert_eq!(
::std::mem::size_of::<fmx_CharacterStyle>(),
1usize,
concat!("Size of: ", stringify!(fmx_CharacterStyle))
);
assert_eq!(
::std::mem::align_of::<fmx_CharacterStyle>(),
1usize,
concat!("Alignment of ", stringify!(fmx_CharacterStyle))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_ColorAutoPtr {
pub _base: std_auto_ptr<fmx_CharacterStyle_Color>,
}
pub type fmx_ColorAutoPtr_UpCaster = fmx_ColorAutoPtr;
#[test]
fn bindgen_test_layout_fmx_ColorAutoPtr() {
assert_eq!(
::std::mem::size_of::<fmx_ColorAutoPtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_ColorAutoPtr))
);
assert_eq!(
::std::mem::align_of::<fmx_ColorAutoPtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_ColorAutoPtr))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_CharacterStyleAutoPtr {
pub _base: std_auto_ptr<fmx_CharacterStyle>,
}
pub type fmx_CharacterStyleAutoPtr_UpCaster = fmx_CharacterStyleAutoPtr;
#[test]
fn bindgen_test_layout_fmx_CharacterStyleAutoPtr() {
assert_eq!(
::std::mem::size_of::<fmx_CharacterStyleAutoPtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_CharacterStyleAutoPtr))
);
assert_eq!(
::std::mem::align_of::<fmx_CharacterStyleAutoPtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_CharacterStyleAutoPtr))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_ColorUniquePtr {
pub _base: std_unique_ptr,
}
pub type fmx_ColorUniquePtr_UpCaster = fmx_ColorUniquePtr;
#[test]
fn bindgen_test_layout_fmx_ColorUniquePtr() {
assert_eq!(
::std::mem::size_of::<fmx_ColorUniquePtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_ColorUniquePtr))
);
assert_eq!(
::std::mem::align_of::<fmx_ColorUniquePtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_ColorUniquePtr))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_CharacterStyleUniquePtr {
pub _base: std_unique_ptr,
}
pub type fmx_CharacterStyleUniquePtr_UpCaster = fmx_CharacterStyleUniquePtr;
#[test]
fn bindgen_test_layout_fmx_CharacterStyleUniquePtr() {
assert_eq!(
::std::mem::size_of::<fmx_CharacterStyleUniquePtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_CharacterStyleUniquePtr))
);
assert_eq!(
::std::mem::align_of::<fmx_CharacterStyleUniquePtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_CharacterStyleUniquePtr))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fmx_Data {
pub _address: u8,
}
pub const fmx_Data_DataType_kDTInvalid: fmx_Data_DataType = 0;
pub const fmx_Data_DataType_kDTText: fmx_Data_DataType = 1;
pub const fmx_Data_DataType_kDTNumber: fmx_Data_DataType = 2;
pub const fmx_Data_DataType_kDTDate: fmx_Data_DataType = 3;
pub const fmx_Data_DataType_kDTTime: fmx_Data_DataType = 4;
pub const fmx_Data_DataType_kDTTimeStamp: fmx_Data_DataType = 5;
pub const fmx_Data_DataType_kDTBinary: fmx_Data_DataType = 6;
pub const fmx_Data_DataType_kDTBoolean: fmx_Data_DataType = 7;
pub type fmx_Data_DataType = i32;
#[test]
fn bindgen_test_layout_fmx_Data() {
assert_eq!(
::std::mem::size_of::<fmx_Data>(),
1usize,
concat!("Size of: ", stringify!(fmx_Data))
);
assert_eq!(
::std::mem::align_of::<fmx_Data>(),
1usize,
concat!("Alignment of ", stringify!(fmx_Data))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_DataAutoPtr {
pub _base: std_auto_ptr<fmx_Data>,
}
pub type fmx_DataAutoPtr_UpCaster = fmx_DataAutoPtr;
#[test]
fn bindgen_test_layout_fmx_DataAutoPtr() {
assert_eq!(
::std::mem::size_of::<fmx_DataAutoPtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_DataAutoPtr))
);
assert_eq!(
::std::mem::align_of::<fmx_DataAutoPtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_DataAutoPtr))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_DataUniquePtr {
pub _base: std_unique_ptr,
}
pub type fmx_DataUniquePtr_UpCaster = fmx_DataUniquePtr;
#[test]
fn bindgen_test_layout_fmx_DataUniquePtr() {
assert_eq!(
::std::mem::size_of::<fmx_DataUniquePtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_DataUniquePtr))
);
assert_eq!(
::std::mem::align_of::<fmx_DataUniquePtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_DataUniquePtr))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fmx_DateTime {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_fmx_DateTime() {
assert_eq!(
::std::mem::size_of::<fmx_DateTime>(),
1usize,
concat!("Size of: ", stringify!(fmx_DateTime))
);
assert_eq!(
::std::mem::align_of::<fmx_DateTime>(),
1usize,
concat!("Alignment of ", stringify!(fmx_DateTime))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_DateTimeAutoPtr {
pub _base: std_auto_ptr<fmx_DateTime>,
}
pub type fmx_DateTimeAutoPtr_UpCaster = fmx_DateTimeAutoPtr;
#[test]
fn bindgen_test_layout_fmx_DateTimeAutoPtr() {
assert_eq!(
::std::mem::size_of::<fmx_DateTimeAutoPtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_DateTimeAutoPtr))
);
assert_eq!(
::std::mem::align_of::<fmx_DateTimeAutoPtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_DateTimeAutoPtr))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_DateTimeUniquePtr {
pub _base: std_unique_ptr,
}
pub type fmx_DateTimeUniquePtr_UpCaster = fmx_DateTimeUniquePtr;
#[test]
fn bindgen_test_layout_fmx_DateTimeUniquePtr() {
assert_eq!(
::std::mem::size_of::<fmx_DateTimeUniquePtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_DateTimeUniquePtr))
);
assert_eq!(
::std::mem::align_of::<fmx_DateTimeUniquePtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_DateTimeUniquePtr))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fmx_FixPt {
pub _address: u8,
}
pub const fmx_FixPt_kDefltFixedPrecision: fmx_FixPt__bindgen_ty_1 = 16;
pub type fmx_FixPt__bindgen_ty_1 = i32;
#[test]
fn bindgen_test_layout_fmx_FixPt() {
assert_eq!(
::std::mem::size_of::<fmx_FixPt>(),
1usize,
concat!("Size of: ", stringify!(fmx_FixPt))
);
assert_eq!(
::std::mem::align_of::<fmx_FixPt>(),
1usize,
concat!("Alignment of ", stringify!(fmx_FixPt))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_FixPtAutoPtr {
pub _base: std_auto_ptr<fmx_FixPt>,
}
pub type fmx_FixPtAutoPtr_UpCaster = fmx_FixPtAutoPtr;
#[test]
fn bindgen_test_layout_fmx_FixPtAutoPtr() {
assert_eq!(
::std::mem::size_of::<fmx_FixPtAutoPtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_FixPtAutoPtr))
);
assert_eq!(
::std::mem::align_of::<fmx_FixPtAutoPtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_FixPtAutoPtr))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_FixPtUniquePtr {
pub _base: std_unique_ptr,
}
pub type fmx_FixPtUniquePtr_UpCaster = fmx_FixPtUniquePtr;
#[test]
fn bindgen_test_layout_fmx_FixPtUniquePtr() {
assert_eq!(
::std::mem::size_of::<fmx_FixPtUniquePtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_FixPtUniquePtr))
);
assert_eq!(
::std::mem::align_of::<fmx_FixPtUniquePtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_FixPtUniquePtr))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fmx_Text {
pub _address: u8,
}
pub const fmx_Text_Encoding_kEncoding_Native: fmx_Text_Encoding = 0;
pub const fmx_Text_Encoding_kEncoding_UTF8: fmx_Text_Encoding = 1;
pub const fmx_Text_Encoding_kEncoding_ASCII_DOS: fmx_Text_Encoding = 2;
pub const fmx_Text_Encoding_kEncoding_ASCII_Windows: fmx_Text_Encoding = 3;
pub const fmx_Text_Encoding_kEncoding_ASCII_Mac: fmx_Text_Encoding = 4;
pub const fmx_Text_Encoding_kEncoding_ISO_8859_1: fmx_Text_Encoding = 5;
pub const fmx_Text_Encoding_kEncoding_ShiftJIS_Mac: fmx_Text_Encoding = 6;
pub const fmx_Text_Encoding_kEncoding_ShiftJIS_Win: fmx_Text_Encoding = 7;
pub const fmx_Text_Encoding_kEncoding_Korean_Mac: fmx_Text_Encoding = 8;
pub const fmx_Text_Encoding_kEncoding_Korean_Win: fmx_Text_Encoding = 9;
pub const fmx_Text_Encoding_kEncoding_Korean_Johab: fmx_Text_Encoding = 10;
pub const fmx_Text_Encoding_kEncoding_ChineseTrad_Mac: fmx_Text_Encoding = 11;
pub const fmx_Text_Encoding_kEncoding_ChineseTrad_Win: fmx_Text_Encoding = 12;
pub const fmx_Text_Encoding_kEncoding_ChineseSimp_Mac: fmx_Text_Encoding = 13;
pub const fmx_Text_Encoding_kEncoding_ChineseSimp_Win: fmx_Text_Encoding = 14;
pub const fmx_Text_Encoding_kEncoding_Cyrillic_Mac: fmx_Text_Encoding = 15;
pub const fmx_Text_Encoding_kEncoding_Cyrillic_Win: fmx_Text_Encoding = 16;
pub const fmx_Text_Encoding_kEncoding_ISO_8859_5: fmx_Text_Encoding = 17;
pub const fmx_Text_Encoding_kEncoding_CentralEurope_Mac: fmx_Text_Encoding = 18;
pub const fmx_Text_Encoding_kEncoding_EasternEurope_Win: fmx_Text_Encoding = 19;
pub const fmx_Text_Encoding_kEncoding_ISO_8859_2: fmx_Text_Encoding = 20;
pub const fmx_Text_Encoding_kEncoding_Turkish_Mac: fmx_Text_Encoding = 21;
pub const fmx_Text_Encoding_kEncoding_Turkish_Win: fmx_Text_Encoding = 22;
pub const fmx_Text_Encoding_kEncoding_ISO_8859_3: fmx_Text_Encoding = 23;
pub const fmx_Text_Encoding_kEncoding_ISO_8859_9: fmx_Text_Encoding = 24;
pub const fmx_Text_Encoding_kEncoding_Baltic_Win: fmx_Text_Encoding = 25;
pub const fmx_Text_Encoding_kEncoding_ISO_8859_4: fmx_Text_Encoding = 26;
pub const fmx_Text_Encoding_kEncoding_Arabic_Mac: fmx_Text_Encoding = 27;
pub const fmx_Text_Encoding_kEncoding_Arabic_Win: fmx_Text_Encoding = 28;
pub const fmx_Text_Encoding_kEncoding_ISO_8859_6: fmx_Text_Encoding = 29;
pub const fmx_Text_Encoding_kEncoding_Greek_Mac: fmx_Text_Encoding = 30;
pub const fmx_Text_Encoding_kEncoding_Greek_Win: fmx_Text_Encoding = 31;
pub const fmx_Text_Encoding_kEncoding_ISO_8859_7: fmx_Text_Encoding = 32;
pub const fmx_Text_Encoding_kEncoding_Hebrew_Mac: fmx_Text_Encoding = 33;
pub const fmx_Text_Encoding_kEncoding_Hebrew_Win: fmx_Text_Encoding = 34;
pub const fmx_Text_Encoding_kEncoding_ISO_8859_8: fmx_Text_Encoding = 35;
pub const fmx_Text_Encoding_kEncoding_ISO_8859_15: fmx_Text_Encoding = 36;
pub type fmx_Text_Encoding = i32;
pub const fmx_Text_kSize_Invalid: fmx_Text__bindgen_ty_1 = -1;
pub const fmx_Text_kSize_End: fmx_Text__bindgen_ty_1 = -1;
pub type fmx_Text__bindgen_ty_1 = i32;
#[test]
fn bindgen_test_layout_fmx_Text() {
assert_eq!(
::std::mem::size_of::<fmx_Text>(),
1usize,
concat!("Size of: ", stringify!(fmx_Text))
);
assert_eq!(
::std::mem::align_of::<fmx_Text>(),
1usize,
concat!("Alignment of ", stringify!(fmx_Text))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_TextAutoPtr {
pub _base: std_auto_ptr<fmx_Text>,
}
pub type fmx_TextAutoPtr_UpCaster = fmx_TextAutoPtr;
#[test]
fn bindgen_test_layout_fmx_TextAutoPtr() {
assert_eq!(
::std::mem::size_of::<fmx_TextAutoPtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_TextAutoPtr))
);
assert_eq!(
::std::mem::align_of::<fmx_TextAutoPtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_TextAutoPtr))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct fmx_TextUniquePtr {
pub _base: std_unique_ptr,
}
pub type fmx_TextUniquePtr_UpCaster = fmx_TextUniquePtr;
#[test]
fn bindgen_test_layout_fmx_TextUniquePtr() {
assert_eq!(
::std::mem::size_of::<fmx_TextUniquePtr>(),
8usize,
concat!("Size of: ", stringify!(fmx_TextUniquePtr))
);
assert_eq!(
::std::mem::align_of::<fmx_TextUniquePtr>(),
8usize,
concat!("Alignment of ", stringify!(fmx_TextUniquePtr))
);
}
pub type FMX_Text = fmx_Text;
pub type FMX_Data = fmx_Data;
pub type FMX_ExprEnv = fmx_ExprEnv;
pub type FMX_UChar = fmx_uchar;
pub type FMX_Int16 = fmx_int16;
pub type FMX_UInt16 = fmx_uint16;
pub type FMX_Int32 = fmx_int32;
pub type FMX_UInt32 = fmx_uint32;
pub type FMX_Unichar = fmx_unichar16;
pub type FMX_ErrorCode = fmx_errcode;
pub type FMX_PtrType = fmx_ptrtype;
pub type FMX_Char = ::std::os::raw::c_char;
pub type FMX_Boolean = ::std::os::raw::c_char;
pub type FMX_ScriptControl = FMX_UChar;
pub const kFMXT_Halt: _bindgen_ty_9 = 0;
pub const kFMXT_Exit: _bindgen_ty_9 = 1;
pub const kFMXT_Resume: _bindgen_ty_9 = 2;
pub const kFMXT_Pause: _bindgen_ty_9 = 3;
pub type _bindgen_ty_9 = i32;
pub type FMX_StartScriptCall = ::std::option::Option<
unsafe extern "C" fn(
fileName: *const FMX_Text,
scriptName: *const FMX_Text,
control: FMX_ScriptControl,
parameter: *const FMX_Data,
) -> FMX_ErrorCode,
>;
pub type FMX_CurrentEnvCall =
::std::option::Option<unsafe extern "C" fn(env: *mut FMX_ExprEnv) -> FMX_ErrorCode>;
pub const kBadExtnVersion: _bindgen_ty_10 = -1;
pub const kDoNotEnable: _bindgen_ty_10 = -2;
pub const k40ExtnVersion: _bindgen_ty_10 = 11;
pub const k41ExtnVersion: _bindgen_ty_10 = 12;
pub const k50ExtnVersion: _bindgen_ty_10 = 14;
pub const k60ExtnVersion: _bindgen_ty_10 = 17;
pub const k70ExtnVersion: _bindgen_ty_10 = 50;
pub const k80ExtnVersion: _bindgen_ty_10 = 51;
pub const k110ExtnVersion: _bindgen_ty_10 = 52;
pub const k120ExtnVersion: _bindgen_ty_10 = 53;
pub const k130ExtnVersion: _bindgen_ty_10 = 54;
pub const k140ExtnVersion: _bindgen_ty_10 = 55;
pub const k150ExtnVersion: _bindgen_ty_10 = 56;
pub const k160ExtnVersion: _bindgen_ty_10 = 57;
pub const k170ExtnVersion: _bindgen_ty_10 = 59;
pub const k180ExtnVersion: _bindgen_ty_10 = 60;
pub const k190ExtnVersion: _bindgen_ty_10 = 62;
pub const kCurrentExtnVersion: _bindgen_ty_10 = 62;
pub const kMinExtnVersion: _bindgen_ty_10 = 4;
pub const kMaxExtnVersion: _bindgen_ty_10 = 255;
pub type _bindgen_ty_10 = i32;
pub type FMX_ExternCallSwitch = FMX_UChar;
pub const kFMXT_Init: _bindgen_ty_11 = 0;
pub const kFMXT_Idle: _bindgen_ty_11 = 1;
pub const kFMXT_Shutdown: _bindgen_ty_11 = 4;
pub const kFMXT_DoAppPreferences: _bindgen_ty_11 = 5;
pub const kFMXT_GetString: _bindgen_ty_11 = 7;
pub const kFMXT_SessionShutdown: _bindgen_ty_11 = 8;
pub const kFMXT_FileShutdown: _bindgen_ty_11 = 9;
pub type _bindgen_ty_11 = i32;
pub type FMX_Strings = FMX_UChar;
pub const kFMXT_NameStr: _bindgen_ty_12 = 128;
pub const kFMXT_AppConfigStr: _bindgen_ty_12 = 129;
pub const kFMXT_OptionsStr: _bindgen_ty_12 = 131;
pub const kFMXT_HelpURLStr: _bindgen_ty_12 = 132;
pub type _bindgen_ty_12 = i32;
pub type FMX_IdleLevel = FMX_UChar;
pub const kFMXT_UserIdle: _bindgen_ty_13 = 0;
pub const kFMXT_UserNotIdle: _bindgen_ty_13 = 1;
pub const kFMXT_ScriptPaused: _bindgen_ty_13 = 2;
pub const kFMXT_ScriptRunning: _bindgen_ty_13 = 3;
pub const kFMXT_Unsafe: _bindgen_ty_13 = 4;
pub type _bindgen_ty_13 = i32;
pub type FMX_Application = FMX_UChar;
pub const kFMXT_Developer: _bindgen_ty_14 = 0;
pub const kFMXT_Pro: _bindgen_ty_14 = 1;
pub const kFMXT_Runtime: _bindgen_ty_14 = 2;
pub const kFMXT_Server: _bindgen_ty_14 = 3;
pub const kFMXT_Web: _bindgen_ty_14 = 4;
pub const kFMXT_Mobile: _bindgen_ty_14 = 5;
pub const kFMXT_XDBC: _bindgen_ty_14 = 6;
pub const kFMXT_SASE: _bindgen_ty_14 = 7;
pub const kFMXT_IWP: _bindgen_ty_14 = 8;
pub type _bindgen_ty_14 = i32;
pub type FMX_ExternCallPtr = *mut FMX_ExternCallStruct;
pub type FMX_ExternCallProc = ::std::option::Option<unsafe extern "C" fn(arg1: FMX_ExternCallPtr)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMX_ExternCallStruct {
pub extnVersion: FMX_Int16,
pub unusedID: fmx_unusedid,
pub entryPoint: FMX_ExternCallProc,
pub cfmCalls: FMX_Boolean,
pub whichCall: FMX_ExternCallSwitch,
pub unsafeCalls: FMX_Boolean,
pub parm1: FMX_UChar,
pub parm2: FMX_PtrType,
pub parm3: FMX_PtrType,
pub instanceID: FMX_PtrType,
pub result: FMX_PtrType,
pub unused: FMX_PtrType,
pub cStartScript: FMX_StartScriptCall,
pub cCurrentEnv: FMX_CurrentEnvCall,
}
#[test]
fn bindgen_test_layout_FMX_ExternCallStruct() {
assert_eq!(
::std::mem::size_of::<FMX_ExternCallStruct>(),
80usize,
concat!("Size of: ", stringify!(FMX_ExternCallStruct))
);
assert_eq!(
::std::mem::align_of::<FMX_ExternCallStruct>(),
8usize,
concat!("Alignment of ", stringify!(FMX_ExternCallStruct))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FMX_ExternCallStruct>())).extnVersion as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(FMX_ExternCallStruct),
"::",
stringify!(extnVersion)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FMX_ExternCallStruct>())).unusedID as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(FMX_ExternCallStruct),
"::",
stringify!(unusedID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FMX_ExternCallStruct>())).entryPoint as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FMX_ExternCallStruct),
"::",
stringify!(entryPoint)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FMX_ExternCallStruct>())).cfmCalls as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(FMX_ExternCallStruct),
"::",
stringify!(cfmCalls)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FMX_ExternCallStruct>())).whichCall as *const _ as usize },
17usize,
concat!(
"Offset of field: ",
stringify!(FMX_ExternCallStruct),
"::",
stringify!(whichCall)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FMX_ExternCallStruct>())).unsafeCalls as *const _ as usize
},
18usize,
concat!(
"Offset of field: ",
stringify!(FMX_ExternCallStruct),
"::",
stringify!(unsafeCalls)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FMX_ExternCallStruct>())).parm1 as *const _ as usize },
19usize,
concat!(
"Offset of field: ",
stringify!(FMX_ExternCallStruct),
"::",
stringify!(parm1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FMX_ExternCallStruct>())).parm2 as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(FMX_ExternCallStruct),
"::",
stringify!(parm2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FMX_ExternCallStruct>())).parm3 as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(FMX_ExternCallStruct),
"::",
stringify!(parm3)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FMX_ExternCallStruct>())).instanceID as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(FMX_ExternCallStruct),
"::",
stringify!(instanceID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FMX_ExternCallStruct>())).result as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(FMX_ExternCallStruct),
"::",
stringify!(result)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FMX_ExternCallStruct>())).unused as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(FMX_ExternCallStruct),
"::",
stringify!(unused)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FMX_ExternCallStruct>())).cStartScript as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(FMX_ExternCallStruct),
"::",
stringify!(cStartScript)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<FMX_ExternCallStruct>())).cCurrentEnv as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(FMX_ExternCallStruct),
"::",
stringify!(cCurrentEnv)
)
);
}
extern "C" {
pub fn FMExternCallProc(pb: FMX_ExternCallPtr);
}
extern "C" {
pub static mut gFMX_ExternCallPtr: FMX_ExternCallPtr;
}
extern "C" {
pub fn FM_QuadChar_Constructor1(_x: *mut fmx__fmxcpt) -> *mut fmx_QuadChar;
}
extern "C" {
pub fn FM_QuadChar_Constructor2(
c0: ::std::os::raw::c_char,
c1: ::std::os::raw::c_char,
c2: ::std::os::raw::c_char,
c3: ::std::os::raw::c_char,
_x: *mut fmx__fmxcpt,
) -> *mut fmx_QuadChar;
}
extern "C" {
pub fn FM_QuadChar_Constructor3(
value: *const fmx_QuadChar,
_x: *mut fmx__fmxcpt,
) -> *mut fmx_QuadChar;
}
extern "C" {
pub fn FM_QuadChar_operatorAS(
_self: *mut ::std::os::raw::c_void,
value: *const fmx_QuadChar,
_x: *mut fmx__fmxcpt,
) -> *const fmx_QuadChar;
}
extern "C" {
pub fn FM_QuadChar_operatorAR(
_self: *mut ::std::os::raw::c_void,
i: ::std::os::raw::c_int,
_x: *mut fmx__fmxcpt,
) -> fmx_uchar;
}
extern "C" {
pub fn FM_QuadChar_operatorCAR(
_self: *const ::std::os::raw::c_void,
i: ::std::os::raw::c_int,
_x: *mut fmx__fmxcpt,
) -> fmx_uchar;
}
extern "C" {
pub fn FM_QuadChar_operatorEQ(
_self: *const ::std::os::raw::c_void,
value: *const fmx_QuadChar,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_QuadChar_operatorNE(
_self: *const ::std::os::raw::c_void,
value: *const fmx_QuadChar,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_QuadChar_operatorLT(
_self: *const ::std::os::raw::c_void,
value: *const fmx_QuadChar,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_QuadChar_operatorLE(
_self: *const ::std::os::raw::c_void,
value: *const fmx_QuadChar,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_QuadChar_operatorGT(
_self: *const ::std::os::raw::c_void,
value: *const fmx_QuadChar,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_QuadChar_operatorGE(
_self: *const ::std::os::raw::c_void,
value: *const fmx_QuadChar,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_QuadChar_GetMacType(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_uint32;
}
extern "C" {
pub fn FM_QuadChar_SetMacType(
_self: *mut ::std::os::raw::c_void,
value: fmx_uint32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_QuadChar_Delete(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
}
extern "C" {
pub fn FM_Locale_Constructor1(inputType: fmx_int32, _x: *mut fmx__fmxcpt) -> *mut fmx_Locale;
}
extern "C" {
pub fn FM_Locale_Constructor2(
copyConstruct: *const fmx_Locale,
_x: *mut fmx__fmxcpt,
) -> *mut fmx_Locale;
}
extern "C" {
pub fn FM_Locale_operatorAS(
_self: *mut ::std::os::raw::c_void,
rhs: *const fmx_Locale,
_x: *mut fmx__fmxcpt,
) -> *mut fmx_Locale;
}
extern "C" {
pub fn FM_Locale_Delete(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
}
extern "C" {
pub fn FM_BinaryData_Constructor1(_x: *mut fmx__fmxcpt) -> *mut fmx_BinaryData;
}
extern "C" {
pub fn FM_BinaryData_Constructor2(
sourceData: *const fmx_BinaryData,
_x: *mut fmx__fmxcpt,
) -> *mut fmx_BinaryData;
}
extern "C" {
pub fn FM_BinaryData_Constructor3(
name: *const fmx_Text,
amount: fmx_uint32,
buffer: *mut ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> *mut fmx_BinaryData;
}
extern "C" {
pub fn FM_BinaryData_Constructor4(
name: *const fmx_Text,
context: *mut fmx_uint32,
_x: *mut fmx__fmxcpt,
) -> *mut fmx_BinaryData;
}
extern "C" {
pub fn FM_BinaryData_operatorAS(
_self: *mut ::std::os::raw::c_void,
source: *const fmx_BinaryData,
_x: *mut fmx__fmxcpt,
) -> *mut fmx_BinaryData;
}
extern "C" {
pub fn FM_BinaryData_operatorEQ(
_self: *const ::std::os::raw::c_void,
compareData: *const fmx_BinaryData,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_BinaryData_operatorNE(
_self: *const ::std::os::raw::c_void,
compareData: *const fmx_BinaryData,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_BinaryData_GetCount(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_int32;
}
extern "C" {
pub fn FM_BinaryData_GetIndex(
_self: *const ::std::os::raw::c_void,
dataType: *const fmx_QuadChar,
_x: *mut fmx__fmxcpt,
) -> fmx_int32;
}
extern "C" {
pub fn FM_BinaryData_GetTotalSize(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_uint32;
}
extern "C" {
pub fn FM_BinaryData_GetType(
_self: *const ::std::os::raw::c_void,
index: fmx_int32,
dataType: *mut fmx_QuadChar,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_BinaryData_GetSize(
_self: *const ::std::os::raw::c_void,
index: fmx_int32,
_x: *mut fmx__fmxcpt,
) -> fmx_uint32;
}
extern "C" {
pub fn FM_BinaryData_GetData(
_self: *const ::std::os::raw::c_void,
index: fmx_int32,
offset: fmx_uint32,
amount: fmx_uint32,
buffer: *mut ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
}
extern "C" {
pub fn FM_BinaryData_Add(
_self: *mut ::std::os::raw::c_void,
dataType: *const fmx_QuadChar,
amount: fmx_uint32,
buffer: *mut ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
}
extern "C" {
pub fn FM_BinaryData_Remove(
_self: *mut ::std::os::raw::c_void,
dataType: *const fmx_QuadChar,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_BinaryData_RemoveAll(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
}
extern "C" {
pub fn FM_BinaryData_Delete(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
}
extern "C" {
pub fn FM_BinaryData_GetFNAMData(
_self: *const ::std::os::raw::c_void,
filepathlist: *mut fmx_Text,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
}
extern "C" {
pub fn FM_BinaryData_AddFNAMData(
_self: *mut ::std::os::raw::c_void,
filepathlist: *const fmx_Text,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
pub fn FM_BinaryData_GetSIZEData(
_self: *const ::std::os::raw::c_void,
width: *mut ::std::os::raw::c_short,
height: *mut ::std::os::raw::c_short,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
pub fn FM_BinaryData_AddSIZEData(
_self: *mut ::std::os::raw::c_void,
width: ::std::os::raw::c_short,
height: ::std::os::raw::c_short,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
pub fn FM_BinaryData_AddBegin(
_self: *mut ::std::os::raw::c_void,
dataType: *const fmx_QuadChar,
context: *mut fmx_uint32,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
pub fn FM_BinaryData_AddAppend(
_self: *mut ::std::os::raw::c_void,
context: fmx_uint32,
amount: fmx_uint32,
buffer: *mut ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
pub fn FM_BinaryData_AddFinish(
_self: *mut ::std::os::raw::c_void,
context: fmx_uint32,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
pub fn FM_DataVect_Constructor1(_x: *mut fmx__fmxcpt) -> *mut fmx_DataVect;
pub fn FM_DataVect_Size(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_uint32;
pub fn FM_DataVect_Clear(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
pub fn FM_DataVect_IsEmpty(_self: *const ::std::os::raw::c_void, _x: *mut fmx__fmxcpt) -> bool;
pub fn FM_DataVect_PushBack(
_self: *mut ::std::os::raw::c_void,
data: *const fmx_Data,
_x: *mut fmx__fmxcpt,
);
pub fn FM_DataVect_PopBack(
_self: *mut ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> *mut fmx_Data;
pub fn FM_DataVect_At(
_self: *const ::std::os::raw::c_void,
position: fmx_uint32,
_x: *mut fmx__fmxcpt,
) -> *const fmx_Data;
pub fn FM_DataVect_AtAsText(
_self: *const ::std::os::raw::c_void,
position: fmx_uint32,
_x: *mut fmx__fmxcpt,
) -> *const fmx_Text;
pub fn FM_DataVect_AtAsNumber(
_self: *const ::std::os::raw::c_void,
position: fmx_uint32,
_x: *mut fmx__fmxcpt,
) -> *const fmx_FixPt;
pub fn FM_DataVect_AtAsDate(
_self: *const ::std::os::raw::c_void,
position: fmx_uint32,
_x: *mut fmx__fmxcpt,
) -> *const fmx_DateTime;
pub fn FM_DataVect_AtAsTime(
_self: *const ::std::os::raw::c_void,
position: fmx_uint32,
_x: *mut fmx__fmxcpt,
) -> *const fmx_DateTime;
pub fn FM_DataVect_AtAsTimeStamp(
_self: *const ::std::os::raw::c_void,
position: fmx_uint32,
_x: *mut fmx__fmxcpt,
) -> *const fmx_DateTime;
pub fn FM_DataVect_AtAsBoolean(
_self: *const ::std::os::raw::c_void,
position: fmx_uint32,
_x: *mut fmx__fmxcpt,
) -> bool;
pub fn FM_DataVect_AtAsBinaryData(
_self: *const ::std::os::raw::c_void,
position: fmx_uint32,
_x: *mut fmx__fmxcpt,
) -> *const fmx_BinaryData;
pub fn FM_DataVect_Delete(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
pub fn FM_RowVect_Constructor1(_x: *mut fmx__fmxcpt) -> *mut fmx_RowVect;
pub fn FM_RowVect_Size(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_uint32;
pub fn FM_RowVect_IsEmpty(_self: *const ::std::os::raw::c_void, _x: *mut fmx__fmxcpt) -> bool;
pub fn FM_RowVect_At(
_self: *const ::std::os::raw::c_void,
position: fmx_uint32,
_x: *mut fmx__fmxcpt,
) -> *const fmx_DataVect;
pub fn FM_RowVect_Delete(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
pub fn FM_ExprEnv_Constructor1(_x: *mut fmx__fmxcpt) -> *mut fmx_ExprEnv;
pub fn FM_ExprEnv_Evaluate(
_self: *const ::std::os::raw::c_void,
expression: *const fmx_Text,
result: *mut fmx_Data,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
pub fn FM_ExprEnv_EvaluateGetFunction(
_self: *const ::std::os::raw::c_void,
functionValue: ::std::os::raw::c_short,
result: *mut fmx_Data,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
pub fn FM_ExprEnv_EvaluateConvertToFileMakerPath(
_self: *const ::std::os::raw::c_void,
inPath: *const fmx_Text,
inFormat: fmx_int32,
outFMPath: *mut fmx_Text,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
pub fn FM_ExprEnv_EvaluateConvertFromFileMakerPath(
_self: *const ::std::os::raw::c_void,
inFMPath: *const fmx_Text,
inFormat: fmx_int32,
outPath: *mut fmx_Text,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
pub fn FM_ExprEnv_ExecuteFileSQL(
_self: *const ::std::os::raw::c_void,
expression: *const fmx_Text,
filename: *const fmx_Text,
parameters: *const fmx_DataVect,
result: *mut fmx_RowVect,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
pub fn FM_ExprEnv_ExecuteFileSQLTextResult(
_self: *const ::std::os::raw::c_void,
expression: *const fmx_Text,
filename: *const fmx_Text,
parameters: *const fmx_DataVect,
result: *mut fmx_Data,
colSep: fmx_uint16,
rowSep: fmx_uint16,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
pub fn FM_ExprEnv_RegisterExternalFunction(
pluginId: *const fmx_QuadChar,
functionId: ::std::os::raw::c_short,
functionName: *const fmx_Text,
functionPrototype: *const fmx_Text,
minArgs: ::std::os::raw::c_short,
maxArgs: ::std::os::raw::c_short,
compatibleOnFlags: fmx_uint32,
funcPtr: fmx_ExtPluginType,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
pub fn FM_ExprEnv_RegisterExternalFunctionEx(
pluginId: *const fmx_QuadChar,
functionId: ::std::os::raw::c_short,
functionName: *const fmx_Text,
functionPrototype: *const fmx_Text,
functionDescription: *const fmx_Text,
minArgs: ::std::os::raw::c_short,
maxArgs: ::std::os::raw::c_short,
compatibleOnFlags: fmx_uint32,
funcPtr: fmx_ExtPluginType,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
pub fn FM_ExprEnv_UnRegisterExternalFunction(
pluginId: *const fmx_QuadChar,
functionId: ::std::os::raw::c_short,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
pub fn FM_ExprEnv_SessionID(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_ptrtype;
pub fn FM_ExprEnv_FileID(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_ptrtype;
pub fn FM_ExprEnv_RegisterScriptStep(
pluginId: *const fmx_QuadChar,
scriptStepId: ::std::os::raw::c_short,
scriptStepName: *const fmx_Text,
scriptStepDefinition: *const fmx_Text,
scriptStepDescription: *const fmx_Text,
compatibleOnFlags: fmx_uint32,
funcPtr: fmx_ExtPluginType,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
pub fn FM_ExprEnv_UnRegisterScriptStep(
pluginId: *const fmx_QuadChar,
scriptStepId: ::std::os::raw::c_short,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
pub fn FM_ExprEnv_Delete(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
pub fn FM_Color_Constructor1(_x: *mut fmx__fmxcpt) -> *mut fmx_CharacterStyle_Color;
pub fn FM_Color_Constructor2(
red: fmx_CharacterStyle_ColorChannel,
green: fmx_CharacterStyle_ColorChannel,
blue: fmx_CharacterStyle_ColorChannel,
alpha: fmx_CharacterStyle_ColorChannel,
_x: *mut fmx__fmxcpt,
) -> *mut fmx_CharacterStyle_Color;
pub fn FM_Color_Constructor3(
color: *const fmx_CharacterStyle_Color,
_x: *mut fmx__fmxcpt,
) -> *mut fmx_CharacterStyle_Color;
pub fn FM_Color_SetRed(
_self: *mut ::std::os::raw::c_void,
r: fmx_CharacterStyle_ColorChannel,
_x: *mut fmx__fmxcpt,
);
pub fn FM_Color_SetGreen(
_self: *mut ::std::os::raw::c_void,
g: fmx_CharacterStyle_ColorChannel,
_x: *mut fmx__fmxcpt,
);
pub fn FM_Color_SetBlue(
_self: *mut ::std::os::raw::c_void,
b: fmx_CharacterStyle_ColorChannel,
_x: *mut fmx__fmxcpt,
);
pub fn FM_Color_SetAlpha(
_self: *mut ::std::os::raw::c_void,
a: fmx_CharacterStyle_ColorChannel,
_x: *mut fmx__fmxcpt,
);
pub fn FM_Color_GetRed(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_CharacterStyle_ColorChannel;
pub fn FM_Color_GetGreen(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_CharacterStyle_ColorChannel;
pub fn FM_Color_GetBlue(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_CharacterStyle_ColorChannel;
pub fn FM_Color_GetAlpha(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_CharacterStyle_ColorChannel;
pub fn FM_Color_GetRedUpsample(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_CharacterStyle_ColorChannel16;
pub fn FM_Color_GetGreenUpsample(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_CharacterStyle_ColorChannel16;
pub fn FM_Color_GetBlueUpsample(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_CharacterStyle_ColorChannel16;
pub fn FM_Color_GetAlphaUpsample(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_CharacterStyle_ColorChannel16;
pub fn FM_Color_operatorAS(
_self: *mut ::std::os::raw::c_void,
rhs: *const fmx_CharacterStyle_Color,
_x: *mut fmx__fmxcpt,
) -> *mut fmx_CharacterStyle_Color;
pub fn FM_Color_operatorEQ(
_self: *const ::std::os::raw::c_void,
rhs: *const fmx_CharacterStyle_Color,
_x: *mut fmx__fmxcpt,
) -> bool;
pub fn FM_Color_operatorNE(
_self: *const ::std::os::raw::c_void,
rhs: *const fmx_CharacterStyle_Color,
_x: *mut fmx__fmxcpt,
) -> bool;
pub fn FM_Color_White() -> *const fmx_CharacterStyle_Color;
pub fn FM_Color_Black() -> *const fmx_CharacterStyle_Color;
pub fn FM_Color_Delete(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
pub fn FM_CharacterStyle_Constructor1(_x: *mut fmx__fmxcpt) -> *mut fmx_CharacterStyle;
pub fn FM_CharacterStyle_Constructor2(
font: fmx_CharacterStyle_FontID,
face: fmx_CharacterStyle_Face,
size: fmx_CharacterStyle_FontSize,
color: *const fmx_CharacterStyle_Color,
_x: *mut fmx__fmxcpt,
) -> *mut fmx_CharacterStyle;
pub fn FM_CharacterStyle_Constructor3(
style: *const fmx_CharacterStyle,
_x: *mut fmx__fmxcpt,
) -> *mut fmx_CharacterStyle;
pub fn FM_CharacterStyle_EnableFont(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
pub fn FM_CharacterStyle_EnableFace(
_self: *mut ::std::os::raw::c_void,
face: fmx_CharacterStyle_Face,
_x: *mut fmx__fmxcpt,
);
pub fn FM_CharacterStyle_EnableSize(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
pub fn FM_CharacterStyle_EnableColor(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
pub fn FM_CharacterStyle_DisableFont(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
pub fn FM_CharacterStyle_DisableFace(
_self: *mut ::std::os::raw::c_void,
face: fmx_CharacterStyle_Face,
_x: *mut fmx__fmxcpt,
);
pub fn FM_CharacterStyle_DisableAllFaces(
_self: *mut ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
);
pub fn FM_CharacterStyle_DisableSize(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
pub fn FM_CharacterStyle_DisableColor(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
pub fn FM_CharacterStyle_DisableAll(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
pub fn FM_CharacterStyle_IsAllDisabled(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> bool;
pub fn FM_CharacterStyle_IsFontEnabled(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> bool;
pub fn FM_CharacterStyle_IsFaceEnabled(
_self: *const ::std::os::raw::c_void,
face: fmx_CharacterStyle_Face,
_x: *mut fmx__fmxcpt,
) -> bool;
pub fn FM_CharacterStyle_IsAnyFaceEnabled(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_CharacterStyle_IsSizeEnabled(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_CharacterStyle_IsColorEnabled(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_CharacterStyle_SetFontInformation(
_self: *mut ::std::os::raw::c_void,
font: fmx_CharacterStyle_FontID,
face: fmx_CharacterStyle_Face,
size: fmx_CharacterStyle_FontSize,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_CharacterStyle_GetFontInformation(
_self: *mut ::std::os::raw::c_void,
font: *mut fmx_CharacterStyle_FontID,
face: *mut fmx_CharacterStyle_Face,
size: *mut fmx_CharacterStyle_FontSize,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_CharacterStyle_SetFont(
_self: *mut ::std::os::raw::c_void,
font: fmx_CharacterStyle_FontID,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_CharacterStyle_SetFace(
_self: *mut ::std::os::raw::c_void,
face: fmx_CharacterStyle_Face,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_CharacterStyle_SetSize(
_self: *mut ::std::os::raw::c_void,
size: fmx_CharacterStyle_FontSize,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_CharacterStyle_GetFont(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_CharacterStyle_FontID;
}
extern "C" {
pub fn FM_CharacterStyle_GetFace(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_CharacterStyle_Face;
}
extern "C" {
pub fn FM_CharacterStyle_GetSize(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_CharacterStyle_FontSize;
}
extern "C" {
pub fn FM_CharacterStyle_SetColor(
_self: *mut ::std::os::raw::c_void,
color: *const fmx_CharacterStyle_Color,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_CharacterStyle_GetColor(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> *const fmx_CharacterStyle_Color;
}
extern "C" {
pub fn FM_CharacterStyle_operatorAS(
_self: *mut ::std::os::raw::c_void,
rhs: *const fmx_CharacterStyle,
_x: *mut fmx__fmxcpt,
) -> *mut fmx_CharacterStyle;
}
extern "C" {
pub fn FM_CharacterStyle_operatorEQ(
_self: *const ::std::os::raw::c_void,
rhs: *const fmx_CharacterStyle,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_CharacterStyle_operatorNE(
_self: *const ::std::os::raw::c_void,
rhs: *const fmx_CharacterStyle,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_CharacterStyle_Delete(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
}
extern "C" {
pub fn FM_Data_Constructor1(_x: *mut fmx__fmxcpt) -> *mut fmx_Data;
}
extern "C" {
pub fn FM_Data_IsEmpty(_self: *const ::std::os::raw::c_void, _x: *mut fmx__fmxcpt) -> bool;
}
extern "C" {
pub fn FM_Data_IsValid(_self: *const ::std::os::raw::c_void, _x: *mut fmx__fmxcpt) -> bool;
}
extern "C" {
pub fn FM_Data_IsFindRequest(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_Data_Clear(
_self: *mut ::std::os::raw::c_void,
newNativeType: fmx_int32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Data_GetAsText(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> *const fmx_Text;
}
extern "C" {
pub fn FM_Data_GetAsNumber(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> *const fmx_FixPt;
}
extern "C" {
pub fn FM_Data_GetAsDate(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> *const fmx_DateTime;
}
extern "C" {
pub fn FM_Data_GetAsTime(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> *const fmx_DateTime;
}
extern "C" {
pub fn FM_Data_GetAsTimeStamp(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> *const fmx_DateTime;
}
extern "C" {
pub fn FM_Data_GetAsBoolean(_self: *const ::std::os::raw::c_void, _x: *mut fmx__fmxcpt)
-> bool;
}
extern "C" {
pub fn FM_Data_GetBinaryData(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> *const fmx_BinaryData;
}
extern "C" {
pub fn FM_Data_GetLocale(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> *const fmx_Locale;
}
extern "C" {
pub fn FM_Data_GetNativeType(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_int32;
}
extern "C" {
pub fn FM_Data_ConvertData(
_self: *mut ::std::os::raw::c_void,
nativeType: fmx_int32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Data_SetAsText(
_self: *mut ::std::os::raw::c_void,
textData: *const fmx_Text,
sourceLocale: *const fmx_Locale,
nativeType: fmx_int32,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
}
extern "C" {
pub fn FM_Data_SetAsNumber(
_self: *mut ::std::os::raw::c_void,
numericData: *const fmx_FixPt,
nativeType: fmx_int32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Data_SetAsDate(
_self: *mut ::std::os::raw::c_void,
dateData: *const fmx_DateTime,
nativeType: fmx_int32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Data_SetAsTime(
_self: *mut ::std::os::raw::c_void,
timeData: *const fmx_DateTime,
nativeType: fmx_int32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Data_SetAsTimeStamp(
_self: *mut ::std::os::raw::c_void,
timeStampData: *const fmx_DateTime,
nativeType: fmx_int32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Data_SetDateTime(
_self: *mut ::std::os::raw::c_void,
dateTimeData: *const fmx_DateTime,
dateTimeType: fmx_int32,
nativeType: fmx_int32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Data_SetBinaryData(
_self: *mut ::std::os::raw::c_void,
binaryData: *const fmx_BinaryData,
forceBinaryNativeType: bool,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Data_Delete(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
}
extern "C" {
pub fn FM_Data_GetFontID(
_self: *const ::std::os::raw::c_void,
fontDisplayName: *const fmx_Text,
fontScript: fmx_CharacterStyle_FontScript,
env: *const fmx_ExprEnv,
_x: *mut fmx__fmxcpt,
) -> fmx_CharacterStyle_FontID;
}
extern "C" {
pub fn FM_Data_GetPostscriptFontID(
_self: *const ::std::os::raw::c_void,
fontPostscriptName: *const fmx_Text,
env: *const fmx_ExprEnv,
_x: *mut fmx__fmxcpt,
) -> fmx_CharacterStyle_FontID;
}
extern "C" {
pub fn FM_Data_GetFontInfo(
_self: *const ::std::os::raw::c_void,
font: fmx_CharacterStyle_FontID,
fontDisplayName: *mut fmx_Text,
fontScript: *mut fmx_CharacterStyle_FontScript,
env: *const fmx_ExprEnv,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_Data_GetPostscriptFontInfo(
_self: *const ::std::os::raw::c_void,
font: fmx_CharacterStyle_FontID,
fontPostscriptName: *mut fmx_Text,
env: *const fmx_ExprEnv,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_DateTime_Constructor1(_x: *mut fmx__fmxcpt) -> *mut fmx_DateTime;
}
extern "C" {
pub fn FM_DateTime_Constructor2(
dateString: *const fmx_unichar16,
dateLength: fmx_uint32,
intl: *const fmx_Locale,
_x: *mut fmx__fmxcpt,
) -> *mut fmx_DateTime;
}
extern "C" {
pub fn FM_DateTime_Constructor3(
dateText: *const fmx_Text,
intl: *const fmx_Locale,
_x: *mut fmx__fmxcpt,
) -> *mut fmx_DateTime;
}
extern "C" {
pub fn FM_DateTime_operatorEQ(
_self: *const ::std::os::raw::c_void,
that: *const fmx_DateTime,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_DateTime_operatorNE(
_self: *const ::std::os::raw::c_void,
that: *const fmx_DateTime,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_DateTime_IsLeapYear(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_DateTime_DayOfWeek(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_int16;
}
extern "C" {
pub fn FM_DateTime_DayOfYear(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_int16;
}
extern "C" {
pub fn FM_DateTime_WeekOfYear(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_int16;
}
extern "C" {
pub fn FM_DateTime_Now(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
}
extern "C" {
pub fn FM_DateTime_SetDate(
_self: *mut ::std::os::raw::c_void,
datetime: *const fmx_DateTime,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_DateTime_SetNormalizedDate1(
_self: *mut ::std::os::raw::c_void,
month: fmx_int16,
day: fmx_int16,
year: fmx_int16,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
}
extern "C" {
pub fn FM_DateTime_SetNormalizedDate2(
_self: *mut ::std::os::raw::c_void,
year: *const fmx_FixPt,
month: *const fmx_FixPt,
day: *const fmx_FixPt,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
}
extern "C" {
pub fn FM_DateTime_SetDaysSinceEpoch(
_self: *mut ::std::os::raw::c_void,
days: fmx_int64,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_DateTime_SetTime(
_self: *mut ::std::os::raw::c_void,
datetime: *const fmx_DateTime,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_DateTime_SetNormalizedTime1(
_self: *mut ::std::os::raw::c_void,
hour: fmx_int64,
minute: fmx_int16,
sec: fmx_int16,
usec: fmx_int32,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
}
extern "C" {
pub fn FM_DateTime_SetNormalizedTime2(
_self: *mut ::std::os::raw::c_void,
hour: *const fmx_FixPt,
minute: *const fmx_FixPt,
sec: *const fmx_FixPt,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
}
extern "C" {
pub fn FM_DateTime_SetSecsSinceMidnight(
_self: *mut ::std::os::raw::c_void,
secs: *const fmx_FixPt,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_DateTime_SetSecondsSinceEpoch(
_self: *mut ::std::os::raw::c_void,
seconds: *const fmx_FixPt,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_DateTime_GetYear(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_int16;
}
extern "C" {
pub fn FM_DateTime_GetMonth(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_int16;
}
extern "C" {
pub fn FM_DateTime_GetDay(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_int16;
}
extern "C" {
pub fn FM_DateTime_GetDaysSinceEpoch(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_int32;
}
extern "C" {
pub fn FM_DateTime_GetHour(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_int32;
}
extern "C" {
pub fn FM_DateTime_GetMinute(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_int16;
}
extern "C" {
pub fn FM_DateTime_GetSec(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_int16;
}
extern "C" {
pub fn FM_DateTime_GetUSec(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_int32;
}
extern "C" {
pub fn FM_DateTime_GetSeconds(
_self: *const ::std::os::raw::c_void,
results: *mut fmx_FixPt,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_DateTime_GetSecsSinceMidnight(
_self: *const ::std::os::raw::c_void,
results: *mut fmx_FixPt,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_DateTime_GetSecondsSinceEpoch(
_self: *const ::std::os::raw::c_void,
results: *mut fmx_FixPt,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_DateTime_Delete(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
}
extern "C" {
pub fn FM_FixPt_Constructor1(
val: fmx_int32,
precision: ::std::os::raw::c_int,
_x: *mut fmx__fmxcpt,
) -> *mut fmx_FixPt;
}
extern "C" {
pub fn FM_FixPt_Constructor2(
val: fmx_int32,
precisionExample: *const fmx_FixPt,
_x: *mut fmx__fmxcpt,
) -> *mut fmx_FixPt;
}
extern "C" {
pub fn FM_FixPt_AssignInt(
_self: *mut ::std::os::raw::c_void,
that: fmx_int32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_FixPt_AssignInt64(
_self: *mut ::std::os::raw::c_void,
that: fmx_int64,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_FixPt_AssignDouble(
_self: *mut ::std::os::raw::c_void,
that: f64,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_FixPt_AssignFixPt(
_self: *mut ::std::os::raw::c_void,
that: *const fmx_FixPt,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_FixPt_operatorEQ(
_self: *const ::std::os::raw::c_void,
that: *const fmx_FixPt,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_FixPt_operatorNE(
_self: *const ::std::os::raw::c_void,
that: *const fmx_FixPt,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_FixPt_operatorLT(
_self: *const ::std::os::raw::c_void,
that: *const fmx_FixPt,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_FixPt_operatorLE(
_self: *const ::std::os::raw::c_void,
that: *const fmx_FixPt,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_FixPt_operatorGT(
_self: *const ::std::os::raw::c_void,
that: *const fmx_FixPt,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_FixPt_operatorGE(
_self: *const ::std::os::raw::c_void,
that: *const fmx_FixPt,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_FixPt_Increment(
_self: *mut ::std::os::raw::c_void,
n: fmx_int32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_FixPt_Increment64(
_self: *mut ::std::os::raw::c_void,
n: fmx_int64,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_FixPt_Decrement(
_self: *mut ::std::os::raw::c_void,
n: fmx_int32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_FixPt_Decrement64(
_self: *mut ::std::os::raw::c_void,
n: fmx_int64,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_FixPt_Negate(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
}
extern "C" {
pub fn FM_FixPt_GetPrecision(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn FM_FixPt_SetPrecision(
_self: *mut ::std::os::raw::c_void,
precision: ::std::os::raw::c_int,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_FixPt_Add(
_self: *const ::std::os::raw::c_void,
arg: *const fmx_FixPt,
result: *mut fmx_FixPt,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_FixPt_Subtract(
_self: *const ::std::os::raw::c_void,
arg: *const fmx_FixPt,
result: *mut fmx_FixPt,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_FixPt_Multiply(
_self: *const ::std::os::raw::c_void,
arg: *const fmx_FixPt,
result: *mut fmx_FixPt,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_FixPt_Divide(
_self: *const ::std::os::raw::c_void,
arg: *const fmx_FixPt,
result: *mut fmx_FixPt,
_x: *mut fmx__fmxcpt,
) -> fmx_errcode;
}
extern "C" {
pub fn FM_FixPt_AsBool(_self: *const ::std::os::raw::c_void, _x: *mut fmx__fmxcpt) -> bool;
}
extern "C" {
pub fn FM_FixPt_AsLong(_self: *const ::std::os::raw::c_void, _x: *mut fmx__fmxcpt)
-> fmx_int32;
}
extern "C" {
pub fn FM_FixPt_AsLong64(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_int64;
}
extern "C" {
pub fn FM_FixPt_AsFloat(_self: *const ::std::os::raw::c_void, _x: *mut fmx__fmxcpt) -> f64;
}
extern "C" {
pub fn FM_FixPt_Delete(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
}
extern "C" {
pub fn FM_Text_Constructor1(_x: *mut fmx__fmxcpt) -> *mut fmx_Text;
}
extern "C" {
pub fn FM_Text_GetSize(
_self: *const ::std::os::raw::c_void,
_x: *mut fmx__fmxcpt,
) -> fmx_uint32;
}
extern "C" {
pub fn FM_Text_Assign(
_self: *mut ::std::os::raw::c_void,
s: *const ::std::os::raw::c_char,
encoding: fmx_int32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Text_GetBytes(
_self: *const ::std::os::raw::c_void,
buffer: *mut ::std::os::raw::c_char,
buffersize: fmx_uint32,
position: fmx_uint32,
size: fmx_uint32,
encoding: fmx_int32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Text_GetBytesEx(
_self: *const ::std::os::raw::c_void,
buffer: *mut ::std::os::raw::c_char,
buffersize: fmx_uint32,
position: fmx_uint32,
size: fmx_uint32,
encoding: fmx_int32,
_x: *mut fmx__fmxcpt,
) -> fmx_uint32;
}
extern "C" {
pub fn FM_Text_AssignWide(
_self: *mut ::std::os::raw::c_void,
s: *const u16,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Text_AssignUnicode(
_self: *mut ::std::os::raw::c_void,
s: *const fmx_uint16,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Text_AssignWithLength(
_self: *mut ::std::os::raw::c_void,
s: *const ::std::os::raw::c_char,
strlength: fmx_uint32,
encoding: fmx_int32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Text_AssignWideWithLength(
_self: *mut ::std::os::raw::c_void,
s: *const u16,
strlength: fmx_uint32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Text_AssignUnicodeWithLength(
_self: *mut ::std::os::raw::c_void,
s: *const fmx_uint16,
strlength: fmx_uint32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Text_GetUnicode(
_self: *const ::std::os::raw::c_void,
s: *mut fmx_uint16,
position: fmx_uint32,
size: fmx_uint32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Text_SetText(
_self: *mut ::std::os::raw::c_void,
other: *const fmx_Text,
position: fmx_uint32,
size: fmx_uint32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Text_AppendText(
_self: *mut ::std::os::raw::c_void,
other: *const fmx_Text,
position: fmx_uint32,
size: fmx_uint32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Text_InsertText(
_self: *mut ::std::os::raw::c_void,
other: *const fmx_Text,
position: fmx_uint32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Text_DeleteText(
_self: *mut ::std::os::raw::c_void,
positionToDelete: fmx_uint32,
sizeToDelete: fmx_uint32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Text_Find(
_self: *const ::std::os::raw::c_void,
other: *const fmx_Text,
position: fmx_uint32,
_x: *mut fmx__fmxcpt,
) -> fmx_uint32;
}
extern "C" {
pub fn FM_Text_FindPrev(
_self: *const ::std::os::raw::c_void,
other: *const fmx_Text,
position: fmx_uint32,
_x: *mut fmx__fmxcpt,
) -> fmx_uint32;
}
extern "C" {
pub fn FM_Text_FindIgnoringCase(
_self: *const ::std::os::raw::c_void,
other: *const fmx_Text,
position: fmx_uint32,
_x: *mut fmx__fmxcpt,
) -> fmx_uint32;
}
extern "C" {
pub fn FM_Text_FindPrevIgnoringCase(
_self: *const ::std::os::raw::c_void,
other: *const fmx_Text,
position: fmx_uint32,
_x: *mut fmx__fmxcpt,
) -> fmx_uint32;
}
extern "C" {
pub fn FM_Text_Uppercase(_self: *const ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
}
extern "C" {
pub fn FM_Text_Lowercase(_self: *const ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
}
extern "C" {
pub fn FM_Text_GetStyle(
_self: *const ::std::os::raw::c_void,
style: *mut fmx_CharacterStyle,
position: fmx_uint32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Text_GetDefaultStyle(
_self: *const ::std::os::raw::c_void,
style: *mut fmx_CharacterStyle,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Text_SetStyle(
_self: *mut ::std::os::raw::c_void,
style: *const fmx_CharacterStyle,
position: fmx_uint32,
size: fmx_uint32,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Text_RemoveStyle(
_self: *mut ::std::os::raw::c_void,
style: *const fmx_CharacterStyle,
_x: *mut fmx__fmxcpt,
);
}
extern "C" {
pub fn FM_Text_ResetAllStyleBuffers(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
}
extern "C" {
pub fn FM_Text_operatorEQ(
_self: *const ::std::os::raw::c_void,
that: *const fmx_Text,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_Text_operatorNE(
_self: *const ::std::os::raw::c_void,
that: *const fmx_Text,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_Text_operatorLT(
_self: *const ::std::os::raw::c_void,
that: *const fmx_Text,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_Text_operatorLE(
_self: *const ::std::os::raw::c_void,
that: *const fmx_Text,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_Text_operatorGT(
_self: *const ::std::os::raw::c_void,
that: *const fmx_Text,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_Text_operatorGE(
_self: *const ::std::os::raw::c_void,
that: *const fmx_Text,
_x: *mut fmx__fmxcpt,
) -> bool;
}
extern "C" {
pub fn FM_Text_Delete(_self: *mut ::std::os::raw::c_void, _x: *mut fmx__fmxcpt);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __crt_locale_data {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __crt_multibyte_data {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _bindgen_ty_1 {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _bindgen_ty_2 {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _bindgen_ty_3 {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _bindgen_ty_4 {
pub _address: u8,
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char_close0_instantiation_2() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char_close0_instantiation_3() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char_close0_instantiation_4() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char_close0_instantiation_5() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char_close0_instantiation_6() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char_close0_instantiation_7() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_allocator_open0_char_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_allocator>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_allocator)
)
);
assert_eq!(
::std::mem::align_of::<std_allocator>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_allocator)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char_close0_instantiation_8() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_allocator_open0_char_close0_instantiation_1() {
assert_eq!(
::std::mem::size_of::<std_allocator>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_allocator)
)
);
assert_eq!(
::std::mem::align_of::<std_allocator>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_allocator)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char_close0_instantiation_9() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_allocator_open0_char_close0_instantiation_2() {
assert_eq!(
::std::mem::size_of::<std_allocator>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_allocator)
)
);
assert_eq!(
::std::mem::align_of::<std_allocator>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_allocator)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char_close0_instantiation_10() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_allocator_open0_char_close0_instantiation_3() {
assert_eq!(
::std::mem::size_of::<std_allocator>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_allocator)
)
);
assert_eq!(
::std::mem::align_of::<std_allocator>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_allocator)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char_close0_instantiation_11() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char_close0_instantiation_12() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char_close0_instantiation_13() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char_close0_instantiation_14() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_wchar_t_close0_instantiation_2() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_wchar_t_close0_instantiation_3() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_wchar_t_close0_instantiation_4() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_wchar_t_close0_instantiation_5() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_wchar_t_close0_instantiation_6() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_wchar_t_close0_instantiation_7() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_allocator_open0_wchar_t_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_allocator>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_allocator)
)
);
assert_eq!(
::std::mem::align_of::<std_allocator>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_allocator)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_wchar_t_close0_instantiation_8() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_allocator_open0_wchar_t_close0_instantiation_1() {
assert_eq!(
::std::mem::size_of::<std_allocator>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_allocator)
)
);
assert_eq!(
::std::mem::align_of::<std_allocator>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_allocator)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_wchar_t_close0_instantiation_9() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_allocator_open0_wchar_t_close0_instantiation_2() {
assert_eq!(
::std::mem::size_of::<std_allocator>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_allocator)
)
);
assert_eq!(
::std::mem::align_of::<std_allocator>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_allocator)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_wchar_t_close0_instantiation_10() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_allocator_open0_wchar_t_close0_instantiation_3() {
assert_eq!(
::std::mem::size_of::<std_allocator>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_allocator)
)
);
assert_eq!(
::std::mem::align_of::<std_allocator>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_allocator)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_wchar_t_close0_instantiation_11() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_wchar_t_close0_instantiation_12() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_wchar_t_close0_instantiation_13() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_wchar_t_close0_instantiation_14() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _bindgen_ty_5 {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _bindgen_ty_6 {
pub _address: u8,
}
#[test]
fn __bindgen_test_layout_std_basic_string_open0_char_std_char_traits_open1_char_close1_std_allocator_open1_char_close1_close0_instantiation(
) {
assert_eq!(
::std::mem::size_of::<std_basic_string>(),
32usize,
concat!(
"Size of template specialization: ",
stringify!(std_basic_string)
)
);
assert_eq!(
::std::mem::align_of::<std_basic_string>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_basic_string)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char_close0_instantiation_15() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_allocator_open0_char_close0_instantiation_4() {
assert_eq!(
::std::mem::size_of::<std_allocator>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_allocator)
)
);
assert_eq!(
::std::mem::align_of::<std_allocator>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_allocator)
)
);
}
#[test]
fn __bindgen_test_layout_std_basic_string_open0_wchar_t_std_char_traits_open1_wchar_t_close1_std_allocator_open1_wchar_t_close1_close0_instantiation(
) {
assert_eq!(
::std::mem::size_of::<std_basic_string>(),
32usize,
concat!(
"Size of template specialization: ",
stringify!(std_basic_string)
)
);
assert_eq!(
::std::mem::align_of::<std_basic_string>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_basic_string)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_wchar_t_close0_instantiation_15() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_allocator_open0_wchar_t_close0_instantiation_4() {
assert_eq!(
::std::mem::size_of::<std_allocator>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_allocator)
)
);
assert_eq!(
::std::mem::align_of::<std_allocator>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_allocator)
)
);
}
#[test]
fn __bindgen_test_layout_std_basic_string_open0_char16_t_std_char_traits_open1_char16_t_close1_std_allocator_open1_char16_t_close1_close0_instantiation(
) {
assert_eq!(
::std::mem::size_of::<std_basic_string>(),
32usize,
concat!(
"Size of template specialization: ",
stringify!(std_basic_string)
)
);
assert_eq!(
::std::mem::align_of::<std_basic_string>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_basic_string)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char16_t_close0_instantiation_2() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_allocator_open0_char16_t_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_allocator>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_allocator)
)
);
assert_eq!(
::std::mem::align_of::<std_allocator>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_allocator)
)
);
}
#[test]
fn __bindgen_test_layout_std_basic_string_open0_char32_t_std_char_traits_open1_char32_t_close1_std_allocator_open1_char32_t_close1_close0_instantiation(
) {
assert_eq!(
::std::mem::size_of::<std_basic_string>(),
32usize,
concat!(
"Size of template specialization: ",
stringify!(std_basic_string)
)
);
assert_eq!(
::std::mem::align_of::<std_basic_string>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_basic_string)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_char32_t_close0_instantiation_2() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_allocator_open0_char32_t_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_allocator>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_allocator)
)
);
assert_eq!(
::std::mem::align_of::<std_allocator>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_allocator)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _bindgen_ty_7 {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _bindgen_ty_8 {
pub _address: u8,
}
#[test]
fn __bindgen_test_layout_std_auto_ptr_open0_fmx_QuadChar_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_auto_ptr<fmx_QuadChar>>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_auto_ptr<fmx_QuadChar>)
)
);
assert_eq!(
::std::mem::align_of::<std_auto_ptr<fmx_QuadChar>>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_auto_ptr<fmx_QuadChar>)
)
);
}
#[test]
fn __bindgen_test_layout_std_auto_ptr_open0_fmx_Locale_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_auto_ptr<fmx_Locale>>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_auto_ptr<fmx_Locale>)
)
);
assert_eq!(
::std::mem::align_of::<std_auto_ptr<fmx_Locale>>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_auto_ptr<fmx_Locale>)
)
);
}
#[test]
fn __bindgen_test_layout_std_unique_ptr_open0_fmx_QuadChar_std_default_delete_open1_fmx_QuadChar_close1_close0_instantiation(
) {
assert_eq!(
::std::mem::size_of::<std_unique_ptr>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_unique_ptr)
)
);
assert_eq!(
::std::mem::align_of::<std_unique_ptr>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_unique_ptr)
)
);
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_fmx_QuadChar_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_default_delete>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_default_delete)
)
);
assert_eq!(
::std::mem::align_of::<std_default_delete>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_default_delete)
)
);
}
#[test]
fn __bindgen_test_layout_std_unique_ptr_open0_fmx_Locale_std_default_delete_open1_fmx_Locale_close1_close0_instantiation(
) {
assert_eq!(
::std::mem::size_of::<std_unique_ptr>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_unique_ptr)
)
);
assert_eq!(
::std::mem::align_of::<std_unique_ptr>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_unique_ptr)
)
);
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_fmx_Locale_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_default_delete>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_default_delete)
)
);
assert_eq!(
::std::mem::align_of::<std_default_delete>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_default_delete)
)
);
}
#[test]
fn __bindgen_test_layout_std_auto_ptr_open0_fmx_BinaryData_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_auto_ptr<fmx_BinaryData>>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_auto_ptr<fmx_BinaryData>)
)
);
assert_eq!(
::std::mem::align_of::<std_auto_ptr<fmx_BinaryData>>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_auto_ptr<fmx_BinaryData>)
)
);
}
#[test]
fn __bindgen_test_layout_std_unique_ptr_open0_fmx_BinaryData_std_default_delete_open1_fmx_BinaryData_close1_close0_instantiation(
) {
assert_eq!(
::std::mem::size_of::<std_unique_ptr>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_unique_ptr)
)
);
assert_eq!(
::std::mem::align_of::<std_unique_ptr>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_unique_ptr)
)
);
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_fmx_BinaryData_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_default_delete>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_default_delete)
)
);
assert_eq!(
::std::mem::align_of::<std_default_delete>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_default_delete)
)
);
}
#[test]
fn __bindgen_test_layout_std_auto_ptr_open0_fmx_DataVect_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_auto_ptr<fmx_DataVect>>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_auto_ptr<fmx_DataVect>)
)
);
assert_eq!(
::std::mem::align_of::<std_auto_ptr<fmx_DataVect>>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_auto_ptr<fmx_DataVect>)
)
);
}
#[test]
fn __bindgen_test_layout_std_auto_ptr_open0_fmx_RowVect_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_auto_ptr<fmx_RowVect>>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_auto_ptr<fmx_RowVect>)
)
);
assert_eq!(
::std::mem::align_of::<std_auto_ptr<fmx_RowVect>>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_auto_ptr<fmx_RowVect>)
)
);
}
#[test]
fn __bindgen_test_layout_std_auto_ptr_open0_fmx_ExprEnv_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_auto_ptr<fmx_ExprEnv>>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_auto_ptr<fmx_ExprEnv>)
)
);
assert_eq!(
::std::mem::align_of::<std_auto_ptr<fmx_ExprEnv>>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_auto_ptr<fmx_ExprEnv>)
)
);
}
#[test]
fn __bindgen_test_layout_std_unique_ptr_open0_fmx_DataVect_std_default_delete_open1_fmx_DataVect_close1_close0_instantiation(
) {
assert_eq!(
::std::mem::size_of::<std_unique_ptr>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_unique_ptr)
)
);
assert_eq!(
::std::mem::align_of::<std_unique_ptr>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_unique_ptr)
)
);
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_fmx_DataVect_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_default_delete>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_default_delete)
)
);
assert_eq!(
::std::mem::align_of::<std_default_delete>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_default_delete)
)
);
}
#[test]
fn __bindgen_test_layout_std_unique_ptr_open0_fmx_RowVect_std_default_delete_open1_fmx_RowVect_close1_close0_instantiation(
) {
assert_eq!(
::std::mem::size_of::<std_unique_ptr>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_unique_ptr)
)
);
assert_eq!(
::std::mem::align_of::<std_unique_ptr>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_unique_ptr)
)
);
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_fmx_RowVect_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_default_delete>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_default_delete)
)
);
assert_eq!(
::std::mem::align_of::<std_default_delete>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_default_delete)
)
);
}
#[test]
fn __bindgen_test_layout_std_unique_ptr_open0_fmx_ExprEnv_std_default_delete_open1_fmx_ExprEnv_close1_close0_instantiation(
) {
assert_eq!(
::std::mem::size_of::<std_unique_ptr>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_unique_ptr)
)
);
assert_eq!(
::std::mem::align_of::<std_unique_ptr>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_unique_ptr)
)
);
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_fmx_ExprEnv_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_default_delete>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_default_delete)
)
);
assert_eq!(
::std::mem::align_of::<std_default_delete>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_default_delete)
)
);
}
#[test]
fn __bindgen_test_layout_std_auto_ptr_open0_fmx_CharacterStyle_Color_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_auto_ptr<fmx_CharacterStyle_Color>>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_auto_ptr<fmx_CharacterStyle_Color>)
)
);
assert_eq!(
::std::mem::align_of::<std_auto_ptr<fmx_CharacterStyle_Color>>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_auto_ptr<fmx_CharacterStyle_Color>)
)
);
}
#[test]
fn __bindgen_test_layout_std_auto_ptr_open0_fmx_CharacterStyle_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_auto_ptr<fmx_CharacterStyle>>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_auto_ptr<fmx_CharacterStyle>)
)
);
assert_eq!(
::std::mem::align_of::<std_auto_ptr<fmx_CharacterStyle>>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_auto_ptr<fmx_CharacterStyle>)
)
);
}
#[test]
fn __bindgen_test_layout_std_unique_ptr_open0_fmx_CharacterStyle_Color_std_default_delete_open1_fmx_CharacterStyle_Color_close1_close0_instantiation(
) {
assert_eq!(
::std::mem::size_of::<std_unique_ptr>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_unique_ptr)
)
);
assert_eq!(
::std::mem::align_of::<std_unique_ptr>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_unique_ptr)
)
);
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_fmx_CharacterStyle_Color_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_default_delete>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_default_delete)
)
);
assert_eq!(
::std::mem::align_of::<std_default_delete>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_default_delete)
)
);
}
#[test]
fn __bindgen_test_layout_std_unique_ptr_open0_fmx_CharacterStyle_std_default_delete_open1_fmx_CharacterStyle_close1_close0_instantiation(
) {
assert_eq!(
::std::mem::size_of::<std_unique_ptr>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_unique_ptr)
)
);
assert_eq!(
::std::mem::align_of::<std_unique_ptr>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_unique_ptr)
)
);
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_fmx_CharacterStyle_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_default_delete>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_default_delete)
)
);
assert_eq!(
::std::mem::align_of::<std_default_delete>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_default_delete)
)
);
}
#[test]
fn __bindgen_test_layout_std_auto_ptr_open0_fmx_Data_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_auto_ptr<fmx_Data>>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_auto_ptr<fmx_Data>)
)
);
assert_eq!(
::std::mem::align_of::<std_auto_ptr<fmx_Data>>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_auto_ptr<fmx_Data>)
)
);
}
#[test]
fn __bindgen_test_layout_std_unique_ptr_open0_fmx_Data_std_default_delete_open1_fmx_Data_close1_close0_instantiation(
) {
assert_eq!(
::std::mem::size_of::<std_unique_ptr>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_unique_ptr)
)
);
assert_eq!(
::std::mem::align_of::<std_unique_ptr>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_unique_ptr)
)
);
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_fmx_Data_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_default_delete>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_default_delete)
)
);
assert_eq!(
::std::mem::align_of::<std_default_delete>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_default_delete)
)
);
}
#[test]
fn __bindgen_test_layout_std_auto_ptr_open0_fmx_DateTime_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_auto_ptr<fmx_DateTime>>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_auto_ptr<fmx_DateTime>)
)
);
assert_eq!(
::std::mem::align_of::<std_auto_ptr<fmx_DateTime>>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_auto_ptr<fmx_DateTime>)
)
);
}
#[test]
fn __bindgen_test_layout_std_unique_ptr_open0_fmx_DateTime_std_default_delete_open1_fmx_DateTime_close1_close0_instantiation(
) {
assert_eq!(
::std::mem::size_of::<std_unique_ptr>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_unique_ptr)
)
);
assert_eq!(
::std::mem::align_of::<std_unique_ptr>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_unique_ptr)
)
);
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_fmx_DateTime_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_default_delete>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_default_delete)
)
);
assert_eq!(
::std::mem::align_of::<std_default_delete>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_default_delete)
)
);
}
#[test]
fn __bindgen_test_layout_std_auto_ptr_open0_fmx_FixPt_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_auto_ptr<fmx_FixPt>>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_auto_ptr<fmx_FixPt>)
)
);
assert_eq!(
::std::mem::align_of::<std_auto_ptr<fmx_FixPt>>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_auto_ptr<fmx_FixPt>)
)
);
}
#[test]
fn __bindgen_test_layout_std_unique_ptr_open0_fmx_FixPt_std_default_delete_open1_fmx_FixPt_close1_close0_instantiation(
) {
assert_eq!(
::std::mem::size_of::<std_unique_ptr>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_unique_ptr)
)
);
assert_eq!(
::std::mem::align_of::<std_unique_ptr>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_unique_ptr)
)
);
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_fmx_FixPt_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_default_delete>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_default_delete)
)
);
assert_eq!(
::std::mem::align_of::<std_default_delete>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_default_delete)
)
);
}
#[test]
fn __bindgen_test_layout_std_auto_ptr_open0_fmx_Text_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_auto_ptr<fmx_Text>>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_auto_ptr<fmx_Text>)
)
);
assert_eq!(
::std::mem::align_of::<std_auto_ptr<fmx_Text>>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_auto_ptr<fmx_Text>)
)
);
}
#[test]
fn __bindgen_test_layout_std_unique_ptr_open0_fmx_Text_std_default_delete_open1_fmx_Text_close1_close0_instantiation(
) {
assert_eq!(
::std::mem::size_of::<std_unique_ptr>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(std_unique_ptr)
)
);
assert_eq!(
::std::mem::align_of::<std_unique_ptr>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_unique_ptr)
)
);
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_fmx_Text_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_default_delete>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_default_delete)
)
);
assert_eq!(
::std::mem::align_of::<std_default_delete>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_default_delete)
)
);
}