From d27384e582b9a89f1af1118c8fccf7862e5da485 Mon Sep 17 00:00:00 2001 From: qwerty2501 Date: Sun, 26 Jun 2022 17:59:02 +0000 Subject: [PATCH] Automated generate bindings for x86_64-pc-windows-msvc --- .../src/generated/windows/x86_64/bindings.rs | 29632 ++++++++-------- 1 file changed, 14816 insertions(+), 14816 deletions(-) diff --git a/crates/openjtalk-sys/src/generated/windows/x86_64/bindings.rs b/crates/openjtalk-sys/src/generated/windows/x86_64/bindings.rs index 9c2950006..ff1c383e5 100644 --- a/crates/openjtalk-sys/src/generated/windows/x86_64/bindings.rs +++ b/crates/openjtalk-sys/src/generated/windows/x86_64/bindings.rs @@ -153,6 +153,7 @@ impl ::std::cmp::PartialEq for __BindgenUnionField { } } impl ::std::cmp::Eq for __BindgenUnionField {} +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; @@ -165,53 +166,6 @@ pub const _HAS_CXX17: u32 = 0; pub const _HAS_CXX20: u32 = 0; pub const _HAS_CXX23: u32 = 0; pub const _HAS_NODISCARD: u32 = 1; -pub const _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE: u32 = 1; -pub const _CRT_BUILD_DESKTOP_APP: u32 = 1; -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 _CRT_HAS_C11: u32 = 0; -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_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 _STL_COMPILER_PREPROCESSOR: u32 = 1; pub const _STL_WARNING_LEVEL: u32 = 3; pub const _HAS_CONDITIONAL_EXPLICIT: u32 = 1; pub const _STL_DISABLED_WARNING_C4984: u32 = 4984; @@ -272,6 +226,52 @@ pub const _STL_WIN32_WINNT_WIN8: u32 = 1538; pub const _STL_WIN32_WINNT_WINBLUE: u32 = 1539; pub const _STL_WIN32_WINNT_WIN10: u32 = 2560; pub const _STL_WIN32_WINNT: u32 = 1536; +pub const _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE: u32 = 1; +pub const _CRT_BUILD_DESKTOP_APP: u32 = 1; +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 _CRT_HAS_C11: u32 = 0; +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_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 WINAPI_FAMILY_PC_APP: u32 = 2; pub const WINAPI_FAMILY_PHONE_APP: u32 = 3; pub const WINAPI_FAMILY_SYSTEM: u32 = 4; @@ -20674,6 +20674,835 @@ pub const IMFS_UNHILITE: u32 = 0; pub const IMFS_DEFAULT: u32 = 4096; pub const SOFTKEYBOARD_TYPE_T1: u32 = 1; pub const SOFTKEYBOARD_TYPE_C1: u32 = 2; +#[doc = " DictionaryInfo structure"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct mecab_dictionary_info_t { + #[doc = " filename of dictionary"] + #[doc = " On Windows, filename is stored in UTF-8 encoding"] + pub filename: *const ::std::os::raw::c_char, + #[doc = " character set of the dictionary. e.g., \"SHIFT-JIS\", \"UTF-8\""] + pub charset: *const ::std::os::raw::c_char, + #[doc = " How many words are registered in this dictionary."] + pub size: ::std::os::raw::c_uint, + #[doc = " dictionary type"] + #[doc = " this value should be MECAB_USR_DIC, MECAB_SYS_DIC, or MECAB_UNK_DIC."] + pub type_: ::std::os::raw::c_int, + #[doc = " left attributes size"] + pub lsize: ::std::os::raw::c_uint, + #[doc = " right attributes size"] + pub rsize: ::std::os::raw::c_uint, + #[doc = " version of this dictionary"] + pub version: ::std::os::raw::c_ushort, + #[doc = " pointer to the next dictionary info."] + pub next: *mut mecab_dictionary_info_t, +} +#[test] +fn bindgen_test_layout_mecab_dictionary_info_t() { + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(mecab_dictionary_info_t)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(mecab_dictionary_info_t)) + ); + fn test_field_filename() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).filename) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(mecab_dictionary_info_t), + "::", + stringify!(filename) + ) + ); + } + test_field_filename(); + fn test_field_charset() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).charset) as usize - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(mecab_dictionary_info_t), + "::", + stringify!(charset) + ) + ); + } + test_field_charset(); + fn test_field_size() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(mecab_dictionary_info_t), + "::", + stringify!(size) + ) + ); + } + test_field_size(); + fn test_field_type() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize + }, + 20usize, + concat!( + "Offset of field: ", + stringify!(mecab_dictionary_info_t), + "::", + stringify!(type_) + ) + ); + } + test_field_type(); + fn test_field_lsize() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).lsize) as usize - ptr as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(mecab_dictionary_info_t), + "::", + stringify!(lsize) + ) + ); + } + test_field_lsize(); + fn test_field_rsize() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).rsize) as usize - ptr as usize + }, + 28usize, + concat!( + "Offset of field: ", + stringify!(mecab_dictionary_info_t), + "::", + stringify!(rsize) + ) + ); + } + test_field_rsize(); + fn test_field_version() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(mecab_dictionary_info_t), + "::", + stringify!(version) + ) + ); + } + test_field_version(); + fn test_field_next() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(mecab_dictionary_info_t), + "::", + stringify!(next) + ) + ); + } + test_field_next(); +} +#[doc = " Path structure"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct mecab_path_t { + #[doc = " pointer to the right node"] + pub rnode: *mut mecab_node_t, + #[doc = " pointer to the next right path"] + pub rnext: *mut mecab_path_t, + #[doc = " pointer to the left node"] + pub lnode: *mut mecab_node_t, + #[doc = " pointer to the next left path"] + pub lnext: *mut mecab_path_t, + #[doc = " local cost"] + pub cost: ::std::os::raw::c_int, + #[doc = " marginal probability"] + pub prob: f32, +} +#[test] +fn bindgen_test_layout_mecab_path_t() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(mecab_path_t)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(mecab_path_t)) + ); + fn test_field_rnode() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).rnode) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(mecab_path_t), + "::", + stringify!(rnode) + ) + ); + } + test_field_rnode(); + fn test_field_rnext() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).rnext) as usize - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(mecab_path_t), + "::", + stringify!(rnext) + ) + ); + } + test_field_rnext(); + fn test_field_lnode() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).lnode) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(mecab_path_t), + "::", + stringify!(lnode) + ) + ); + } + test_field_lnode(); + fn test_field_lnext() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).lnext) as usize - ptr as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(mecab_path_t), + "::", + stringify!(lnext) + ) + ); + } + test_field_lnext(); + fn test_field_cost() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).cost) as usize - ptr as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(mecab_path_t), + "::", + stringify!(cost) + ) + ); + } + test_field_cost(); + fn test_field_prob() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).prob) as usize - ptr as usize + }, + 36usize, + concat!( + "Offset of field: ", + stringify!(mecab_path_t), + "::", + stringify!(prob) + ) + ); + } + test_field_prob(); +} +#[doc = " Node structure"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct mecab_node_t { + #[doc = " pointer to the previous node."] + pub prev: *mut mecab_node_t, + #[doc = " pointer to the next node."] + pub next: *mut mecab_node_t, + #[doc = " pointer to the node which ends at the same position."] + pub enext: *mut mecab_node_t, + #[doc = " pointer to the node which starts at the same position."] + pub bnext: *mut mecab_node_t, + #[doc = " pointer to the right path."] + #[doc = " this value is NULL if MECAB_ONE_BEST mode."] + pub rpath: *mut mecab_path_t, + #[doc = " pointer to the right path."] + #[doc = " this value is NULL if MECAB_ONE_BEST mode."] + pub lpath: *mut mecab_path_t, + #[doc = " surface string."] + #[doc = " this value is not 0 terminated."] + #[doc = " You can get the length with length/rlength members."] + pub surface: *const ::std::os::raw::c_char, + #[doc = " feature string"] + pub feature: *const ::std::os::raw::c_char, + #[doc = " unique node id"] + pub id: ::std::os::raw::c_uint, + #[doc = " length of the surface form."] + pub length: ::std::os::raw::c_ushort, + #[doc = " length of the surface form including white space before the morph."] + pub rlength: ::std::os::raw::c_ushort, + #[doc = " right attribute id"] + pub rcAttr: ::std::os::raw::c_ushort, + #[doc = " left attribute id"] + pub lcAttr: ::std::os::raw::c_ushort, + #[doc = " unique part of speech id. This value is defined in \"pos.def\" file."] + pub posid: ::std::os::raw::c_ushort, + #[doc = " character type"] + pub char_type: ::std::os::raw::c_uchar, + #[doc = " status of this model."] + #[doc = " This value is MECAB_NOR_NODE, MECAB_UNK_NODE, MECAB_BOS_NODE, MECAB_EOS_NODE, or MECAB_EON_NODE."] + pub stat: ::std::os::raw::c_uchar, + #[doc = " set 1 if this node is best node."] + pub isbest: ::std::os::raw::c_uchar, + #[doc = " forward accumulative log summation."] + #[doc = " This value is only available when MECAB_MARGINAL_PROB is passed."] + pub alpha: f32, + #[doc = " backward accumulative log summation."] + #[doc = " This value is only available when MECAB_MARGINAL_PROB is passed."] + pub beta: f32, + #[doc = " marginal probability."] + #[doc = " This value is only available when MECAB_MARGINAL_PROB is passed."] + pub prob: f32, + #[doc = " word cost."] + pub wcost: ::std::os::raw::c_short, + #[doc = " best accumulative cost from bos node to this node."] + pub cost: ::std::os::raw::c_long, +} +#[test] +fn bindgen_test_layout_mecab_node_t() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(mecab_node_t)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(mecab_node_t)) + ); + fn test_field_prev() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(prev) + ) + ); + } + test_field_prev(); + fn test_field_next() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(next) + ) + ); + } + test_field_next(); + fn test_field_enext() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).enext) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(enext) + ) + ); + } + test_field_enext(); + fn test_field_bnext() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).bnext) as usize - ptr as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(bnext) + ) + ); + } + test_field_bnext(); + fn test_field_rpath() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).rpath) as usize - ptr as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(rpath) + ) + ); + } + test_field_rpath(); + fn test_field_lpath() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).lpath) as usize - ptr as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(lpath) + ) + ); + } + test_field_lpath(); + fn test_field_surface() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).surface) as usize - ptr as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(surface) + ) + ); + } + test_field_surface(); + fn test_field_feature() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).feature) as usize - ptr as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(feature) + ) + ); + } + test_field_feature(); + fn test_field_id() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(id) + ) + ); + } + test_field_id(); + fn test_field_length() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize + }, + 68usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(length) + ) + ); + } + test_field_length(); + fn test_field_rlength() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).rlength) as usize - ptr as usize + }, + 70usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(rlength) + ) + ); + } + test_field_rlength(); + fn test_field_rcAttr() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).rcAttr) as usize - ptr as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(rcAttr) + ) + ); + } + test_field_rcAttr(); + fn test_field_lcAttr() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).lcAttr) as usize - ptr as usize + }, + 74usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(lcAttr) + ) + ); + } + test_field_lcAttr(); + fn test_field_posid() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).posid) as usize - ptr as usize + }, + 76usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(posid) + ) + ); + } + test_field_posid(); + fn test_field_char_type() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).char_type) as usize - ptr as usize + }, + 78usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(char_type) + ) + ); + } + test_field_char_type(); + fn test_field_stat() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).stat) as usize - ptr as usize + }, + 79usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(stat) + ) + ); + } + test_field_stat(); + fn test_field_isbest() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).isbest) as usize - ptr as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(isbest) + ) + ); + } + test_field_isbest(); + fn test_field_alpha() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).alpha) as usize - ptr as usize + }, + 84usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(alpha) + ) + ); + } + test_field_alpha(); + fn test_field_beta() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).beta) as usize - ptr as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(beta) + ) + ); + } + test_field_beta(); + fn test_field_prob() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).prob) as usize - ptr as usize + }, + 92usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(prob) + ) + ); + } + test_field_prob(); + fn test_field_wcost() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).wcost) as usize - ptr as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(wcost) + ) + ); + } + test_field_wcost(); + fn test_field_cost() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).cost) as usize - ptr as usize + }, + 100usize, + concat!( + "Offset of field: ", + stringify!(mecab_node_t), + "::", + stringify!(cost) + ) + ); + } + test_field_cost(); +} +pub const MECAB_NOR_NODE: _bindgen_ty_1 = _bindgen_ty_1::MECAB_NOR_NODE; +pub const MECAB_UNK_NODE: _bindgen_ty_1 = _bindgen_ty_1::MECAB_UNK_NODE; +pub const MECAB_BOS_NODE: _bindgen_ty_1 = _bindgen_ty_1::MECAB_BOS_NODE; +pub const MECAB_EOS_NODE: _bindgen_ty_1 = _bindgen_ty_1::MECAB_EOS_NODE; +pub const MECAB_EON_NODE: _bindgen_ty_1 = _bindgen_ty_1::MECAB_EON_NODE; +#[repr(i32)] +#[doc = " Parameters for MeCab::Node::stat"] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _bindgen_ty_1 { + #[doc = " Normal node defined in the dictionary."] + MECAB_NOR_NODE = 0, + #[doc = " Unknown node not defined in the dictionary."] + MECAB_UNK_NODE = 1, + #[doc = " Virtual node representing a beginning of the sentence."] + MECAB_BOS_NODE = 2, + #[doc = " Virtual node representing a end of the sentence."] + MECAB_EOS_NODE = 3, + #[doc = " Virtual node representing a end of the N-best enumeration."] + MECAB_EON_NODE = 4, +} +pub const MECAB_SYS_DIC: _bindgen_ty_2 = _bindgen_ty_2::MECAB_SYS_DIC; +pub const MECAB_USR_DIC: _bindgen_ty_2 = _bindgen_ty_2::MECAB_USR_DIC; +pub const MECAB_UNK_DIC: _bindgen_ty_2 = _bindgen_ty_2::MECAB_UNK_DIC; +#[repr(i32)] +#[doc = " Parameters for MeCab::DictionaryInfo::type"] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _bindgen_ty_2 { + #[doc = " This is a system dictionary."] + MECAB_SYS_DIC = 0, + #[doc = " This is a user dictionary."] + MECAB_USR_DIC = 1, + #[doc = " This is a unknown word dictionary."] + MECAB_UNK_DIC = 2, +} +pub const MECAB_ONE_BEST: _bindgen_ty_3 = _bindgen_ty_3::MECAB_ONE_BEST; +pub const MECAB_NBEST: _bindgen_ty_3 = _bindgen_ty_3::MECAB_NBEST; +pub const MECAB_PARTIAL: _bindgen_ty_3 = _bindgen_ty_3::MECAB_PARTIAL; +pub const MECAB_MARGINAL_PROB: _bindgen_ty_3 = _bindgen_ty_3::MECAB_MARGINAL_PROB; +pub const MECAB_ALTERNATIVE: _bindgen_ty_3 = _bindgen_ty_3::MECAB_ALTERNATIVE; +pub const MECAB_ALL_MORPHS: _bindgen_ty_3 = _bindgen_ty_3::MECAB_ALL_MORPHS; +pub const MECAB_ALLOCATE_SENTENCE: _bindgen_ty_3 = _bindgen_ty_3::MECAB_ALLOCATE_SENTENCE; +#[repr(i32)] +#[doc = " Parameters for MeCab::Lattice::request_type"] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _bindgen_ty_3 { + #[doc = " One best result is obtained (default mode)"] + MECAB_ONE_BEST = 1, + #[doc = " Set this flag if you want to obtain N best results."] + MECAB_NBEST = 2, + #[doc = " Set this flag if you want to enable a partial parsing mode."] + #[doc = " When this flag is set, the input |sentence| needs to be written"] + #[doc = " in partial parsing format."] + MECAB_PARTIAL = 4, + #[doc = " Set this flag if you want to obtain marginal probabilities."] + #[doc = " Marginal probability is set in MeCab::Node::prob."] + #[doc = " The parsing speed will get 3-5 times slower than the default mode."] + MECAB_MARGINAL_PROB = 8, + #[doc = " Set this flag if you want to obtain alternative results."] + #[doc = " Not implemented."] + MECAB_ALTERNATIVE = 16, + #[doc = " When this flag is set, the result linked-list (Node::next/prev)"] + #[doc = " traverses all nodes in the lattice."] + MECAB_ALL_MORPHS = 32, + #[doc = " When this flag is set, tagger internally copies the body of passed"] + #[doc = " sentence into internal buffer."] + MECAB_ALLOCATE_SENTENCE = 64, +} +pub const MECAB_ANY_BOUNDARY: _bindgen_ty_4 = _bindgen_ty_4::MECAB_ANY_BOUNDARY; +pub const MECAB_TOKEN_BOUNDARY: _bindgen_ty_4 = _bindgen_ty_4::MECAB_TOKEN_BOUNDARY; +pub const MECAB_INSIDE_TOKEN: _bindgen_ty_4 = _bindgen_ty_4::MECAB_INSIDE_TOKEN; +#[repr(i32)] +#[doc = " Parameters for MeCab::Lattice::boundary_constraint_type"] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _bindgen_ty_4 { + #[doc = " The token boundary is not specified."] + MECAB_ANY_BOUNDARY = 0, + #[doc = " The position is a strong token boundary."] + MECAB_TOKEN_BOUNDARY = 1, + #[doc = " The position is not a token boundary."] + MECAB_INSIDE_TOKEN = 2, +} pub type va_list = *mut ::std::os::raw::c_char; extern "C" { pub fn __va_start(arg1: *mut va_list, ...); @@ -21621,8813 +22450,8652 @@ extern "C" { extern "C" { pub fn rmtmp() -> ::std::os::raw::c_int; } +pub type std_nullptr_t = *const ::std::os::raw::c_void; +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _EXCEPTION_DISPOSITION { + ExceptionContinueExecution = 0, + ExceptionContinueSearch = 1, + ExceptionNestedException = 2, + ExceptionCollidedUnwind = 3, +} +pub use self::_EXCEPTION_DISPOSITION as EXCEPTION_DISPOSITION; +extern "C" { + pub fn __C_specific_handler( + ExceptionRecord: *mut _EXCEPTION_RECORD, + EstablisherFrame: *mut ::std::os::raw::c_void, + ContextRecord: *mut _CONTEXT, + DispatcherContext: *mut _DISPATCHER_CONTEXT, + ) -> EXCEPTION_DISPOSITION; +} +extern "C" { + pub fn _exception_code() -> ::std::os::raw::c_ulong; +} +extern "C" { + pub fn _exception_info() -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn _abnormal_termination() -> ::std::os::raw::c_int; +} +pub type __gnuc_va_list = __builtin_va_list; +pub type ULONG = ::std::os::raw::c_ulong; +pub type PULONG = *mut ULONG; +pub type USHORT = ::std::os::raw::c_ushort; +pub type PUSHORT = *mut USHORT; +pub type UCHAR = ::std::os::raw::c_uchar; +pub type PUCHAR = *mut UCHAR; +pub type PSZ = *mut ::std::os::raw::c_char; +pub type DWORD = ::std::os::raw::c_ulong; +pub type BOOL = ::std::os::raw::c_int; +pub type BYTE = ::std::os::raw::c_uchar; +pub type WORD = ::std::os::raw::c_ushort; +pub type FLOAT = f32; +pub type PFLOAT = *mut FLOAT; +pub type PBOOL = *mut BOOL; +pub type LPBOOL = *mut BOOL; +pub type PBYTE = *mut BYTE; +pub type LPBYTE = *mut BYTE; +pub type PINT = *mut ::std::os::raw::c_int; +pub type LPINT = *mut ::std::os::raw::c_int; +pub type PWORD = *mut WORD; +pub type LPWORD = *mut WORD; +pub type LPLONG = *mut ::std::os::raw::c_long; +pub type PDWORD = *mut DWORD; +pub type LPDWORD = *mut DWORD; +pub type LPVOID = *mut ::std::os::raw::c_void; +pub type LPCVOID = *const ::std::os::raw::c_void; +pub type INT = ::std::os::raw::c_int; +pub type UINT = ::std::os::raw::c_uint; +pub type PUINT = *mut ::std::os::raw::c_uint; +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 _isctype( + _C: ::std::os::raw::c_int, + _Type: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _isctype_l( + _C: ::std::os::raw::c_int, + _Type: ::std::os::raw::c_int, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn isalpha(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _isalpha_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn isupper(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _isupper_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn islower(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _islower_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn isdigit(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _isdigit_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn isxdigit(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _isxdigit_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn isspace(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _isspace_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn ispunct(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _ispunct_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn isblank(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _isblank_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn isalnum(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _isalnum_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn isprint(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _isprint_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn isgraph(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _isgraph_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn iscntrl(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _iscntrl_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn toupper(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn tolower(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _tolower(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _tolower_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _toupper(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _toupper_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn __isascii(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn __toascii(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn __iscsymf(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn __iscsym(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +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; +} +pub type POINTER_64_INT = ::std::os::raw::c_ulonglong; +pub type INT8 = ::std::os::raw::c_schar; +pub type PINT8 = *mut ::std::os::raw::c_schar; +pub type INT16 = ::std::os::raw::c_short; +pub type PINT16 = *mut ::std::os::raw::c_short; +pub type INT32 = ::std::os::raw::c_int; +pub type PINT32 = *mut ::std::os::raw::c_int; +pub type INT64 = ::std::os::raw::c_longlong; +pub type PINT64 = *mut ::std::os::raw::c_longlong; +pub type UINT8 = ::std::os::raw::c_uchar; +pub type PUINT8 = *mut ::std::os::raw::c_uchar; +pub type UINT16 = ::std::os::raw::c_ushort; +pub type PUINT16 = *mut ::std::os::raw::c_ushort; +pub type UINT32 = ::std::os::raw::c_uint; +pub type PUINT32 = *mut ::std::os::raw::c_uint; +pub type UINT64 = ::std::os::raw::c_ulonglong; +pub type PUINT64 = *mut ::std::os::raw::c_ulonglong; +pub type LONG32 = ::std::os::raw::c_int; +pub type PLONG32 = *mut ::std::os::raw::c_int; +pub type ULONG32 = ::std::os::raw::c_uint; +pub type PULONG32 = *mut ::std::os::raw::c_uint; +pub type DWORD32 = ::std::os::raw::c_uint; +pub type PDWORD32 = *mut ::std::os::raw::c_uint; +pub type INT_PTR = ::std::os::raw::c_longlong; +pub type PINT_PTR = *mut ::std::os::raw::c_longlong; +pub type UINT_PTR = ::std::os::raw::c_ulonglong; +pub type PUINT_PTR = *mut ::std::os::raw::c_ulonglong; +pub type LONG_PTR = ::std::os::raw::c_longlong; +pub type PLONG_PTR = *mut ::std::os::raw::c_longlong; +pub type ULONG_PTR = ::std::os::raw::c_ulonglong; +pub type PULONG_PTR = *mut ::std::os::raw::c_ulonglong; +pub type PHANDLE64 = *mut *mut ::std::os::raw::c_void; +pub type SHANDLE_PTR = ::std::os::raw::c_longlong; +pub type HANDLE_PTR = ::std::os::raw::c_ulonglong; +pub type UHALF_PTR = ::std::os::raw::c_uint; +pub type PUHALF_PTR = *mut ::std::os::raw::c_uint; +pub type HALF_PTR = ::std::os::raw::c_int; +pub type PHALF_PTR = *mut ::std::os::raw::c_int; +pub type SIZE_T = ULONG_PTR; +pub type PSIZE_T = *mut ULONG_PTR; +pub type SSIZE_T = LONG_PTR; +pub type PSSIZE_T = *mut LONG_PTR; +pub type DWORD_PTR = ULONG_PTR; +pub type PDWORD_PTR = *mut ULONG_PTR; +pub type LONG64 = ::std::os::raw::c_longlong; +pub type PLONG64 = *mut ::std::os::raw::c_longlong; +pub type ULONG64 = ::std::os::raw::c_ulonglong; +pub type PULONG64 = *mut ::std::os::raw::c_ulonglong; +pub type DWORD64 = ::std::os::raw::c_ulonglong; +pub type PDWORD64 = *mut ::std::os::raw::c_ulonglong; +pub type KAFFINITY = ULONG_PTR; +pub type PKAFFINITY = *mut KAFFINITY; +pub type PVOID = *mut ::std::os::raw::c_void; +pub type CHAR = ::std::os::raw::c_char; +pub type SHORT = ::std::os::raw::c_short; +pub type LONG = ::std::os::raw::c_long; +pub type WCHAR = u16; +pub type PWCHAR = *mut WCHAR; +pub type LPWCH = *mut WCHAR; +pub type PWCH = *mut WCHAR; +pub type LPCWCH = *const WCHAR; +pub type PCWCH = *const WCHAR; +pub type NWPSTR = *mut WCHAR; +pub type LPWSTR = *mut WCHAR; +pub type PWSTR = *mut WCHAR; +pub type PZPWSTR = *mut PWSTR; +pub type PCZPWSTR = *const PWSTR; +pub type LPUWSTR = *mut WCHAR; +pub type PUWSTR = *mut WCHAR; +pub type LPCWSTR = *const WCHAR; +pub type PCWSTR = *const WCHAR; +pub type PZPCWSTR = *mut PCWSTR; +pub type PCZPCWSTR = *const PCWSTR; +pub type LPCUWSTR = *const WCHAR; +pub type PCUWSTR = *const WCHAR; +pub type PZZWSTR = *mut WCHAR; +pub type PCZZWSTR = *const WCHAR; +pub type PUZZWSTR = *mut WCHAR; +pub type PCUZZWSTR = *const WCHAR; +pub type PNZWCH = *mut WCHAR; +pub type PCNZWCH = *const WCHAR; +pub type PUNZWCH = *mut WCHAR; +pub type PCUNZWCH = *const WCHAR; +pub type LPCWCHAR = *const WCHAR; +pub type PCWCHAR = *const WCHAR; +pub type LPCUWCHAR = *const WCHAR; +pub type PCUWCHAR = *const WCHAR; +pub type UCSCHAR = ::std::os::raw::c_ulong; +pub type PUCSCHAR = *mut UCSCHAR; +pub type PCUCSCHAR = *const UCSCHAR; +pub type PUCSSTR = *mut UCSCHAR; +pub type PUUCSSTR = *mut UCSCHAR; +pub type PCUCSSTR = *const UCSCHAR; +pub type PCUUCSSTR = *const UCSCHAR; +pub type PUUCSCHAR = *mut UCSCHAR; +pub type PCUUCSCHAR = *const UCSCHAR; +pub type PCHAR = *mut CHAR; +pub type LPCH = *mut CHAR; +pub type PCH = *mut CHAR; +pub type LPCCH = *const CHAR; +pub type PCCH = *const CHAR; +pub type NPSTR = *mut CHAR; +pub type LPSTR = *mut CHAR; +pub type PSTR = *mut CHAR; +pub type PZPSTR = *mut PSTR; +pub type PCZPSTR = *const PSTR; +pub type LPCSTR = *const CHAR; +pub type PCSTR = *const CHAR; +pub type PZPCSTR = *mut PCSTR; +pub type PCZPCSTR = *const PCSTR; +pub type PZZSTR = *mut CHAR; +pub type PCZZSTR = *const CHAR; +pub type PNZCH = *mut CHAR; +pub type PCNZCH = *const CHAR; +pub type TCHAR = ::std::os::raw::c_char; +pub type PTCHAR = *mut ::std::os::raw::c_char; +pub type TBYTE = ::std::os::raw::c_uchar; +pub type PTBYTE = *mut ::std::os::raw::c_uchar; +pub type LPTCH = LPCH; +pub type PTCH = LPCH; +pub type LPCTCH = LPCCH; +pub type PCTCH = LPCCH; +pub type PTSTR = LPSTR; +pub type LPTSTR = LPSTR; +pub type PUTSTR = LPSTR; +pub type LPUTSTR = LPSTR; +pub type PCTSTR = LPCSTR; +pub type LPCTSTR = LPCSTR; +pub type PCUTSTR = LPCSTR; +pub type LPCUTSTR = LPCSTR; +pub type PZZTSTR = PZZSTR; +pub type PUZZTSTR = PZZSTR; +pub type PCZZTSTR = PCZZSTR; +pub type PCUZZTSTR = PCZZSTR; +pub type PZPTSTR = PZPSTR; +pub type PNZTCH = PNZCH; +pub type PUNZTCH = PNZCH; +pub type PCNZTCH = PCNZCH; +pub type PCUNZTCH = PCNZCH; +pub type PSHORT = *mut SHORT; +pub type PLONG = *mut LONG; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _JPCommonLabelPhoneme { - pub phoneme: *mut ::std::os::raw::c_char, - pub prev: *mut _JPCommonLabelPhoneme, - pub next: *mut _JPCommonLabelPhoneme, - pub up: *mut _JPCommonLabelMora, +pub struct _PROCESSOR_NUMBER { + pub Group: WORD, + pub Number: BYTE, + pub Reserved: BYTE, } #[test] -fn bindgen_test_layout__JPCommonLabelPhoneme() { +fn bindgen_test_layout__PROCESSOR_NUMBER() { assert_eq!( - ::std::mem::size_of::<_JPCommonLabelPhoneme>(), - 32usize, - concat!("Size of: ", stringify!(_JPCommonLabelPhoneme)) + ::std::mem::size_of::<_PROCESSOR_NUMBER>(), + 4usize, + concat!("Size of: ", stringify!(_PROCESSOR_NUMBER)) ); assert_eq!( - ::std::mem::align_of::<_JPCommonLabelPhoneme>(), - 8usize, - concat!("Alignment of ", stringify!(_JPCommonLabelPhoneme)) + ::std::mem::align_of::<_PROCESSOR_NUMBER>(), + 2usize, + concat!("Alignment of ", stringify!(_PROCESSOR_NUMBER)) ); - fn test_field_phoneme() { + fn test_field_Group() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelPhoneme>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_PROCESSOR_NUMBER>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).phoneme) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Group) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelPhoneme), - "::", - stringify!(phoneme) - ) - ); - } - test_field_phoneme(); - fn test_field_prev() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelPhoneme>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(_JPCommonLabelPhoneme), + stringify!(_PROCESSOR_NUMBER), "::", - stringify!(prev) + stringify!(Group) ) ); } - test_field_prev(); - fn test_field_next() { + test_field_Group(); + fn test_field_Number() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelPhoneme>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_PROCESSOR_NUMBER>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Number) as usize - ptr as usize }, - 16usize, + 2usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelPhoneme), + stringify!(_PROCESSOR_NUMBER), "::", - stringify!(next) + stringify!(Number) ) ); } - test_field_next(); - fn test_field_up() { + test_field_Number(); + fn test_field_Reserved() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelPhoneme>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_PROCESSOR_NUMBER>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).up) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize }, - 24usize, + 3usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelPhoneme), + stringify!(_PROCESSOR_NUMBER), "::", - stringify!(up) + stringify!(Reserved) ) ); } - test_field_up(); + test_field_Reserved(); } -pub type JPCommonLabelPhoneme = _JPCommonLabelPhoneme; +pub type PROCESSOR_NUMBER = _PROCESSOR_NUMBER; +pub type PPROCESSOR_NUMBER = *mut _PROCESSOR_NUMBER; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _JPCommonLabelMora { - pub mora: *mut ::std::os::raw::c_char, - pub head: *mut _JPCommonLabelPhoneme, - pub tail: *mut _JPCommonLabelPhoneme, - pub prev: *mut _JPCommonLabelMora, - pub next: *mut _JPCommonLabelMora, - pub up: *mut _JPCommonLabelWord, +pub struct _GROUP_AFFINITY { + pub Mask: KAFFINITY, + pub Group: WORD, + pub Reserved: [WORD; 3usize], } #[test] -fn bindgen_test_layout__JPCommonLabelMora() { +fn bindgen_test_layout__GROUP_AFFINITY() { assert_eq!( - ::std::mem::size_of::<_JPCommonLabelMora>(), - 48usize, - concat!("Size of: ", stringify!(_JPCommonLabelMora)) + ::std::mem::size_of::<_GROUP_AFFINITY>(), + 16usize, + concat!("Size of: ", stringify!(_GROUP_AFFINITY)) ); assert_eq!( - ::std::mem::align_of::<_JPCommonLabelMora>(), + ::std::mem::align_of::<_GROUP_AFFINITY>(), 8usize, - concat!("Alignment of ", stringify!(_JPCommonLabelMora)) + concat!("Alignment of ", stringify!(_GROUP_AFFINITY)) ); - fn test_field_mora() { + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelMora>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_GROUP_AFFINITY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).mora) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelMora), + stringify!(_GROUP_AFFINITY), "::", - stringify!(mora) + stringify!(Mask) ) ); } - test_field_mora(); - fn test_field_head() { + test_field_Mask(); + fn test_field_Group() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelMora>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_GROUP_AFFINITY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).head) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Group) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelMora), - "::", - stringify!(head) - ) - ); - } - test_field_head(); - fn test_field_tail() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelMora>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).tail) as usize - ptr as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(_JPCommonLabelMora), + stringify!(_GROUP_AFFINITY), "::", - stringify!(tail) + stringify!(Group) ) ); } - test_field_tail(); - fn test_field_prev() { + test_field_Group(); + fn test_field_Reserved() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelMora>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_GROUP_AFFINITY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize }, - 24usize, + 10usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelMora), + stringify!(_GROUP_AFFINITY), "::", - stringify!(prev) + stringify!(Reserved) ) ); } - test_field_prev(); - fn test_field_next() { + test_field_Reserved(); +} +pub type GROUP_AFFINITY = _GROUP_AFFINITY; +pub type PGROUP_AFFINITY = *mut _GROUP_AFFINITY; +pub type HANDLE = *mut ::std::os::raw::c_void; +pub type PHANDLE = *mut HANDLE; +pub type FCHAR = BYTE; +pub type FSHORT = WORD; +pub type FLONG = DWORD; +pub type HRESULT = ::std::os::raw::c_long; +pub type CCHAR = ::std::os::raw::c_char; +pub type LCID = DWORD; +pub type PLCID = PDWORD; +pub type LANGID = WORD; +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum COMPARTMENT_ID { + UNSPECIFIED_COMPARTMENT_ID = 0, + DEFAULT_COMPARTMENT_ID = 1, +} +pub type PCOMPARTMENT_ID = *mut COMPARTMENT_ID; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _FLOAT128 { + pub LowPart: ::std::os::raw::c_longlong, + pub HighPart: ::std::os::raw::c_longlong, +} +#[test] +fn bindgen_test_layout__FLOAT128() { + assert_eq!( + ::std::mem::size_of::<_FLOAT128>(), + 16usize, + concat!("Size of: ", stringify!(_FLOAT128)) + ); + assert_eq!( + ::std::mem::align_of::<_FLOAT128>(), + 8usize, + concat!("Alignment of ", stringify!(_FLOAT128)) + ); + fn test_field_LowPart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelMora>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_FLOAT128>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).LowPart) as usize - ptr as usize }, - 32usize, + 0usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelMora), + stringify!(_FLOAT128), "::", - stringify!(next) + stringify!(LowPart) ) ); } - test_field_next(); - fn test_field_up() { + test_field_LowPart(); + fn test_field_HighPart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelMora>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_FLOAT128>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).up) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).HighPart) as usize - ptr as usize }, - 40usize, + 8usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelMora), + stringify!(_FLOAT128), "::", - stringify!(up) + stringify!(HighPart) ) ); } - test_field_up(); + test_field_HighPart(); +} +pub type FLOAT128 = _FLOAT128; +pub type PFLOAT128 = *mut FLOAT128; +pub type LONGLONG = ::std::os::raw::c_longlong; +pub type ULONGLONG = ::std::os::raw::c_ulonglong; +pub type PLONGLONG = *mut LONGLONG; +pub type PULONGLONG = *mut ULONGLONG; +pub type USN = LONGLONG; +#[repr(C)] +#[derive(Copy, Clone)] +pub union _LARGE_INTEGER { + pub __bindgen_anon_1: _LARGE_INTEGER__bindgen_ty_1, + pub u: _LARGE_INTEGER__bindgen_ty_2, + pub QuadPart: LONGLONG, } -pub type JPCommonLabelMora = _JPCommonLabelMora; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _JPCommonLabelWord { - pub pron: *mut ::std::os::raw::c_char, - pub pos: *mut ::std::os::raw::c_char, - pub ctype: *mut ::std::os::raw::c_char, - pub cform: *mut ::std::os::raw::c_char, - pub head: *mut _JPCommonLabelMora, - pub tail: *mut _JPCommonLabelMora, - pub prev: *mut _JPCommonLabelWord, - pub next: *mut _JPCommonLabelWord, - pub up: *mut _JPCommonLabelAccentPhrase, +pub struct _LARGE_INTEGER__bindgen_ty_1 { + pub LowPart: DWORD, + pub HighPart: LONG, } #[test] -fn bindgen_test_layout__JPCommonLabelWord() { +fn bindgen_test_layout__LARGE_INTEGER__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_JPCommonLabelWord>(), - 72usize, - concat!("Size of: ", stringify!(_JPCommonLabelWord)) + ::std::mem::size_of::<_LARGE_INTEGER__bindgen_ty_1>(), + 8usize, + concat!("Size of: ", stringify!(_LARGE_INTEGER__bindgen_ty_1)) ); assert_eq!( - ::std::mem::align_of::<_JPCommonLabelWord>(), - 8usize, - concat!("Alignment of ", stringify!(_JPCommonLabelWord)) + ::std::mem::align_of::<_LARGE_INTEGER__bindgen_ty_1>(), + 4usize, + concat!("Alignment of ", stringify!(_LARGE_INTEGER__bindgen_ty_1)) ); - fn test_field_pron() { + fn test_field_LowPart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelWord>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_LARGE_INTEGER__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).pron) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).LowPart) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelWord), - "::", - stringify!(pron) - ) - ); - } - test_field_pron(); - fn test_field_pos() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelWord>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).pos) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(_JPCommonLabelWord), + stringify!(_LARGE_INTEGER__bindgen_ty_1), "::", - stringify!(pos) + stringify!(LowPart) ) ); } - test_field_pos(); - fn test_field_ctype() { + test_field_LowPart(); + fn test_field_HighPart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelWord>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_LARGE_INTEGER__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ctype) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).HighPart) as usize - ptr as usize }, - 16usize, + 4usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelWord), + stringify!(_LARGE_INTEGER__bindgen_ty_1), "::", - stringify!(ctype) + stringify!(HighPart) ) ); } - test_field_ctype(); - fn test_field_cform() { + test_field_HighPart(); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _LARGE_INTEGER__bindgen_ty_2 { + pub LowPart: DWORD, + pub HighPart: LONG, +} +#[test] +fn bindgen_test_layout__LARGE_INTEGER__bindgen_ty_2() { + assert_eq!( + ::std::mem::size_of::<_LARGE_INTEGER__bindgen_ty_2>(), + 8usize, + concat!("Size of: ", stringify!(_LARGE_INTEGER__bindgen_ty_2)) + ); + assert_eq!( + ::std::mem::align_of::<_LARGE_INTEGER__bindgen_ty_2>(), + 4usize, + concat!("Alignment of ", stringify!(_LARGE_INTEGER__bindgen_ty_2)) + ); + fn test_field_LowPart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelWord>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_LARGE_INTEGER__bindgen_ty_2>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).cform) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).LowPart) as usize - ptr as usize }, - 24usize, + 0usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelWord), + stringify!(_LARGE_INTEGER__bindgen_ty_2), "::", - stringify!(cform) + stringify!(LowPart) ) ); } - test_field_cform(); - fn test_field_head() { + test_field_LowPart(); + fn test_field_HighPart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelWord>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_LARGE_INTEGER__bindgen_ty_2>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).head) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).HighPart) as usize - ptr as usize }, - 32usize, + 4usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelWord), + stringify!(_LARGE_INTEGER__bindgen_ty_2), "::", - stringify!(head) + stringify!(HighPart) ) ); } - test_field_head(); - fn test_field_tail() { + test_field_HighPart(); +} +#[test] +fn bindgen_test_layout__LARGE_INTEGER() { + assert_eq!( + ::std::mem::size_of::<_LARGE_INTEGER>(), + 8usize, + concat!("Size of: ", stringify!(_LARGE_INTEGER)) + ); + assert_eq!( + ::std::mem::align_of::<_LARGE_INTEGER>(), + 8usize, + concat!("Alignment of ", stringify!(_LARGE_INTEGER)) + ); + fn test_field_u() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelWord>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_LARGE_INTEGER>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).tail) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize }, - 40usize, + 0usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelWord), + stringify!(_LARGE_INTEGER), "::", - stringify!(tail) + stringify!(u) ) ); } - test_field_tail(); - fn test_field_prev() { + test_field_u(); + fn test_field_QuadPart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelWord>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_LARGE_INTEGER>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).QuadPart) as usize - ptr as usize }, - 48usize, + 0usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelWord), + stringify!(_LARGE_INTEGER), "::", - stringify!(prev) + stringify!(QuadPart) ) ); } - test_field_prev(); - fn test_field_next() { + test_field_QuadPart(); +} +pub type LARGE_INTEGER = _LARGE_INTEGER; +pub type PLARGE_INTEGER = *mut LARGE_INTEGER; +#[repr(C)] +#[derive(Copy, Clone)] +pub union _ULARGE_INTEGER { + pub __bindgen_anon_1: _ULARGE_INTEGER__bindgen_ty_1, + pub u: _ULARGE_INTEGER__bindgen_ty_2, + pub QuadPart: ULONGLONG, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _ULARGE_INTEGER__bindgen_ty_1 { + pub LowPart: DWORD, + pub HighPart: DWORD, +} +#[test] +fn bindgen_test_layout__ULARGE_INTEGER__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<_ULARGE_INTEGER__bindgen_ty_1>(), + 8usize, + concat!("Size of: ", stringify!(_ULARGE_INTEGER__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::<_ULARGE_INTEGER__bindgen_ty_1>(), + 4usize, + concat!("Alignment of ", stringify!(_ULARGE_INTEGER__bindgen_ty_1)) + ); + fn test_field_LowPart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelWord>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ULARGE_INTEGER__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).LowPart) as usize - ptr as usize }, - 56usize, + 0usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelWord), + stringify!(_ULARGE_INTEGER__bindgen_ty_1), "::", - stringify!(next) + stringify!(LowPart) ) ); } - test_field_next(); - fn test_field_up() { + test_field_LowPart(); + fn test_field_HighPart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelWord>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ULARGE_INTEGER__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).up) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).HighPart) as usize - ptr as usize }, - 64usize, + 4usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelWord), + stringify!(_ULARGE_INTEGER__bindgen_ty_1), "::", - stringify!(up) + stringify!(HighPart) ) ); } - test_field_up(); + test_field_HighPart(); } -pub type JPCommonLabelWord = _JPCommonLabelWord; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _JPCommonLabelAccentPhrase { - pub accent: ::std::os::raw::c_int, - pub emotion: *mut ::std::os::raw::c_char, - pub head: *mut _JPCommonLabelWord, - pub tail: *mut _JPCommonLabelWord, - pub prev: *mut _JPCommonLabelAccentPhrase, - pub next: *mut _JPCommonLabelAccentPhrase, - pub up: *mut _JPCommonLabelBreathGroup, +pub struct _ULARGE_INTEGER__bindgen_ty_2 { + pub LowPart: DWORD, + pub HighPart: DWORD, } #[test] -fn bindgen_test_layout__JPCommonLabelAccentPhrase() { +fn bindgen_test_layout__ULARGE_INTEGER__bindgen_ty_2() { assert_eq!( - ::std::mem::size_of::<_JPCommonLabelAccentPhrase>(), - 56usize, - concat!("Size of: ", stringify!(_JPCommonLabelAccentPhrase)) + ::std::mem::size_of::<_ULARGE_INTEGER__bindgen_ty_2>(), + 8usize, + concat!("Size of: ", stringify!(_ULARGE_INTEGER__bindgen_ty_2)) ); assert_eq!( - ::std::mem::align_of::<_JPCommonLabelAccentPhrase>(), - 8usize, - concat!("Alignment of ", stringify!(_JPCommonLabelAccentPhrase)) + ::std::mem::align_of::<_ULARGE_INTEGER__bindgen_ty_2>(), + 4usize, + concat!("Alignment of ", stringify!(_ULARGE_INTEGER__bindgen_ty_2)) ); - fn test_field_accent() { + fn test_field_LowPart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelAccentPhrase>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ULARGE_INTEGER__bindgen_ty_2>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).accent) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).LowPart) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelAccentPhrase), + stringify!(_ULARGE_INTEGER__bindgen_ty_2), "::", - stringify!(accent) + stringify!(LowPart) ) ); } - test_field_accent(); - fn test_field_emotion() { + test_field_LowPart(); + fn test_field_HighPart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelAccentPhrase>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ULARGE_INTEGER__bindgen_ty_2>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).emotion) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).HighPart) as usize - ptr as usize }, - 8usize, + 4usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelAccentPhrase), + stringify!(_ULARGE_INTEGER__bindgen_ty_2), "::", - stringify!(emotion) + stringify!(HighPart) ) ); } - test_field_emotion(); - fn test_field_head() { + test_field_HighPart(); +} +#[test] +fn bindgen_test_layout__ULARGE_INTEGER() { + assert_eq!( + ::std::mem::size_of::<_ULARGE_INTEGER>(), + 8usize, + concat!("Size of: ", stringify!(_ULARGE_INTEGER)) + ); + assert_eq!( + ::std::mem::align_of::<_ULARGE_INTEGER>(), + 8usize, + concat!("Alignment of ", stringify!(_ULARGE_INTEGER)) + ); + fn test_field_u() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelAccentPhrase>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ULARGE_INTEGER>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).head) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize }, - 16usize, + 0usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelAccentPhrase), + stringify!(_ULARGE_INTEGER), "::", - stringify!(head) + stringify!(u) ) ); } - test_field_head(); - fn test_field_tail() { + test_field_u(); + fn test_field_QuadPart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelAccentPhrase>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ULARGE_INTEGER>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).tail) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).QuadPart) as usize - ptr as usize }, - 24usize, + 0usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelAccentPhrase), + stringify!(_ULARGE_INTEGER), "::", - stringify!(tail) + stringify!(QuadPart) ) ); } - test_field_tail(); - fn test_field_prev() { + test_field_QuadPart(); +} +pub type ULARGE_INTEGER = _ULARGE_INTEGER; +pub type PULARGE_INTEGER = *mut ULARGE_INTEGER; +pub type RTL_REFERENCE_COUNT = LONG_PTR; +pub type PRTL_REFERENCE_COUNT = *mut LONG_PTR; +pub type RTL_REFERENCE_COUNT32 = LONG; +pub type PRTL_REFERENCE_COUNT32 = *mut LONG; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _LUID { + pub LowPart: DWORD, + pub HighPart: LONG, +} +#[test] +fn bindgen_test_layout__LUID() { + assert_eq!( + ::std::mem::size_of::<_LUID>(), + 8usize, + concat!("Size of: ", stringify!(_LUID)) + ); + assert_eq!( + ::std::mem::align_of::<_LUID>(), + 4usize, + concat!("Alignment of ", stringify!(_LUID)) + ); + fn test_field_LowPart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelAccentPhrase>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_LUID>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).LowPart) as usize - ptr as usize }, - 32usize, + 0usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelAccentPhrase), + stringify!(_LUID), "::", - stringify!(prev) - ) - ); - } - test_field_prev(); - fn test_field_next() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelAccentPhrase>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(_JPCommonLabelAccentPhrase), - "::", - stringify!(next) + stringify!(LowPart) ) ); } - test_field_next(); - fn test_field_up() { + test_field_LowPart(); + fn test_field_HighPart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelAccentPhrase>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_LUID>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).up) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).HighPart) as usize - ptr as usize }, - 48usize, + 4usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelAccentPhrase), + stringify!(_LUID), "::", - stringify!(up) + stringify!(HighPart) ) ); } - test_field_up(); + test_field_HighPart(); } -pub type JPCommonLabelAccentPhrase = _JPCommonLabelAccentPhrase; +pub type LUID = _LUID; +pub type PLUID = *mut _LUID; +pub type DWORDLONG = ULONGLONG; +pub type PDWORDLONG = *mut DWORDLONG; +extern "C" { + pub fn _rotl8( + Value: ::std::os::raw::c_uchar, + Shift: ::std::os::raw::c_uchar, + ) -> ::std::os::raw::c_uchar; +} +extern "C" { + pub fn _rotl16( + Value: ::std::os::raw::c_ushort, + Shift: ::std::os::raw::c_uchar, + ) -> ::std::os::raw::c_ushort; +} +extern "C" { + pub fn _rotr8( + Value: ::std::os::raw::c_uchar, + Shift: ::std::os::raw::c_uchar, + ) -> ::std::os::raw::c_uchar; +} +extern "C" { + pub fn _rotr16( + Value: ::std::os::raw::c_ushort, + Shift: ::std::os::raw::c_uchar, + ) -> ::std::os::raw::c_ushort; +} +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 _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 _rotr64( + Value: ::std::os::raw::c_ulonglong, + Shift: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_ulonglong; +} +pub type BOOLEAN = BYTE; +pub type PBOOLEAN = *mut BOOLEAN; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _JPCommonLabelBreathGroup { - pub head: *mut _JPCommonLabelAccentPhrase, - pub tail: *mut _JPCommonLabelAccentPhrase, - pub prev: *mut _JPCommonLabelBreathGroup, - pub next: *mut _JPCommonLabelBreathGroup, +pub struct _LIST_ENTRY { + pub Flink: *mut _LIST_ENTRY, + pub Blink: *mut _LIST_ENTRY, } #[test] -fn bindgen_test_layout__JPCommonLabelBreathGroup() { +fn bindgen_test_layout__LIST_ENTRY() { assert_eq!( - ::std::mem::size_of::<_JPCommonLabelBreathGroup>(), - 32usize, - concat!("Size of: ", stringify!(_JPCommonLabelBreathGroup)) + ::std::mem::size_of::<_LIST_ENTRY>(), + 16usize, + concat!("Size of: ", stringify!(_LIST_ENTRY)) ); assert_eq!( - ::std::mem::align_of::<_JPCommonLabelBreathGroup>(), + ::std::mem::align_of::<_LIST_ENTRY>(), 8usize, - concat!("Alignment of ", stringify!(_JPCommonLabelBreathGroup)) + concat!("Alignment of ", stringify!(_LIST_ENTRY)) ); - fn test_field_head() { + fn test_field_Flink() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelBreathGroup>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_LIST_ENTRY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).head) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flink) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelBreathGroup), + stringify!(_LIST_ENTRY), "::", - stringify!(head) + stringify!(Flink) ) ); } - test_field_head(); - fn test_field_tail() { + test_field_Flink(); + fn test_field_Blink() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelBreathGroup>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_LIST_ENTRY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).tail) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Blink) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabelBreathGroup), - "::", - stringify!(tail) - ) - ); - } - test_field_tail(); - fn test_field_prev() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelBreathGroup>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(_JPCommonLabelBreathGroup), - "::", - stringify!(prev) - ) - ); - } - test_field_prev(); - fn test_field_next() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelBreathGroup>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(_JPCommonLabelBreathGroup), + stringify!(_LIST_ENTRY), "::", - stringify!(next) + stringify!(Blink) ) ); } - test_field_next(); + test_field_Blink(); } -pub type JPCommonLabelBreathGroup = _JPCommonLabelBreathGroup; +pub type LIST_ENTRY = _LIST_ENTRY; +pub type PLIST_ENTRY = *mut _LIST_ENTRY; +pub type PRLIST_ENTRY = *mut _LIST_ENTRY; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _JPCommonLabel { - pub size: ::std::os::raw::c_int, - pub feature: *mut *mut ::std::os::raw::c_char, - pub breath_head: *mut JPCommonLabelBreathGroup, - pub breath_tail: *mut JPCommonLabelBreathGroup, - pub accent_head: *mut JPCommonLabelAccentPhrase, - pub accent_tail: *mut JPCommonLabelAccentPhrase, - pub word_head: *mut JPCommonLabelWord, - pub word_tail: *mut JPCommonLabelWord, - pub mora_head: *mut JPCommonLabelMora, - pub mora_tail: *mut JPCommonLabelMora, - pub phoneme_head: *mut JPCommonLabelPhoneme, - pub phoneme_tail: *mut JPCommonLabelPhoneme, - pub short_pause_flag: ::std::os::raw::c_int, +pub struct _SINGLE_LIST_ENTRY { + pub Next: *mut _SINGLE_LIST_ENTRY, } #[test] -fn bindgen_test_layout__JPCommonLabel() { +fn bindgen_test_layout__SINGLE_LIST_ENTRY() { assert_eq!( - ::std::mem::size_of::<_JPCommonLabel>(), - 104usize, - concat!("Size of: ", stringify!(_JPCommonLabel)) + ::std::mem::size_of::<_SINGLE_LIST_ENTRY>(), + 8usize, + concat!("Size of: ", stringify!(_SINGLE_LIST_ENTRY)) ); assert_eq!( - ::std::mem::align_of::<_JPCommonLabel>(), + ::std::mem::align_of::<_SINGLE_LIST_ENTRY>(), 8usize, - concat!("Alignment of ", stringify!(_JPCommonLabel)) + concat!("Alignment of ", stringify!(_SINGLE_LIST_ENTRY)) ); - fn test_field_size() { + fn test_field_Next() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SINGLE_LIST_ENTRY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Next) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabel), - "::", - stringify!(size) - ) - ); - } - test_field_size(); - fn test_field_feature() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).feature) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(_JPCommonLabel), - "::", - stringify!(feature) - ) - ); - } - test_field_feature(); - fn test_field_breath_head() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).breath_head) as usize - ptr as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(_JPCommonLabel), - "::", - stringify!(breath_head) - ) - ); - } - test_field_breath_head(); - fn test_field_breath_tail() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).breath_tail) as usize - ptr as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(_JPCommonLabel), - "::", - stringify!(breath_tail) - ) - ); - } - test_field_breath_tail(); - fn test_field_accent_head() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).accent_head) as usize - ptr as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(_JPCommonLabel), + stringify!(_SINGLE_LIST_ENTRY), "::", - stringify!(accent_head) + stringify!(Next) ) ); } - test_field_accent_head(); - fn test_field_accent_tail() { + test_field_Next(); +} +pub type SINGLE_LIST_ENTRY = _SINGLE_LIST_ENTRY; +pub type PSINGLE_LIST_ENTRY = *mut _SINGLE_LIST_ENTRY; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LIST_ENTRY32 { + pub Flink: DWORD, + pub Blink: DWORD, +} +#[test] +fn bindgen_test_layout_LIST_ENTRY32() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(LIST_ENTRY32)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(LIST_ENTRY32)) + ); + fn test_field_Flink() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); + let uninit = ::std::mem::MaybeUninit::::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).accent_tail) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flink) as usize - ptr as usize }, - 40usize, + 0usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabel), + stringify!(LIST_ENTRY32), "::", - stringify!(accent_tail) + stringify!(Flink) ) ); } - test_field_accent_tail(); - fn test_field_word_head() { + test_field_Flink(); + fn test_field_Blink() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); + let uninit = ::std::mem::MaybeUninit::::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).word_head) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Blink) as usize - ptr as usize }, - 48usize, + 4usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabel), + stringify!(LIST_ENTRY32), "::", - stringify!(word_head) + stringify!(Blink) ) ); } - test_field_word_head(); - fn test_field_word_tail() { + test_field_Blink(); +} +pub type PLIST_ENTRY32 = *mut LIST_ENTRY32; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LIST_ENTRY64 { + pub Flink: ULONGLONG, + pub Blink: ULONGLONG, +} +#[test] +fn bindgen_test_layout_LIST_ENTRY64() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(LIST_ENTRY64)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(LIST_ENTRY64)) + ); + fn test_field_Flink() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); + let uninit = ::std::mem::MaybeUninit::::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).word_tail) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flink) as usize - ptr as usize }, - 56usize, + 0usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabel), + stringify!(LIST_ENTRY64), "::", - stringify!(word_tail) + stringify!(Flink) ) ); } - test_field_word_tail(); - fn test_field_mora_head() { + test_field_Flink(); + fn test_field_Blink() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); + let uninit = ::std::mem::MaybeUninit::::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).mora_head) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Blink) as usize - ptr as usize }, - 64usize, + 8usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabel), + stringify!(LIST_ENTRY64), "::", - stringify!(mora_head) + stringify!(Blink) ) ); } - test_field_mora_head(); - fn test_field_mora_tail() { + test_field_Blink(); +} +pub type PLIST_ENTRY64 = *mut LIST_ENTRY64; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _GUID { + pub Data1: ::std::os::raw::c_ulong, + pub Data2: ::std::os::raw::c_ushort, + pub Data3: ::std::os::raw::c_ushort, + pub Data4: [::std::os::raw::c_uchar; 8usize], +} +#[test] +fn bindgen_test_layout__GUID() { + assert_eq!( + ::std::mem::size_of::<_GUID>(), + 16usize, + concat!("Size of: ", stringify!(_GUID)) + ); + assert_eq!( + ::std::mem::align_of::<_GUID>(), + 4usize, + concat!("Alignment of ", stringify!(_GUID)) + ); + fn test_field_Data1() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_GUID>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).mora_tail) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Data1) as usize - ptr as usize }, - 72usize, + 0usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabel), + stringify!(_GUID), "::", - stringify!(mora_tail) + stringify!(Data1) ) ); } - test_field_mora_tail(); - fn test_field_phoneme_head() { + test_field_Data1(); + fn test_field_Data2() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_GUID>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).phoneme_head) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Data2) as usize - ptr as usize }, - 80usize, + 4usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabel), + stringify!(_GUID), "::", - stringify!(phoneme_head) + stringify!(Data2) ) ); } - test_field_phoneme_head(); - fn test_field_phoneme_tail() { + test_field_Data2(); + fn test_field_Data3() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_GUID>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).phoneme_tail) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Data3) as usize - ptr as usize }, - 88usize, + 6usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabel), + stringify!(_GUID), "::", - stringify!(phoneme_tail) + stringify!(Data3) ) ); } - test_field_phoneme_tail(); - fn test_field_short_pause_flag() { + test_field_Data3(); + fn test_field_Data4() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_GUID>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).short_pause_flag) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Data4) as usize - ptr as usize }, - 96usize, + 8usize, concat!( "Offset of field: ", - stringify!(_JPCommonLabel), + stringify!(_GUID), "::", - stringify!(short_pause_flag) + stringify!(Data4) ) ); } - test_field_short_pause_flag(); + test_field_Data4(); } -pub type JPCommonLabel = _JPCommonLabel; +pub type GUID = _GUID; +pub type LPGUID = *mut GUID; +pub type LPCGUID = *const GUID; +pub type IID = GUID; +pub type LPIID = *mut IID; +pub type CLSID = GUID; +pub type LPCLSID = *mut CLSID; +pub type FMTID = GUID; +pub type LPFMTID = *mut FMTID; extern "C" { - pub fn JPCommonLabel_initialize(label: *mut JPCommonLabel); + pub fn _errno() -> *mut ::std::os::raw::c_int; } extern "C" { - pub fn JPCommonLabel_push_word( - label: *mut JPCommonLabel, - pron: *const ::std::os::raw::c_char, - pos: *const ::std::os::raw::c_char, - ctype: *const ::std::os::raw::c_char, - cform: *const ::std::os::raw::c_char, - acc: ::std::os::raw::c_int, - chain_flag: ::std::os::raw::c_int, - ); + pub fn _set_errno(_Value: ::std::os::raw::c_int) -> errno_t; } extern "C" { - pub fn JPCommonLabel_make(label: *mut JPCommonLabel); + pub fn _get_errno(_Value: *mut ::std::os::raw::c_int) -> errno_t; } extern "C" { - pub fn JPCommonLabel_get_size(label: *mut JPCommonLabel) -> ::std::os::raw::c_int; + pub fn __doserrno() -> *mut ::std::os::raw::c_ulong; } extern "C" { - pub fn JPCommonLabel_get_feature(label: *mut JPCommonLabel) - -> *mut *mut ::std::os::raw::c_char; + pub fn _set_doserrno(_Value: ::std::os::raw::c_ulong) -> errno_t; } extern "C" { - pub fn JPCommonLabel_print(label: *mut JPCommonLabel); + pub fn _get_doserrno(_Value: *mut ::std::os::raw::c_ulong) -> errno_t; } extern "C" { - pub fn JPCommonLabel_fprint(label: *mut JPCommonLabel, fp: *mut FILE); + pub fn memchr( + _Buf: *const ::std::os::raw::c_void, + _Val: ::std::os::raw::c_int, + _MaxCount: usize, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn JPCommonLabel_clear(label: *mut JPCommonLabel); + pub fn memcmp( + _Buf1: *const ::std::os::raw::c_void, + _Buf2: *const ::std::os::raw::c_void, + _Size: usize, + ) -> ::std::os::raw::c_int; } -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _JPCommonNode { - pub pron: *mut ::std::os::raw::c_char, - pub pos: *mut ::std::os::raw::c_char, - pub ctype: *mut ::std::os::raw::c_char, - pub cform: *mut ::std::os::raw::c_char, - pub acc: ::std::os::raw::c_int, - pub chain_flag: ::std::os::raw::c_int, - pub prev: *mut _JPCommonNode, - pub next: *mut _JPCommonNode, +extern "C" { + pub fn memcpy( + _Dst: *mut ::std::os::raw::c_void, + _Src: *const ::std::os::raw::c_void, + _Size: usize, + ) -> *mut ::std::os::raw::c_void; } -#[test] -fn bindgen_test_layout__JPCommonNode() { - assert_eq!( - ::std::mem::size_of::<_JPCommonNode>(), - 56usize, - concat!("Size of: ", stringify!(_JPCommonNode)) - ); - assert_eq!( - ::std::mem::align_of::<_JPCommonNode>(), - 8usize, - concat!("Alignment of ", stringify!(_JPCommonNode)) - ); - fn test_field_pron() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonNode>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).pron) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_JPCommonNode), - "::", - stringify!(pron) - ) - ); - } - test_field_pron(); - fn test_field_pos() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonNode>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).pos) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(_JPCommonNode), - "::", - stringify!(pos) - ) - ); - } - test_field_pos(); - fn test_field_ctype() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonNode>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ctype) as usize - ptr as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(_JPCommonNode), - "::", - stringify!(ctype) - ) - ); - } - test_field_ctype(); - fn test_field_cform() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonNode>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).cform) as usize - ptr as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(_JPCommonNode), - "::", - stringify!(cform) - ) - ); - } - test_field_cform(); - fn test_field_acc() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonNode>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).acc) as usize - ptr as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(_JPCommonNode), - "::", - stringify!(acc) - ) - ); - } - test_field_acc(); - fn test_field_chain_flag() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonNode>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).chain_flag) as usize - ptr as usize - }, - 36usize, - concat!( - "Offset of field: ", - stringify!(_JPCommonNode), - "::", - stringify!(chain_flag) - ) - ); - } - test_field_chain_flag(); - fn test_field_prev() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonNode>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(_JPCommonNode), - "::", - stringify!(prev) - ) - ); - } - test_field_prev(); - fn test_field_next() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommonNode>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(_JPCommonNode), - "::", - stringify!(next) - ) - ); - } - test_field_next(); +extern "C" { + pub fn memmove( + _Dst: *mut ::std::os::raw::c_void, + _Src: *const ::std::os::raw::c_void, + _Size: usize, + ) -> *mut ::std::os::raw::c_void; } -pub type JPCommonNode = _JPCommonNode; extern "C" { - pub fn JPCommonNode_initialize(node: *mut JPCommonNode); + pub fn memset( + _Dst: *mut ::std::os::raw::c_void, + _Val: ::std::os::raw::c_int, + _Size: usize, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn JPCommonNode_set_pron(node: *mut JPCommonNode, str_: *const ::std::os::raw::c_char); + 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 JPCommonNode_set_pos(node: *mut JPCommonNode, str_: *const ::std::os::raw::c_char); + 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 JPCommonNode_set_ctype(node: *mut JPCommonNode, str_: *const ::std::os::raw::c_char); + 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 JPCommonNode_set_cform(node: *mut JPCommonNode, str_: *const ::std::os::raw::c_char); + pub fn wcschr(_Str: *const u16, _Ch: u16) -> *const u16; } extern "C" { - pub fn JPCommonNode_set_acc(node: *mut JPCommonNode, acc: ::std::os::raw::c_int); + pub fn wcsrchr(_Str: *const u16, _Ch: u16) -> *const u16; } extern "C" { - pub fn JPCommonNode_set_chain_flag(node: *mut JPCommonNode, flag: ::std::os::raw::c_int); + pub fn wcsstr(_Str: *const u16, _SubStr: *const u16) -> *const u16; } extern "C" { - pub fn JPCommonNode_get_pron(node: *mut JPCommonNode) -> *const ::std::os::raw::c_char; + pub fn _memicmp( + _Buf1: *const ::std::os::raw::c_void, + _Buf2: *const ::std::os::raw::c_void, + _Size: usize, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn JPCommonNode_get_pos(node: *mut JPCommonNode) -> *const ::std::os::raw::c_char; + pub fn _memicmp_l( + _Buf1: *const ::std::os::raw::c_void, + _Buf2: *const ::std::os::raw::c_void, + _Size: usize, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn JPCommonNode_get_ctype(node: *mut JPCommonNode) -> *const ::std::os::raw::c_char; + pub fn memccpy( + _Dst: *mut ::std::os::raw::c_void, + _Src: *const ::std::os::raw::c_void, + _Val: ::std::os::raw::c_int, + _Size: usize, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn JPCommonNode_get_cform(node: *mut JPCommonNode) -> *const ::std::os::raw::c_char; + pub fn memicmp( + _Buf1: *const ::std::os::raw::c_void, + _Buf2: *const ::std::os::raw::c_void, + _Size: usize, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn JPCommonNode_get_acc(node: *mut JPCommonNode) -> ::std::os::raw::c_int; + pub fn wcscat_s(_Destination: *mut u16, _SizeInWords: rsize_t, _Source: *const u16) -> errno_t; } extern "C" { - pub fn JPCommonNode_get_chain_flag(node: *mut JPCommonNode) -> ::std::os::raw::c_int; + pub fn wcscpy_s(_Destination: *mut u16, _SizeInWords: rsize_t, _Source: *const u16) -> errno_t; } extern "C" { - pub fn JPCommonNode_print(node: *mut JPCommonNode); + pub fn wcsncat_s( + _Destination: *mut u16, + _SizeInWords: rsize_t, + _Source: *const u16, + _MaxCount: rsize_t, + ) -> errno_t; } extern "C" { - pub fn JPCommonNode_fprint(node: *mut JPCommonNode, fp: *mut FILE); + pub fn wcsncpy_s( + _Destination: *mut u16, + _SizeInWords: rsize_t, + _Source: *const u16, + _MaxCount: rsize_t, + ) -> errno_t; } extern "C" { - pub fn JPCommonNode_clear(node: *mut JPCommonNode); + pub fn wcstok_s(_String: *mut u16, _Delimiter: *const u16, _Context: *mut *mut u16) + -> *mut u16; } -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _JPCommon { - pub head: *mut JPCommonNode, - pub tail: *mut JPCommonNode, - pub label: *mut JPCommonLabel, +extern "C" { + pub fn _wcsdup(_String: *const u16) -> *mut u16; } -#[test] -fn bindgen_test_layout__JPCommon() { - assert_eq!( - ::std::mem::size_of::<_JPCommon>(), - 24usize, - concat!("Size of: ", stringify!(_JPCommon)) - ); - assert_eq!( - ::std::mem::align_of::<_JPCommon>(), - 8usize, - concat!("Alignment of ", stringify!(_JPCommon)) - ); - fn test_field_head() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommon>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).head) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_JPCommon), - "::", - stringify!(head) - ) - ); - } - test_field_head(); - fn test_field_tail() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommon>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).tail) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(_JPCommon), - "::", - stringify!(tail) - ) - ); - } - test_field_tail(); - fn test_field_label() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_JPCommon>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).label) as usize - ptr as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(_JPCommon), - "::", - stringify!(label) - ) - ); - } - test_field_label(); +extern "C" { + pub fn wcscat(_Destination: *mut u16, _Source: *const u16) -> *mut u16; } -pub type JPCommon = _JPCommon; extern "C" { - pub fn JPCommon_initialize(jpcommon: *mut JPCommon); + pub fn wcscmp(_String1: *const u16, _String2: *const u16) -> ::std::os::raw::c_int; } extern "C" { - pub fn JPCommon_push(jpcommon: *mut JPCommon, node: *mut JPCommonNode); + pub fn wcscpy(_Destination: *mut u16, _Source: *const u16) -> *mut u16; } extern "C" { - pub fn JPCommon_make_label(jpcommon: *mut JPCommon); + pub fn wcscspn(_String: *const u16, _Control: *const u16) -> usize; } extern "C" { - pub fn JPCommon_get_label_size(jpcommon: *mut JPCommon) -> ::std::os::raw::c_int; + pub fn wcslen(_String: *const u16) -> usize; } extern "C" { - pub fn JPCommon_get_label_feature(jpcommon: *mut JPCommon) -> *mut *mut ::std::os::raw::c_char; + pub fn wcsnlen(_Source: *const u16, _MaxCount: usize) -> usize; } extern "C" { - pub fn JPCommon_print(jpcommon: *mut JPCommon); + pub fn wcsncat(_Destination: *mut u16, _Source: *const u16, _Count: usize) -> *mut u16; } extern "C" { - pub fn JPCommon_fprint(jpcommon: *mut JPCommon, fp: *mut FILE); + pub fn wcsncmp( + _String1: *const u16, + _String2: *const u16, + _MaxCount: usize, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn JPCommon_refresh(jpcommon: *mut JPCommon); + pub fn wcsncpy(_Destination: *mut u16, _Source: *const u16, _Count: usize) -> *mut u16; } extern "C" { - pub fn JPCommon_clear(jpcommon: *mut JPCommon); + pub fn wcspbrk(_String: *const u16, _Control: *const u16) -> *const u16; } -#[doc = " DictionaryInfo structure"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct mecab_dictionary_info_t { - #[doc = " filename of dictionary"] - #[doc = " On Windows, filename is stored in UTF-8 encoding"] - pub filename: *const ::std::os::raw::c_char, - #[doc = " character set of the dictionary. e.g., \"SHIFT-JIS\", \"UTF-8\""] - pub charset: *const ::std::os::raw::c_char, - #[doc = " How many words are registered in this dictionary."] - pub size: ::std::os::raw::c_uint, - #[doc = " dictionary type"] - #[doc = " this value should be MECAB_USR_DIC, MECAB_SYS_DIC, or MECAB_UNK_DIC."] - pub type_: ::std::os::raw::c_int, - #[doc = " left attributes size"] - pub lsize: ::std::os::raw::c_uint, - #[doc = " right attributes size"] - pub rsize: ::std::os::raw::c_uint, - #[doc = " version of this dictionary"] - pub version: ::std::os::raw::c_ushort, - #[doc = " pointer to the next dictionary info."] - pub next: *mut mecab_dictionary_info_t, +extern "C" { + pub fn wcsspn(_String: *const u16, _Control: *const u16) -> usize; } -#[test] -fn bindgen_test_layout_mecab_dictionary_info_t() { - assert_eq!( - ::std::mem::size_of::(), - 48usize, - concat!("Size of: ", stringify!(mecab_dictionary_info_t)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(mecab_dictionary_info_t)) - ); - fn test_field_filename() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).filename) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(mecab_dictionary_info_t), - "::", - stringify!(filename) - ) - ); - } - test_field_filename(); - fn test_field_charset() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).charset) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(mecab_dictionary_info_t), - "::", - stringify!(charset) - ) - ); - } - test_field_charset(); - fn test_field_size() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(mecab_dictionary_info_t), - "::", - stringify!(size) - ) - ); - } - test_field_size(); - fn test_field_type() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize - }, - 20usize, - concat!( - "Offset of field: ", - stringify!(mecab_dictionary_info_t), - "::", - stringify!(type_) - ) - ); - } - test_field_type(); - fn test_field_lsize() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).lsize) as usize - ptr as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(mecab_dictionary_info_t), - "::", - stringify!(lsize) - ) - ); - } - test_field_lsize(); - fn test_field_rsize() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).rsize) as usize - ptr as usize - }, - 28usize, - concat!( - "Offset of field: ", - stringify!(mecab_dictionary_info_t), - "::", - stringify!(rsize) - ) - ); - } - test_field_rsize(); - fn test_field_version() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(mecab_dictionary_info_t), - "::", - stringify!(version) - ) - ); - } - test_field_version(); - fn test_field_next() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(mecab_dictionary_info_t), - "::", - stringify!(next) - ) - ); - } - test_field_next(); +extern "C" { + pub fn wcstok(_String: *mut u16, _Delimiter: *const u16, _Context: *mut *mut u16) -> *mut u16; } -#[doc = " Path structure"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct mecab_path_t { - #[doc = " pointer to the right node"] - pub rnode: *mut mecab_node_t, - #[doc = " pointer to the next right path"] - pub rnext: *mut mecab_path_t, - #[doc = " pointer to the left node"] - pub lnode: *mut mecab_node_t, - #[doc = " pointer to the next left path"] - pub lnext: *mut mecab_path_t, - #[doc = " local cost"] - pub cost: ::std::os::raw::c_int, - #[doc = " marginal probability"] - pub prob: f32, +extern "C" { + pub fn _wcserror(_ErrorNumber: ::std::os::raw::c_int) -> *mut u16; +} +extern "C" { + pub fn _wcserror_s( + _Buffer: *mut u16, + _SizeInWords: usize, + _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: usize, + _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: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _wcsnicmp_l( + _String1: *const u16, + _String2: *const u16, + _MaxCount: usize, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _wcsnset_s( + _Destination: *mut u16, + _SizeInWords: usize, + _Value: u16, + _MaxCount: usize, + ) -> errno_t; +} +extern "C" { + pub fn _wcsnset(_String: *mut u16, _Value: u16, _MaxCount: usize) -> *mut u16; +} +extern "C" { + pub fn _wcsrev(_String: *mut u16) -> *mut u16; +} +extern "C" { + pub fn _wcsset_s(_Destination: *mut u16, _SizeInWords: usize, _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: usize) -> errno_t; +} +extern "C" { + pub fn _wcslwr(_String: *mut u16) -> *mut u16; +} +extern "C" { + pub fn _wcslwr_s_l(_String: *mut u16, _SizeInWords: usize, _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: usize) -> errno_t; +} +extern "C" { + pub fn _wcsupr(_String: *mut u16) -> *mut u16; +} +extern "C" { + pub fn _wcsupr_s_l(_String: *mut u16, _Size: usize, _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: usize) -> usize; +} +extern "C" { + pub fn _wcsxfrm_l( + _Destination: *mut u16, + _Source: *const u16, + _MaxCount: usize, + _Locale: _locale_t, + ) -> usize; +} +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: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _wcsncoll_l( + _String1: *const u16, + _String2: *const u16, + _MaxCount: usize, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _wcsnicoll( + _String1: *const u16, + _String2: *const u16, + _MaxCount: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _wcsnicoll_l( + _String1: *const u16, + _String2: *const u16, + _MaxCount: usize, + _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: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn wcsnset(_String: *mut u16, _Value: u16, _MaxCount: usize) -> *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: usize, + _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: usize, + ) -> *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, + ) -> usize; +} +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: usize, + _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) -> usize; +} +extern "C" { + pub fn _strlwr_s(_String: *mut ::std::os::raw::c_char, _Size: usize) -> 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: usize, + _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: usize, + ) -> *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: usize, + ) -> ::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: usize, + ) -> ::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: usize, + _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: usize, + ) -> ::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: usize, + _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: usize, + ) -> ::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: usize, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn __strncnt(_String: *const ::std::os::raw::c_char, _Count: usize) -> usize; +} +extern "C" { + pub fn strncpy( + _Destination: *mut ::std::os::raw::c_char, + _Source: *const ::std::os::raw::c_char, + _Count: usize, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn strnlen(_String: *const ::std::os::raw::c_char, _MaxCount: usize) -> usize; +} +extern "C" { + pub fn _strnset_s( + _String: *mut ::std::os::raw::c_char, + _SizeInBytes: usize, + _Value: ::std::os::raw::c_int, + _MaxCount: usize, + ) -> errno_t; +} +extern "C" { + pub fn _strnset( + _Destination: *mut ::std::os::raw::c_char, + _Value: ::std::os::raw::c_int, + _Count: usize, + ) -> *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: usize, + _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, + ) -> usize; +} +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: usize) -> 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: usize, + _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: usize, + ) -> usize; +} +extern "C" { + pub fn _strxfrm_l( + _Destination: *mut ::std::os::raw::c_char, + _Source: *const ::std::os::raw::c_char, + _MaxCount: usize, + _Locale: _locale_t, + ) -> usize; +} +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: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn strnset( + _String: *mut ::std::os::raw::c_char, + _Value: ::std::os::raw::c_int, + _MaxCount: usize, + ) -> *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; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _OBJECTID { + pub Lineage: GUID, + pub Uniquifier: DWORD, } #[test] -fn bindgen_test_layout_mecab_path_t() { +fn bindgen_test_layout__OBJECTID() { assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(mecab_path_t)) + ::std::mem::size_of::<_OBJECTID>(), + 20usize, + concat!("Size of: ", stringify!(_OBJECTID)) ); assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(mecab_path_t)) + ::std::mem::align_of::<_OBJECTID>(), + 4usize, + concat!("Alignment of ", stringify!(_OBJECTID)) ); - fn test_field_rnode() { + fn test_field_Lineage() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_OBJECTID>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).rnode) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Lineage) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(mecab_path_t), - "::", - stringify!(rnode) - ) - ); - } - test_field_rnode(); - fn test_field_rnext() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).rnext) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(mecab_path_t), + stringify!(_OBJECTID), "::", - stringify!(rnext) + stringify!(Lineage) ) ); } - test_field_rnext(); - fn test_field_lnode() { + test_field_Lineage(); + fn test_field_Uniquifier() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_OBJECTID>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).lnode) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Uniquifier) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", - stringify!(mecab_path_t), - "::", - stringify!(lnode) - ) - ); - } - test_field_lnode(); - fn test_field_lnext() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).lnext) as usize - ptr as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(mecab_path_t), + stringify!(_OBJECTID), "::", - stringify!(lnext) + stringify!(Uniquifier) ) ); } - test_field_lnext(); - fn test_field_cost() { + test_field_Uniquifier(); +} +pub type OBJECTID = _OBJECTID; +pub type PEXCEPTION_ROUTINE = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut _EXCEPTION_RECORD, + arg2: PVOID, + arg3: *mut _CONTEXT, + arg4: PVOID, + ) -> EXCEPTION_DISPOSITION, +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _ENUM_FLAG_SIZED_INTEGER { + pub _address: u8, +} +pub type _ENUM_FLAG_SIZED_INTEGER_type = u8; +pub type KSPIN_LOCK = ULONG_PTR; +pub type PKSPIN_LOCK = *mut KSPIN_LOCK; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _M128A { + pub Low: ULONGLONG, + pub High: LONGLONG, +} +#[test] +fn bindgen_test_layout__M128A() { + assert_eq!( + ::std::mem::size_of::<_M128A>(), + 16usize, + concat!("Size of: ", stringify!(_M128A)) + ); + assert_eq!( + ::std::mem::align_of::<_M128A>(), + 16usize, + concat!("Alignment of ", stringify!(_M128A)) + ); + fn test_field_Low() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_M128A>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).cost) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Low) as usize - ptr as usize }, - 32usize, + 0usize, concat!( "Offset of field: ", - stringify!(mecab_path_t), + stringify!(_M128A), "::", - stringify!(cost) + stringify!(Low) ) ); } - test_field_cost(); - fn test_field_prob() { + test_field_Low(); + fn test_field_High() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_M128A>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).prob) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).High) as usize - ptr as usize }, - 36usize, + 8usize, concat!( "Offset of field: ", - stringify!(mecab_path_t), + stringify!(_M128A), "::", - stringify!(prob) + stringify!(High) ) ); } - test_field_prob(); + test_field_High(); } -#[doc = " Node structure"] +pub type M128A = _M128A; +pub type PM128A = *mut _M128A; #[repr(C)] +#[repr(align(16))] #[derive(Debug, Copy, Clone)] -pub struct mecab_node_t { - #[doc = " pointer to the previous node."] - pub prev: *mut mecab_node_t, - #[doc = " pointer to the next node."] - pub next: *mut mecab_node_t, - #[doc = " pointer to the node which ends at the same position."] - pub enext: *mut mecab_node_t, - #[doc = " pointer to the node which starts at the same position."] - pub bnext: *mut mecab_node_t, - #[doc = " pointer to the right path."] - #[doc = " this value is NULL if MECAB_ONE_BEST mode."] - pub rpath: *mut mecab_path_t, - #[doc = " pointer to the right path."] - #[doc = " this value is NULL if MECAB_ONE_BEST mode."] - pub lpath: *mut mecab_path_t, - #[doc = " surface string."] - #[doc = " this value is not 0 terminated."] - #[doc = " You can get the length with length/rlength members."] - pub surface: *const ::std::os::raw::c_char, - #[doc = " feature string"] - pub feature: *const ::std::os::raw::c_char, - #[doc = " unique node id"] - pub id: ::std::os::raw::c_uint, - #[doc = " length of the surface form."] - pub length: ::std::os::raw::c_ushort, - #[doc = " length of the surface form including white space before the morph."] - pub rlength: ::std::os::raw::c_ushort, - #[doc = " right attribute id"] - pub rcAttr: ::std::os::raw::c_ushort, - #[doc = " left attribute id"] - pub lcAttr: ::std::os::raw::c_ushort, - #[doc = " unique part of speech id. This value is defined in \"pos.def\" file."] - pub posid: ::std::os::raw::c_ushort, - #[doc = " character type"] - pub char_type: ::std::os::raw::c_uchar, - #[doc = " status of this model."] - #[doc = " This value is MECAB_NOR_NODE, MECAB_UNK_NODE, MECAB_BOS_NODE, MECAB_EOS_NODE, or MECAB_EON_NODE."] - pub stat: ::std::os::raw::c_uchar, - #[doc = " set 1 if this node is best node."] - pub isbest: ::std::os::raw::c_uchar, - #[doc = " forward accumulative log summation."] - #[doc = " This value is only available when MECAB_MARGINAL_PROB is passed."] - pub alpha: f32, - #[doc = " backward accumulative log summation."] - #[doc = " This value is only available when MECAB_MARGINAL_PROB is passed."] - pub beta: f32, - #[doc = " marginal probability."] - #[doc = " This value is only available when MECAB_MARGINAL_PROB is passed."] - pub prob: f32, - #[doc = " word cost."] - pub wcost: ::std::os::raw::c_short, - #[doc = " best accumulative cost from bos node to this node."] - pub cost: ::std::os::raw::c_long, +pub struct _XSAVE_FORMAT { + pub ControlWord: WORD, + pub StatusWord: WORD, + pub TagWord: BYTE, + pub Reserved1: BYTE, + pub ErrorOpcode: WORD, + pub ErrorOffset: DWORD, + pub ErrorSelector: WORD, + pub Reserved2: WORD, + pub DataOffset: DWORD, + pub DataSelector: WORD, + pub Reserved3: WORD, + pub MxCsr: DWORD, + pub MxCsr_Mask: DWORD, + pub FloatRegisters: [M128A; 8usize], + pub XmmRegisters: [M128A; 16usize], + pub Reserved4: [BYTE; 96usize], } #[test] -fn bindgen_test_layout_mecab_node_t() { +fn bindgen_test_layout__XSAVE_FORMAT() { assert_eq!( - ::std::mem::size_of::(), - 104usize, - concat!("Size of: ", stringify!(mecab_node_t)) + ::std::mem::size_of::<_XSAVE_FORMAT>(), + 512usize, + concat!("Size of: ", stringify!(_XSAVE_FORMAT)) ); assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(mecab_node_t)) + ::std::mem::align_of::<_XSAVE_FORMAT>(), + 16usize, + concat!("Alignment of ", stringify!(_XSAVE_FORMAT)) ); - fn test_field_prev() { + fn test_field_ControlWord() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ControlWord) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_FORMAT), "::", - stringify!(prev) + stringify!(ControlWord) ) ); } - test_field_prev(); - fn test_field_next() { + test_field_ControlWord(); + fn test_field_StatusWord() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).StatusWord) as usize - ptr as usize }, - 8usize, + 2usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_FORMAT), "::", - stringify!(next) + stringify!(StatusWord) ) ); } - test_field_next(); - fn test_field_enext() { + test_field_StatusWord(); + fn test_field_TagWord() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).enext) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).TagWord) as usize - ptr as usize }, - 16usize, + 4usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_FORMAT), "::", - stringify!(enext) + stringify!(TagWord) ) ); } - test_field_enext(); - fn test_field_bnext() { + test_field_TagWord(); + fn test_field_Reserved1() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).bnext) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Reserved1) as usize - ptr as usize }, - 24usize, + 5usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_FORMAT), "::", - stringify!(bnext) + stringify!(Reserved1) ) ); } - test_field_bnext(); - fn test_field_rpath() { + test_field_Reserved1(); + fn test_field_ErrorOpcode() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).rpath) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ErrorOpcode) as usize - ptr as usize }, - 32usize, + 6usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_FORMAT), "::", - stringify!(rpath) + stringify!(ErrorOpcode) ) ); } - test_field_rpath(); - fn test_field_lpath() { + test_field_ErrorOpcode(); + fn test_field_ErrorOffset() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).lpath) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ErrorOffset) as usize - ptr as usize }, - 40usize, + 8usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_FORMAT), "::", - stringify!(lpath) + stringify!(ErrorOffset) ) ); } - test_field_lpath(); - fn test_field_surface() { + test_field_ErrorOffset(); + fn test_field_ErrorSelector() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).surface) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ErrorSelector) as usize - ptr as usize }, - 48usize, + 12usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_FORMAT), "::", - stringify!(surface) + stringify!(ErrorSelector) ) ); } - test_field_surface(); - fn test_field_feature() { + test_field_ErrorSelector(); + fn test_field_Reserved2() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).feature) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Reserved2) as usize - ptr as usize }, - 56usize, + 14usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_FORMAT), "::", - stringify!(feature) + stringify!(Reserved2) ) ); } - test_field_feature(); - fn test_field_id() { + test_field_Reserved2(); + fn test_field_DataOffset() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).DataOffset) as usize - ptr as usize }, - 64usize, + 16usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_FORMAT), "::", - stringify!(id) + stringify!(DataOffset) ) ); } - test_field_id(); - fn test_field_length() { + test_field_DataOffset(); + fn test_field_DataSelector() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).DataSelector) as usize - ptr as usize }, - 68usize, + 20usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_FORMAT), "::", - stringify!(length) + stringify!(DataSelector) ) ); } - test_field_length(); - fn test_field_rlength() { + test_field_DataSelector(); + fn test_field_Reserved3() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).rlength) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Reserved3) as usize - ptr as usize }, - 70usize, + 22usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_FORMAT), "::", - stringify!(rlength) + stringify!(Reserved3) ) ); } - test_field_rlength(); - fn test_field_rcAttr() { + test_field_Reserved3(); + fn test_field_MxCsr() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).rcAttr) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).MxCsr) as usize - ptr as usize }, - 72usize, + 24usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_FORMAT), "::", - stringify!(rcAttr) + stringify!(MxCsr) ) ); } - test_field_rcAttr(); - fn test_field_lcAttr() { + test_field_MxCsr(); + fn test_field_MxCsr_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).lcAttr) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).MxCsr_Mask) as usize - ptr as usize }, - 74usize, + 28usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_FORMAT), "::", - stringify!(lcAttr) + stringify!(MxCsr_Mask) ) ); } - test_field_lcAttr(); - fn test_field_posid() { + test_field_MxCsr_Mask(); + fn test_field_FloatRegisters() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).posid) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).FloatRegisters) as usize - ptr as usize }, - 76usize, + 32usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_FORMAT), "::", - stringify!(posid) + stringify!(FloatRegisters) ) ); } - test_field_posid(); - fn test_field_char_type() { + test_field_FloatRegisters(); + fn test_field_XmmRegisters() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).char_type) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).XmmRegisters) as usize - ptr as usize }, - 78usize, + 160usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_FORMAT), "::", - stringify!(char_type) + stringify!(XmmRegisters) ) ); } - test_field_char_type(); - fn test_field_stat() { + test_field_XmmRegisters(); + fn test_field_Reserved4() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).stat) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Reserved4) as usize - ptr as usize }, - 79usize, + 416usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_FORMAT), "::", - stringify!(stat) + stringify!(Reserved4) ) ); } - test_field_stat(); - fn test_field_isbest() { + test_field_Reserved4(); +} +pub type XSAVE_FORMAT = _XSAVE_FORMAT; +pub type PXSAVE_FORMAT = *mut _XSAVE_FORMAT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _XSAVE_CET_U_FORMAT { + pub Ia32CetUMsr: DWORD64, + pub Ia32Pl3SspMsr: DWORD64, +} +#[test] +fn bindgen_test_layout__XSAVE_CET_U_FORMAT() { + assert_eq!( + ::std::mem::size_of::<_XSAVE_CET_U_FORMAT>(), + 16usize, + concat!("Size of: ", stringify!(_XSAVE_CET_U_FORMAT)) + ); + assert_eq!( + ::std::mem::align_of::<_XSAVE_CET_U_FORMAT>(), + 8usize, + concat!("Alignment of ", stringify!(_XSAVE_CET_U_FORMAT)) + ); + fn test_field_Ia32CetUMsr() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_CET_U_FORMAT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).isbest) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Ia32CetUMsr) as usize - ptr as usize }, - 80usize, + 0usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_CET_U_FORMAT), "::", - stringify!(isbest) + stringify!(Ia32CetUMsr) ) ); } - test_field_isbest(); - fn test_field_alpha() { + test_field_Ia32CetUMsr(); + fn test_field_Ia32Pl3SspMsr() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_CET_U_FORMAT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).alpha) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Ia32Pl3SspMsr) as usize - ptr as usize }, - 84usize, + 8usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_CET_U_FORMAT), "::", - stringify!(alpha) + stringify!(Ia32Pl3SspMsr) ) ); } - test_field_alpha(); - fn test_field_beta() { + test_field_Ia32Pl3SspMsr(); +} +pub type XSAVE_CET_U_FORMAT = _XSAVE_CET_U_FORMAT; +pub type PXSAVE_CET_U_FORMAT = *mut _XSAVE_CET_U_FORMAT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _XSAVE_AREA_HEADER { + pub Mask: DWORD64, + pub CompactionMask: DWORD64, + pub Reserved2: [DWORD64; 6usize], +} +#[test] +fn bindgen_test_layout__XSAVE_AREA_HEADER() { + assert_eq!( + ::std::mem::size_of::<_XSAVE_AREA_HEADER>(), + 64usize, + concat!("Size of: ", stringify!(_XSAVE_AREA_HEADER)) + ); + assert_eq!( + ::std::mem::align_of::<_XSAVE_AREA_HEADER>(), + 8usize, + concat!("Alignment of ", stringify!(_XSAVE_AREA_HEADER)) + ); + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_AREA_HEADER>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).beta) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, - 88usize, + 0usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_AREA_HEADER), "::", - stringify!(beta) + stringify!(Mask) ) ); } - test_field_beta(); - fn test_field_prob() { + test_field_Mask(); + fn test_field_CompactionMask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_AREA_HEADER>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).prob) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).CompactionMask) as usize - ptr as usize }, - 92usize, + 8usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_AREA_HEADER), "::", - stringify!(prob) + stringify!(CompactionMask) ) ); } - test_field_prob(); - fn test_field_wcost() { + test_field_CompactionMask(); + fn test_field_Reserved2() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_AREA_HEADER>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).wcost) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Reserved2) as usize - ptr as usize }, - 96usize, + 16usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_AREA_HEADER), "::", - stringify!(wcost) + stringify!(Reserved2) ) ); } - test_field_wcost(); - fn test_field_cost() { + test_field_Reserved2(); +} +pub type XSAVE_AREA_HEADER = _XSAVE_AREA_HEADER; +pub type PXSAVE_AREA_HEADER = *mut _XSAVE_AREA_HEADER; +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _XSAVE_AREA { + pub LegacyState: XSAVE_FORMAT, + pub Header: XSAVE_AREA_HEADER, +} +#[test] +fn bindgen_test_layout__XSAVE_AREA() { + assert_eq!( + ::std::mem::size_of::<_XSAVE_AREA>(), + 576usize, + concat!("Size of: ", stringify!(_XSAVE_AREA)) + ); + assert_eq!( + ::std::mem::align_of::<_XSAVE_AREA>(), + 16usize, + concat!("Alignment of ", stringify!(_XSAVE_AREA)) + ); + fn test_field_LegacyState() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_XSAVE_AREA>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).cost) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).LegacyState) as usize - ptr as usize }, - 100usize, + 0usize, concat!( "Offset of field: ", - stringify!(mecab_node_t), + stringify!(_XSAVE_AREA), "::", - stringify!(cost) + stringify!(LegacyState) ) ); } - test_field_cost(); + test_field_LegacyState(); + fn test_field_Header() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_XSAVE_AREA>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + }, + 512usize, + concat!( + "Offset of field: ", + stringify!(_XSAVE_AREA), + "::", + stringify!(Header) + ) + ); + } + test_field_Header(); } -pub const MECAB_NOR_NODE: _bindgen_ty_1 = _bindgen_ty_1::MECAB_NOR_NODE; -pub const MECAB_UNK_NODE: _bindgen_ty_1 = _bindgen_ty_1::MECAB_UNK_NODE; -pub const MECAB_BOS_NODE: _bindgen_ty_1 = _bindgen_ty_1::MECAB_BOS_NODE; -pub const MECAB_EOS_NODE: _bindgen_ty_1 = _bindgen_ty_1::MECAB_EOS_NODE; -pub const MECAB_EON_NODE: _bindgen_ty_1 = _bindgen_ty_1::MECAB_EON_NODE; -#[repr(i32)] -#[doc = " Parameters for MeCab::Node::stat"] -#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] -pub enum _bindgen_ty_1 { - #[doc = " Normal node defined in the dictionary."] - MECAB_NOR_NODE = 0, - #[doc = " Unknown node not defined in the dictionary."] - MECAB_UNK_NODE = 1, - #[doc = " Virtual node representing a beginning of the sentence."] - MECAB_BOS_NODE = 2, - #[doc = " Virtual node representing a end of the sentence."] - MECAB_EOS_NODE = 3, - #[doc = " Virtual node representing a end of the N-best enumeration."] - MECAB_EON_NODE = 4, +pub type XSAVE_AREA = _XSAVE_AREA; +pub type PXSAVE_AREA = *mut _XSAVE_AREA; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _XSTATE_CONTEXT { + pub Mask: DWORD64, + pub Length: DWORD, + pub Reserved1: DWORD, + pub Area: PXSAVE_AREA, + pub Buffer: PVOID, } -pub const MECAB_SYS_DIC: _bindgen_ty_2 = _bindgen_ty_2::MECAB_SYS_DIC; -pub const MECAB_USR_DIC: _bindgen_ty_2 = _bindgen_ty_2::MECAB_USR_DIC; -pub const MECAB_UNK_DIC: _bindgen_ty_2 = _bindgen_ty_2::MECAB_UNK_DIC; -#[repr(i32)] -#[doc = " Parameters for MeCab::DictionaryInfo::type"] -#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] -pub enum _bindgen_ty_2 { - #[doc = " This is a system dictionary."] - MECAB_SYS_DIC = 0, - #[doc = " This is a user dictionary."] - MECAB_USR_DIC = 1, - #[doc = " This is a unknown word dictionary."] - MECAB_UNK_DIC = 2, +#[test] +fn bindgen_test_layout__XSTATE_CONTEXT() { + assert_eq!( + ::std::mem::size_of::<_XSTATE_CONTEXT>(), + 32usize, + concat!("Size of: ", stringify!(_XSTATE_CONTEXT)) + ); + assert_eq!( + ::std::mem::align_of::<_XSTATE_CONTEXT>(), + 8usize, + concat!("Alignment of ", stringify!(_XSTATE_CONTEXT)) + ); + fn test_field_Mask() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_XSTATE_CONTEXT>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_XSTATE_CONTEXT), + "::", + stringify!(Mask) + ) + ); + } + test_field_Mask(); + fn test_field_Length() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_XSTATE_CONTEXT>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Length) as usize - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_XSTATE_CONTEXT), + "::", + stringify!(Length) + ) + ); + } + test_field_Length(); + fn test_field_Reserved1() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_XSTATE_CONTEXT>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Reserved1) as usize - ptr as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(_XSTATE_CONTEXT), + "::", + stringify!(Reserved1) + ) + ); + } + test_field_Reserved1(); + fn test_field_Area() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_XSTATE_CONTEXT>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Area) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_XSTATE_CONTEXT), + "::", + stringify!(Area) + ) + ); + } + test_field_Area(); + fn test_field_Buffer() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_XSTATE_CONTEXT>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Buffer) as usize - ptr as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(_XSTATE_CONTEXT), + "::", + stringify!(Buffer) + ) + ); + } + test_field_Buffer(); } -pub const MECAB_ONE_BEST: _bindgen_ty_3 = _bindgen_ty_3::MECAB_ONE_BEST; -pub const MECAB_NBEST: _bindgen_ty_3 = _bindgen_ty_3::MECAB_NBEST; -pub const MECAB_PARTIAL: _bindgen_ty_3 = _bindgen_ty_3::MECAB_PARTIAL; -pub const MECAB_MARGINAL_PROB: _bindgen_ty_3 = _bindgen_ty_3::MECAB_MARGINAL_PROB; -pub const MECAB_ALTERNATIVE: _bindgen_ty_3 = _bindgen_ty_3::MECAB_ALTERNATIVE; -pub const MECAB_ALL_MORPHS: _bindgen_ty_3 = _bindgen_ty_3::MECAB_ALL_MORPHS; -pub const MECAB_ALLOCATE_SENTENCE: _bindgen_ty_3 = _bindgen_ty_3::MECAB_ALLOCATE_SENTENCE; -#[repr(i32)] -#[doc = " Parameters for MeCab::Lattice::request_type"] -#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] -pub enum _bindgen_ty_3 { - #[doc = " One best result is obtained (default mode)"] - MECAB_ONE_BEST = 1, - #[doc = " Set this flag if you want to obtain N best results."] - MECAB_NBEST = 2, - #[doc = " Set this flag if you want to enable a partial parsing mode."] - #[doc = " When this flag is set, the input |sentence| needs to be written"] - #[doc = " in partial parsing format."] - MECAB_PARTIAL = 4, - #[doc = " Set this flag if you want to obtain marginal probabilities."] - #[doc = " Marginal probability is set in MeCab::Node::prob."] - #[doc = " The parsing speed will get 3-5 times slower than the default mode."] - MECAB_MARGINAL_PROB = 8, - #[doc = " Set this flag if you want to obtain alternative results."] - #[doc = " Not implemented."] - MECAB_ALTERNATIVE = 16, - #[doc = " When this flag is set, the result linked-list (Node::next/prev)"] - #[doc = " traverses all nodes in the lattice."] - MECAB_ALL_MORPHS = 32, - #[doc = " When this flag is set, tagger internally copies the body of passed"] - #[doc = " sentence into internal buffer."] - MECAB_ALLOCATE_SENTENCE = 64, +pub type XSTATE_CONTEXT = _XSTATE_CONTEXT; +pub type PXSTATE_CONTEXT = *mut _XSTATE_CONTEXT; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _KERNEL_CET_CONTEXT { + pub Ssp: DWORD64, + pub Rip: DWORD64, + pub SegCs: WORD, + pub __bindgen_anon_1: _KERNEL_CET_CONTEXT__bindgen_ty_1, + pub Fill: [WORD; 2usize], } -pub const MECAB_ANY_BOUNDARY: _bindgen_ty_4 = _bindgen_ty_4::MECAB_ANY_BOUNDARY; -pub const MECAB_TOKEN_BOUNDARY: _bindgen_ty_4 = _bindgen_ty_4::MECAB_TOKEN_BOUNDARY; -pub const MECAB_INSIDE_TOKEN: _bindgen_ty_4 = _bindgen_ty_4::MECAB_INSIDE_TOKEN; -#[repr(i32)] -#[doc = " Parameters for MeCab::Lattice::boundary_constraint_type"] -#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] -pub enum _bindgen_ty_4 { - #[doc = " The token boundary is not specified."] - MECAB_ANY_BOUNDARY = 0, - #[doc = " The position is a strong token boundary."] - MECAB_TOKEN_BOUNDARY = 1, - #[doc = " The position is not a token boundary."] - MECAB_INSIDE_TOKEN = 2, +#[repr(C)] +#[derive(Copy, Clone)] +pub union _KERNEL_CET_CONTEXT__bindgen_ty_1 { + pub AllFlags: WORD, + pub __bindgen_anon_1: _KERNEL_CET_CONTEXT__bindgen_ty_1__bindgen_ty_1, } -pub type std_nullptr_t = *const ::std::os::raw::c_void; -#[repr(i32)] -#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] -pub enum _EXCEPTION_DISPOSITION { - ExceptionContinueExecution = 0, - ExceptionContinueSearch = 1, - ExceptionNestedException = 2, - ExceptionCollidedUnwind = 3, +#[repr(C)] +#[repr(align(2))] +#[derive(Debug, Copy, Clone)] +pub struct _KERNEL_CET_CONTEXT__bindgen_ty_1__bindgen_ty_1 { + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, } -pub use self::_EXCEPTION_DISPOSITION as EXCEPTION_DISPOSITION; +#[test] +fn bindgen_test_layout__KERNEL_CET_CONTEXT__bindgen_ty_1__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<_KERNEL_CET_CONTEXT__bindgen_ty_1__bindgen_ty_1>(), + 2usize, + concat!( + "Size of: ", + stringify!(_KERNEL_CET_CONTEXT__bindgen_ty_1__bindgen_ty_1) + ) + ); + assert_eq!( + ::std::mem::align_of::<_KERNEL_CET_CONTEXT__bindgen_ty_1__bindgen_ty_1>(), + 2usize, + concat!( + "Alignment of ", + stringify!(_KERNEL_CET_CONTEXT__bindgen_ty_1__bindgen_ty_1) + ) + ); +} +impl _KERNEL_CET_CONTEXT__bindgen_ty_1__bindgen_ty_1 { + #[inline] + pub fn UseWrss(&self) -> WORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) } + } + #[inline] + pub fn set_UseWrss(&mut self, val: WORD) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn PopShadowStackOne(&self) -> WORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16) } + } + #[inline] + pub fn set_PopShadowStackOne(&mut self, val: WORD) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn Unused(&self) -> WORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 14u8) as u16) } + } + #[inline] + pub fn set_Unused(&mut self, val: WORD) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 14u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + UseWrss: WORD, + PopShadowStackOne: WORD, + Unused: WORD, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let UseWrss: u16 = unsafe { ::std::mem::transmute(UseWrss) }; + UseWrss as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let PopShadowStackOne: u16 = unsafe { ::std::mem::transmute(PopShadowStackOne) }; + PopShadowStackOne as u64 + }); + __bindgen_bitfield_unit.set(2usize, 14u8, { + let Unused: u16 = unsafe { ::std::mem::transmute(Unused) }; + Unused as u64 + }); + __bindgen_bitfield_unit + } +} +#[test] +fn bindgen_test_layout__KERNEL_CET_CONTEXT__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<_KERNEL_CET_CONTEXT__bindgen_ty_1>(), + 2usize, + concat!("Size of: ", stringify!(_KERNEL_CET_CONTEXT__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::<_KERNEL_CET_CONTEXT__bindgen_ty_1>(), + 2usize, + concat!( + "Alignment of ", + stringify!(_KERNEL_CET_CONTEXT__bindgen_ty_1) + ) + ); + fn test_field_AllFlags() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_KERNEL_CET_CONTEXT__bindgen_ty_1>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).AllFlags) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_KERNEL_CET_CONTEXT__bindgen_ty_1), + "::", + stringify!(AllFlags) + ) + ); + } + test_field_AllFlags(); +} +#[test] +fn bindgen_test_layout__KERNEL_CET_CONTEXT() { + assert_eq!( + ::std::mem::size_of::<_KERNEL_CET_CONTEXT>(), + 24usize, + concat!("Size of: ", stringify!(_KERNEL_CET_CONTEXT)) + ); + assert_eq!( + ::std::mem::align_of::<_KERNEL_CET_CONTEXT>(), + 8usize, + concat!("Alignment of ", stringify!(_KERNEL_CET_CONTEXT)) + ); + fn test_field_Ssp() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_KERNEL_CET_CONTEXT>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Ssp) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_KERNEL_CET_CONTEXT), + "::", + stringify!(Ssp) + ) + ); + } + test_field_Ssp(); + fn test_field_Rip() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_KERNEL_CET_CONTEXT>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Rip) as usize - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_KERNEL_CET_CONTEXT), + "::", + stringify!(Rip) + ) + ); + } + test_field_Rip(); + fn test_field_SegCs() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_KERNEL_CET_CONTEXT>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).SegCs) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_KERNEL_CET_CONTEXT), + "::", + stringify!(SegCs) + ) + ); + } + test_field_SegCs(); + fn test_field_Fill() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_KERNEL_CET_CONTEXT>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Fill) as usize - ptr as usize + }, + 20usize, + concat!( + "Offset of field: ", + stringify!(_KERNEL_CET_CONTEXT), + "::", + stringify!(Fill) + ) + ); + } + test_field_Fill(); +} +pub type KERNEL_CET_CONTEXT = _KERNEL_CET_CONTEXT; +pub type PKERNEL_CET_CONTEXT = *mut _KERNEL_CET_CONTEXT; +pub type __C_ASSERT__ = [::std::os::raw::c_char; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SCOPE_TABLE_AMD64 { + pub Count: DWORD, + pub ScopeRecord: [_SCOPE_TABLE_AMD64__bindgen_ty_1; 1usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SCOPE_TABLE_AMD64__bindgen_ty_1 { + pub BeginAddress: DWORD, + pub EndAddress: DWORD, + pub HandlerAddress: DWORD, + pub JumpTarget: DWORD, +} +#[test] +fn bindgen_test_layout__SCOPE_TABLE_AMD64__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<_SCOPE_TABLE_AMD64__bindgen_ty_1>(), + 16usize, + concat!("Size of: ", stringify!(_SCOPE_TABLE_AMD64__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::<_SCOPE_TABLE_AMD64__bindgen_ty_1>(), + 4usize, + concat!( + "Alignment of ", + stringify!(_SCOPE_TABLE_AMD64__bindgen_ty_1) + ) + ); + fn test_field_BeginAddress() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_AMD64__bindgen_ty_1>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).BeginAddress) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_SCOPE_TABLE_AMD64__bindgen_ty_1), + "::", + stringify!(BeginAddress) + ) + ); + } + test_field_BeginAddress(); + fn test_field_EndAddress() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_AMD64__bindgen_ty_1>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).EndAddress) as usize - ptr as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(_SCOPE_TABLE_AMD64__bindgen_ty_1), + "::", + stringify!(EndAddress) + ) + ); + } + test_field_EndAddress(); + fn test_field_HandlerAddress() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_AMD64__bindgen_ty_1>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).HandlerAddress) as usize - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_SCOPE_TABLE_AMD64__bindgen_ty_1), + "::", + stringify!(HandlerAddress) + ) + ); + } + test_field_HandlerAddress(); + fn test_field_JumpTarget() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_AMD64__bindgen_ty_1>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).JumpTarget) as usize - ptr as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(_SCOPE_TABLE_AMD64__bindgen_ty_1), + "::", + stringify!(JumpTarget) + ) + ); + } + test_field_JumpTarget(); +} +#[test] +fn bindgen_test_layout__SCOPE_TABLE_AMD64() { + assert_eq!( + ::std::mem::size_of::<_SCOPE_TABLE_AMD64>(), + 20usize, + concat!("Size of: ", stringify!(_SCOPE_TABLE_AMD64)) + ); + assert_eq!( + ::std::mem::align_of::<_SCOPE_TABLE_AMD64>(), + 4usize, + concat!("Alignment of ", stringify!(_SCOPE_TABLE_AMD64)) + ); + fn test_field_Count() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_AMD64>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Count) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_SCOPE_TABLE_AMD64), + "::", + stringify!(Count) + ) + ); + } + test_field_Count(); + fn test_field_ScopeRecord() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_AMD64>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).ScopeRecord) as usize - ptr as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(_SCOPE_TABLE_AMD64), + "::", + stringify!(ScopeRecord) + ) + ); + } + test_field_ScopeRecord(); +} +pub type SCOPE_TABLE_AMD64 = _SCOPE_TABLE_AMD64; +pub type PSCOPE_TABLE_AMD64 = *mut _SCOPE_TABLE_AMD64; extern "C" { - pub fn __C_specific_handler( - ExceptionRecord: *mut _EXCEPTION_RECORD, - EstablisherFrame: *mut ::std::os::raw::c_void, - ContextRecord: *mut _CONTEXT, - DispatcherContext: *mut _DISPATCHER_CONTEXT, - ) -> EXCEPTION_DISPOSITION; + pub fn _bittest(Base: *const LONG, Offset: LONG) -> BOOLEAN; } extern "C" { - pub fn _exception_code() -> ::std::os::raw::c_ulong; + pub fn _bittestandcomplement(Base: *mut LONG, Offset: LONG) -> BOOLEAN; } extern "C" { - pub fn _exception_info() -> *mut ::std::os::raw::c_void; + pub fn _bittestandset(Base: *mut LONG, Offset: LONG) -> BOOLEAN; } extern "C" { - pub fn _abnormal_termination() -> ::std::os::raw::c_int; + pub fn _bittestandreset(Base: *mut LONG, Offset: LONG) -> BOOLEAN; } -pub type __gnuc_va_list = __builtin_va_list; -pub type ULONG = ::std::os::raw::c_ulong; -pub type PULONG = *mut ULONG; -pub type USHORT = ::std::os::raw::c_ushort; -pub type PUSHORT = *mut USHORT; -pub type UCHAR = ::std::os::raw::c_uchar; -pub type PUCHAR = *mut UCHAR; -pub type PSZ = *mut ::std::os::raw::c_char; -pub type DWORD = ::std::os::raw::c_ulong; -pub type BOOL = ::std::os::raw::c_int; -pub type BYTE = ::std::os::raw::c_uchar; -pub type WORD = ::std::os::raw::c_ushort; -pub type FLOAT = f32; -pub type PFLOAT = *mut FLOAT; -pub type PBOOL = *mut BOOL; -pub type LPBOOL = *mut BOOL; -pub type PBYTE = *mut BYTE; -pub type LPBYTE = *mut BYTE; -pub type PINT = *mut ::std::os::raw::c_int; -pub type LPINT = *mut ::std::os::raw::c_int; -pub type PWORD = *mut WORD; -pub type LPWORD = *mut WORD; -pub type LPLONG = *mut ::std::os::raw::c_long; -pub type PDWORD = *mut DWORD; -pub type LPDWORD = *mut DWORD; -pub type LPVOID = *mut ::std::os::raw::c_void; -pub type LPCVOID = *const ::std::os::raw::c_void; -pub type INT = ::std::os::raw::c_int; -pub type UINT = ::std::os::raw::c_uint; -pub type PUINT = *mut ::std::os::raw::c_uint; extern "C" { - pub fn __pctype_func() -> *const ::std::os::raw::c_ushort; + pub fn _interlockedbittestandset(Base: *mut LONG, Offset: LONG) -> BOOLEAN; } extern "C" { - pub fn __pwctype_func() -> *const wctype_t; + pub fn _interlockedbittestandreset(Base: *mut LONG, Offset: LONG) -> BOOLEAN; } extern "C" { - pub fn iswalnum(_C: wint_t) -> ::std::os::raw::c_int; + pub fn _bittest64(Base: *const LONG64, Offset: LONG64) -> BOOLEAN; } extern "C" { - pub fn iswalpha(_C: wint_t) -> ::std::os::raw::c_int; + pub fn _bittestandcomplement64(Base: *mut LONG64, Offset: LONG64) -> BOOLEAN; } extern "C" { - pub fn iswascii(_C: wint_t) -> ::std::os::raw::c_int; + pub fn _bittestandset64(Base: *mut LONG64, Offset: LONG64) -> BOOLEAN; } extern "C" { - pub fn iswblank(_C: wint_t) -> ::std::os::raw::c_int; + pub fn _bittestandreset64(Base: *mut LONG64, Offset: LONG64) -> BOOLEAN; } extern "C" { - pub fn iswcntrl(_C: wint_t) -> ::std::os::raw::c_int; + pub fn _interlockedbittestandset64(Base: *mut LONG64, Offset: LONG64) -> BOOLEAN; } extern "C" { - pub fn iswdigit(_C: wint_t) -> ::std::os::raw::c_int; + pub fn _interlockedbittestandreset64(Base: *mut LONG64, Offset: LONG64) -> BOOLEAN; } extern "C" { - pub fn iswgraph(_C: wint_t) -> ::std::os::raw::c_int; + pub fn _BitScanForward(Index: *mut DWORD, Mask: DWORD) -> BOOLEAN; } extern "C" { - pub fn iswlower(_C: wint_t) -> ::std::os::raw::c_int; + pub fn _BitScanReverse(Index: *mut DWORD, Mask: DWORD) -> BOOLEAN; } extern "C" { - pub fn iswprint(_C: wint_t) -> ::std::os::raw::c_int; + pub fn _BitScanForward64(Index: *mut DWORD, Mask: DWORD64) -> BOOLEAN; } extern "C" { - pub fn iswpunct(_C: wint_t) -> ::std::os::raw::c_int; + pub fn _BitScanReverse64(Index: *mut DWORD, Mask: DWORD64) -> BOOLEAN; } extern "C" { - pub fn iswspace(_C: wint_t) -> ::std::os::raw::c_int; + pub fn _InterlockedIncrement16(Addend: *mut SHORT) -> SHORT; } extern "C" { - pub fn iswupper(_C: wint_t) -> ::std::os::raw::c_int; + pub fn _InterlockedDecrement16(Addend: *mut SHORT) -> SHORT; } extern "C" { - pub fn iswxdigit(_C: wint_t) -> ::std::os::raw::c_int; + pub fn _InterlockedCompareExchange16( + Destination: *mut SHORT, + ExChange: SHORT, + Comperand: SHORT, + ) -> SHORT; } extern "C" { - pub fn __iswcsymf(_C: wint_t) -> ::std::os::raw::c_int; + pub fn _InterlockedAnd(Destination: *mut LONG, Value: LONG) -> LONG; } extern "C" { - pub fn __iswcsym(_C: wint_t) -> ::std::os::raw::c_int; + pub fn _InterlockedOr(Destination: *mut LONG, Value: LONG) -> LONG; } extern "C" { - pub fn _iswalnum_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn _InterlockedXor(Destination: *mut LONG, Value: LONG) -> LONG; } extern "C" { - pub fn _iswalpha_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn _InterlockedAnd64(Destination: *mut LONG64, Value: LONG64) -> LONG64; } extern "C" { - pub fn _iswblank_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn _InterlockedOr64(Destination: *mut LONG64, Value: LONG64) -> LONG64; } extern "C" { - pub fn _iswcntrl_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn _InterlockedXor64(Destination: *mut LONG64, Value: LONG64) -> LONG64; } extern "C" { - pub fn _iswdigit_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn _InterlockedIncrement(Addend: *mut LONG) -> LONG; } extern "C" { - pub fn _iswgraph_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn _InterlockedDecrement(Addend: *mut LONG) -> LONG; } extern "C" { - pub fn _iswlower_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn _InterlockedExchange(Target: *mut LONG, Value: LONG) -> LONG; } extern "C" { - pub fn _iswprint_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn _InterlockedExchangeAdd(Addend: *mut LONG, Value: LONG) -> LONG; } extern "C" { - pub fn _iswpunct_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn _InterlockedCompareExchange( + Destination: *mut LONG, + ExChange: LONG, + Comperand: LONG, + ) -> LONG; } extern "C" { - pub fn _iswspace_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn _InterlockedIncrement64(Addend: *mut LONG64) -> LONG64; } extern "C" { - pub fn _iswupper_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn _InterlockedDecrement64(Addend: *mut LONG64) -> LONG64; } extern "C" { - pub fn _iswxdigit_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn _InterlockedExchange64(Target: *mut LONG64, Value: LONG64) -> LONG64; } extern "C" { - pub fn _iswcsymf_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn _InterlockedExchangeAdd64(Addend: *mut LONG64, Value: LONG64) -> LONG64; } extern "C" { - pub fn _iswcsym_l(_C: wint_t, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn _InterlockedCompareExchange64( + Destination: *mut LONG64, + ExChange: LONG64, + Comperand: LONG64, + ) -> LONG64; } extern "C" { - pub fn towupper(_C: wint_t) -> wint_t; + pub fn _InterlockedCompareExchange128( + Destination: *mut LONG64, + ExchangeHigh: LONG64, + ExchangeLow: LONG64, + ComparandResult: *mut LONG64, + ) -> BOOLEAN; } extern "C" { - pub fn towlower(_C: wint_t) -> wint_t; + pub fn _InterlockedCompareExchangePointer( + Destination: *mut PVOID, + Exchange: PVOID, + Comperand: PVOID, + ) -> PVOID; } extern "C" { - pub fn iswctype(_C: wint_t, _Type: wctype_t) -> ::std::os::raw::c_int; + pub fn _InterlockedExchangePointer(Target: *mut PVOID, Value: PVOID) -> PVOID; } extern "C" { - pub fn _towupper_l(_C: wint_t, _Locale: _locale_t) -> wint_t; + pub fn _InterlockedExchange8(Target: *mut CHAR, Value: CHAR) -> CHAR; } extern "C" { - pub fn _towlower_l(_C: wint_t, _Locale: _locale_t) -> wint_t; + pub fn _InterlockedExchange16(Destination: *mut SHORT, ExChange: SHORT) -> SHORT; } extern "C" { - pub fn _iswctype_l(_C: wint_t, _Type: wctype_t, _Locale: _locale_t) -> ::std::os::raw::c_int; + 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 isleadbyte(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn _InterlockedAnd8( + Destination: *mut ::std::os::raw::c_char, + Value: ::std::os::raw::c_char, + ) -> ::std::os::raw::c_char; } extern "C" { - pub fn _isleadbyte_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn _InterlockedOr8( + Destination: *mut ::std::os::raw::c_char, + Value: ::std::os::raw::c_char, + ) -> ::std::os::raw::c_char; } extern "C" { - pub fn is_wctype(_C: wint_t, _Type: wctype_t) -> ::std::os::raw::c_int; + pub fn _InterlockedXor8( + Destination: *mut ::std::os::raw::c_char, + Value: ::std::os::raw::c_char, + ) -> ::std::os::raw::c_char; } extern "C" { - pub fn _isctype( - _C: ::std::os::raw::c_int, - _Type: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn _InterlockedAnd16(Destination: *mut SHORT, Value: SHORT) -> SHORT; } extern "C" { - pub fn _isctype_l( - _C: ::std::os::raw::c_int, - _Type: ::std::os::raw::c_int, - _Locale: _locale_t, - ) -> ::std::os::raw::c_int; + pub fn _InterlockedOr16(Destination: *mut SHORT, Value: SHORT) -> SHORT; } extern "C" { - pub fn isalpha(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn _InterlockedXor16(Destination: *mut SHORT, Value: SHORT) -> SHORT; } extern "C" { - pub fn _isalpha_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn __cpuidex( + CPUInfo: *mut ::std::os::raw::c_int, + Function: ::std::os::raw::c_int, + SubLeaf: ::std::os::raw::c_int, + ); } extern "C" { - pub fn isupper(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn _mm_clflush(Address: *const ::std::os::raw::c_void); } extern "C" { - pub fn _isupper_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn _ReadWriteBarrier(); } extern "C" { - pub fn islower(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn __faststorefence(); } extern "C" { - pub fn _islower_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn _mm_lfence(); } extern "C" { - pub fn isdigit(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn _mm_mfence(); } extern "C" { - pub fn _isdigit_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn _mm_sfence(); } extern "C" { - pub fn isxdigit(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn _mm_pause(); } extern "C" { - pub fn _isxdigit_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn _mm_prefetch(a: *const CHAR, sel: ::std::os::raw::c_int); } extern "C" { - pub fn isspace(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn _m_prefetchw(Source: *const ::std::os::raw::c_void); } extern "C" { - pub fn _isspace_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn _mm_getcsr() -> ::std::os::raw::c_uint; } extern "C" { - pub fn ispunct(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn _mm_setcsr(MxCsr: ::std::os::raw::c_uint); } extern "C" { - pub fn _ispunct_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn __getcallerseflags() -> ::std::os::raw::c_uint; } extern "C" { - pub fn isblank(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn __segmentlimit(Selector: DWORD) -> DWORD; } extern "C" { - pub fn _isblank_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn __readpmc(Counter: DWORD) -> DWORD64; } extern "C" { - pub fn isalnum(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn __rdtsc() -> DWORD64; } extern "C" { - pub fn _isalnum_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn __movsb(Destination: PBYTE, Source: *const BYTE, Count: SIZE_T); } extern "C" { - pub fn isprint(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn __movsw(Destination: PWORD, Source: *const WORD, Count: SIZE_T); } extern "C" { - pub fn _isprint_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn __movsd(Destination: PDWORD, Source: *const DWORD, Count: SIZE_T); } extern "C" { - pub fn isgraph(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn __movsq(Destination: PDWORD64, Source: *const DWORD64, Count: SIZE_T); } extern "C" { - pub fn _isgraph_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn __stosb(Destination: PBYTE, Value: BYTE, Count: SIZE_T); } extern "C" { - pub fn iscntrl(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn __stosw(Destination: PWORD, Value: WORD, Count: SIZE_T); } extern "C" { - pub fn _iscntrl_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn __stosd(Destination: PDWORD, Value: DWORD, Count: SIZE_T); } extern "C" { - pub fn toupper(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn __stosq(Destination: PDWORD64, Value: DWORD64, Count: SIZE_T); } extern "C" { - pub fn tolower(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn __mulh(Multiplier: LONG64, Multiplicand: LONG64) -> LONGLONG; } extern "C" { - pub fn _tolower(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn __umulh(Multiplier: DWORD64, Multiplicand: DWORD64) -> ULONGLONG; } extern "C" { - pub fn _tolower_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn __popcnt64(operand: DWORD64) -> DWORD64; } extern "C" { - pub fn _toupper(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn __shiftleft128(LowPart: DWORD64, HighPart: DWORD64, Shift: BYTE) -> DWORD64; } extern "C" { - pub fn _toupper_l(_C: ::std::os::raw::c_int, _Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn __shiftright128(LowPart: DWORD64, HighPart: DWORD64, Shift: BYTE) -> DWORD64; } extern "C" { - pub fn __isascii(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn _mul128(Multiplier: LONG64, Multiplicand: LONG64, HighProduct: *mut LONG64) -> LONG64; } extern "C" { - pub fn __toascii(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn UnsignedMultiply128( + Multiplier: DWORD64, + Multiplicand: DWORD64, + HighProduct: *mut DWORD64, + ) -> DWORD64; } extern "C" { - pub fn __iscsymf(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn _umul128( + Multiplier: DWORD64, + Multiplicand: DWORD64, + HighProduct: *mut DWORD64, + ) -> DWORD64; } extern "C" { - pub fn __iscsym(_C: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn __readgsbyte(Offset: DWORD) -> BYTE; } extern "C" { - pub fn ___mb_cur_max_func() -> ::std::os::raw::c_int; + pub fn __readgsword(Offset: DWORD) -> WORD; } extern "C" { - pub fn ___mb_cur_max_l_func(_Locale: _locale_t) -> ::std::os::raw::c_int; + pub fn __readgsdword(Offset: DWORD) -> DWORD; +} +extern "C" { + pub fn __readgsqword(Offset: DWORD) -> DWORD64; +} +extern "C" { + pub fn __writegsbyte(Offset: DWORD, Data: BYTE); +} +extern "C" { + pub fn __writegsword(Offset: DWORD, Data: WORD); +} +extern "C" { + pub fn __writegsdword(Offset: DWORD, Data: DWORD); +} +extern "C" { + pub fn __writegsqword(Offset: DWORD, Data: DWORD64); +} +extern "C" { + pub fn __incgsbyte(Offset: DWORD); +} +extern "C" { + pub fn __addgsbyte(Offset: DWORD, Value: BYTE); +} +extern "C" { + pub fn __incgsword(Offset: DWORD); +} +extern "C" { + pub fn __addgsword(Offset: DWORD, Value: WORD); +} +extern "C" { + pub fn __incgsdword(Offset: DWORD); +} +extern "C" { + pub fn __addgsdword(Offset: DWORD, Value: DWORD); +} +extern "C" { + pub fn __incgsqword(Offset: DWORD); +} +extern "C" { + pub fn __addgsqword(Offset: DWORD, Value: DWORD64); +} +pub type XMM_SAVE_AREA32 = XSAVE_FORMAT; +pub type PXMM_SAVE_AREA32 = *mut XSAVE_FORMAT; +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub struct _CONTEXT { + pub P1Home: DWORD64, + pub P2Home: DWORD64, + pub P3Home: DWORD64, + pub P4Home: DWORD64, + pub P5Home: DWORD64, + pub P6Home: DWORD64, + pub ContextFlags: DWORD, + pub MxCsr: DWORD, + pub SegCs: WORD, + pub SegDs: WORD, + pub SegEs: WORD, + pub SegFs: WORD, + pub SegGs: WORD, + pub SegSs: WORD, + pub EFlags: DWORD, + pub Dr0: DWORD64, + pub Dr1: DWORD64, + pub Dr2: DWORD64, + pub Dr3: DWORD64, + pub Dr6: DWORD64, + pub Dr7: DWORD64, + pub Rax: DWORD64, + pub Rcx: DWORD64, + pub Rdx: DWORD64, + pub Rbx: DWORD64, + pub Rsp: DWORD64, + pub Rbp: DWORD64, + pub Rsi: DWORD64, + pub Rdi: DWORD64, + pub R8: DWORD64, + pub R9: DWORD64, + pub R10: DWORD64, + pub R11: DWORD64, + pub R12: DWORD64, + pub R13: DWORD64, + pub R14: DWORD64, + pub R15: DWORD64, + pub Rip: DWORD64, + pub __bindgen_anon_1: _CONTEXT__bindgen_ty_1, + pub VectorRegister: [M128A; 26usize], + pub VectorControl: DWORD64, + pub DebugControl: DWORD64, + pub LastBranchToRip: DWORD64, + pub LastBranchFromRip: DWORD64, + pub LastExceptionToRip: DWORD64, + pub LastExceptionFromRip: DWORD64, +} +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub union _CONTEXT__bindgen_ty_1 { + pub FltSave: XMM_SAVE_AREA32, + pub __bindgen_anon_1: _CONTEXT__bindgen_ty_1__bindgen_ty_1, } -pub type POINTER_64_INT = ::std::os::raw::c_ulonglong; -pub type INT8 = ::std::os::raw::c_schar; -pub type PINT8 = *mut ::std::os::raw::c_schar; -pub type INT16 = ::std::os::raw::c_short; -pub type PINT16 = *mut ::std::os::raw::c_short; -pub type INT32 = ::std::os::raw::c_int; -pub type PINT32 = *mut ::std::os::raw::c_int; -pub type INT64 = ::std::os::raw::c_longlong; -pub type PINT64 = *mut ::std::os::raw::c_longlong; -pub type UINT8 = ::std::os::raw::c_uchar; -pub type PUINT8 = *mut ::std::os::raw::c_uchar; -pub type UINT16 = ::std::os::raw::c_ushort; -pub type PUINT16 = *mut ::std::os::raw::c_ushort; -pub type UINT32 = ::std::os::raw::c_uint; -pub type PUINT32 = *mut ::std::os::raw::c_uint; -pub type UINT64 = ::std::os::raw::c_ulonglong; -pub type PUINT64 = *mut ::std::os::raw::c_ulonglong; -pub type LONG32 = ::std::os::raw::c_int; -pub type PLONG32 = *mut ::std::os::raw::c_int; -pub type ULONG32 = ::std::os::raw::c_uint; -pub type PULONG32 = *mut ::std::os::raw::c_uint; -pub type DWORD32 = ::std::os::raw::c_uint; -pub type PDWORD32 = *mut ::std::os::raw::c_uint; -pub type INT_PTR = ::std::os::raw::c_longlong; -pub type PINT_PTR = *mut ::std::os::raw::c_longlong; -pub type UINT_PTR = ::std::os::raw::c_ulonglong; -pub type PUINT_PTR = *mut ::std::os::raw::c_ulonglong; -pub type LONG_PTR = ::std::os::raw::c_longlong; -pub type PLONG_PTR = *mut ::std::os::raw::c_longlong; -pub type ULONG_PTR = ::std::os::raw::c_ulonglong; -pub type PULONG_PTR = *mut ::std::os::raw::c_ulonglong; -pub type PHANDLE64 = *mut *mut ::std::os::raw::c_void; -pub type SHANDLE_PTR = ::std::os::raw::c_longlong; -pub type HANDLE_PTR = ::std::os::raw::c_ulonglong; -pub type UHALF_PTR = ::std::os::raw::c_uint; -pub type PUHALF_PTR = *mut ::std::os::raw::c_uint; -pub type HALF_PTR = ::std::os::raw::c_int; -pub type PHALF_PTR = *mut ::std::os::raw::c_int; -pub type SIZE_T = ULONG_PTR; -pub type PSIZE_T = *mut ULONG_PTR; -pub type SSIZE_T = LONG_PTR; -pub type PSSIZE_T = *mut LONG_PTR; -pub type DWORD_PTR = ULONG_PTR; -pub type PDWORD_PTR = *mut ULONG_PTR; -pub type LONG64 = ::std::os::raw::c_longlong; -pub type PLONG64 = *mut ::std::os::raw::c_longlong; -pub type ULONG64 = ::std::os::raw::c_ulonglong; -pub type PULONG64 = *mut ::std::os::raw::c_ulonglong; -pub type DWORD64 = ::std::os::raw::c_ulonglong; -pub type PDWORD64 = *mut ::std::os::raw::c_ulonglong; -pub type KAFFINITY = ULONG_PTR; -pub type PKAFFINITY = *mut KAFFINITY; -pub type PVOID = *mut ::std::os::raw::c_void; -pub type CHAR = ::std::os::raw::c_char; -pub type SHORT = ::std::os::raw::c_short; -pub type LONG = ::std::os::raw::c_long; -pub type WCHAR = u16; -pub type PWCHAR = *mut WCHAR; -pub type LPWCH = *mut WCHAR; -pub type PWCH = *mut WCHAR; -pub type LPCWCH = *const WCHAR; -pub type PCWCH = *const WCHAR; -pub type NWPSTR = *mut WCHAR; -pub type LPWSTR = *mut WCHAR; -pub type PWSTR = *mut WCHAR; -pub type PZPWSTR = *mut PWSTR; -pub type PCZPWSTR = *const PWSTR; -pub type LPUWSTR = *mut WCHAR; -pub type PUWSTR = *mut WCHAR; -pub type LPCWSTR = *const WCHAR; -pub type PCWSTR = *const WCHAR; -pub type PZPCWSTR = *mut PCWSTR; -pub type PCZPCWSTR = *const PCWSTR; -pub type LPCUWSTR = *const WCHAR; -pub type PCUWSTR = *const WCHAR; -pub type PZZWSTR = *mut WCHAR; -pub type PCZZWSTR = *const WCHAR; -pub type PUZZWSTR = *mut WCHAR; -pub type PCUZZWSTR = *const WCHAR; -pub type PNZWCH = *mut WCHAR; -pub type PCNZWCH = *const WCHAR; -pub type PUNZWCH = *mut WCHAR; -pub type PCUNZWCH = *const WCHAR; -pub type LPCWCHAR = *const WCHAR; -pub type PCWCHAR = *const WCHAR; -pub type LPCUWCHAR = *const WCHAR; -pub type PCUWCHAR = *const WCHAR; -pub type UCSCHAR = ::std::os::raw::c_ulong; -pub type PUCSCHAR = *mut UCSCHAR; -pub type PCUCSCHAR = *const UCSCHAR; -pub type PUCSSTR = *mut UCSCHAR; -pub type PUUCSSTR = *mut UCSCHAR; -pub type PCUCSSTR = *const UCSCHAR; -pub type PCUUCSSTR = *const UCSCHAR; -pub type PUUCSCHAR = *mut UCSCHAR; -pub type PCUUCSCHAR = *const UCSCHAR; -pub type PCHAR = *mut CHAR; -pub type LPCH = *mut CHAR; -pub type PCH = *mut CHAR; -pub type LPCCH = *const CHAR; -pub type PCCH = *const CHAR; -pub type NPSTR = *mut CHAR; -pub type LPSTR = *mut CHAR; -pub type PSTR = *mut CHAR; -pub type PZPSTR = *mut PSTR; -pub type PCZPSTR = *const PSTR; -pub type LPCSTR = *const CHAR; -pub type PCSTR = *const CHAR; -pub type PZPCSTR = *mut PCSTR; -pub type PCZPCSTR = *const PCSTR; -pub type PZZSTR = *mut CHAR; -pub type PCZZSTR = *const CHAR; -pub type PNZCH = *mut CHAR; -pub type PCNZCH = *const CHAR; -pub type TCHAR = ::std::os::raw::c_char; -pub type PTCHAR = *mut ::std::os::raw::c_char; -pub type TBYTE = ::std::os::raw::c_uchar; -pub type PTBYTE = *mut ::std::os::raw::c_uchar; -pub type LPTCH = LPCH; -pub type PTCH = LPCH; -pub type LPCTCH = LPCCH; -pub type PCTCH = LPCCH; -pub type PTSTR = LPSTR; -pub type LPTSTR = LPSTR; -pub type PUTSTR = LPSTR; -pub type LPUTSTR = LPSTR; -pub type PCTSTR = LPCSTR; -pub type LPCTSTR = LPCSTR; -pub type PCUTSTR = LPCSTR; -pub type LPCUTSTR = LPCSTR; -pub type PZZTSTR = PZZSTR; -pub type PUZZTSTR = PZZSTR; -pub type PCZZTSTR = PCZZSTR; -pub type PCUZZTSTR = PCZZSTR; -pub type PZPTSTR = PZPSTR; -pub type PNZTCH = PNZCH; -pub type PUNZTCH = PNZCH; -pub type PCNZTCH = PCNZCH; -pub type PCUNZTCH = PCNZCH; -pub type PSHORT = *mut SHORT; -pub type PLONG = *mut LONG; #[repr(C)] +#[repr(align(16))] #[derive(Debug, Copy, Clone)] -pub struct _PROCESSOR_NUMBER { - pub Group: WORD, - pub Number: BYTE, - pub Reserved: BYTE, +pub struct _CONTEXT__bindgen_ty_1__bindgen_ty_1 { + pub Header: [M128A; 2usize], + pub Legacy: [M128A; 8usize], + pub Xmm0: M128A, + pub Xmm1: M128A, + pub Xmm2: M128A, + pub Xmm3: M128A, + pub Xmm4: M128A, + pub Xmm5: M128A, + pub Xmm6: M128A, + pub Xmm7: M128A, + pub Xmm8: M128A, + pub Xmm9: M128A, + pub Xmm10: M128A, + pub Xmm11: M128A, + pub Xmm12: M128A, + pub Xmm13: M128A, + pub Xmm14: M128A, + pub Xmm15: M128A, } #[test] -fn bindgen_test_layout__PROCESSOR_NUMBER() { +fn bindgen_test_layout__CONTEXT__bindgen_ty_1__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_PROCESSOR_NUMBER>(), - 4usize, - concat!("Size of: ", stringify!(_PROCESSOR_NUMBER)) + ::std::mem::size_of::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>(), + 416usize, + concat!( + "Size of: ", + stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1) + ) ); assert_eq!( - ::std::mem::align_of::<_PROCESSOR_NUMBER>(), - 2usize, - concat!("Alignment of ", stringify!(_PROCESSOR_NUMBER)) + ::std::mem::align_of::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>(), + 16usize, + concat!( + "Alignment of ", + stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1) + ) ); - fn test_field_Group() { + fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_PROCESSOR_NUMBER>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Group) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_PROCESSOR_NUMBER), + stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Group) + stringify!(Header) ) ); } - test_field_Group(); - fn test_field_Number() { + test_field_Header(); + fn test_field_Legacy() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_PROCESSOR_NUMBER>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Number) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Legacy) as usize - ptr as usize }, - 2usize, + 32usize, concat!( "Offset of field: ", - stringify!(_PROCESSOR_NUMBER), + stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Number) + stringify!(Legacy) ) ); } - test_field_Number(); - fn test_field_Reserved() { + test_field_Legacy(); + fn test_field_Xmm0() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_PROCESSOR_NUMBER>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm0) as usize - ptr as usize }, - 3usize, + 160usize, concat!( "Offset of field: ", - stringify!(_PROCESSOR_NUMBER), + stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Reserved) + stringify!(Xmm0) ) ); } - test_field_Reserved(); -} -pub type PROCESSOR_NUMBER = _PROCESSOR_NUMBER; -pub type PPROCESSOR_NUMBER = *mut _PROCESSOR_NUMBER; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _GROUP_AFFINITY { - pub Mask: KAFFINITY, - pub Group: WORD, - pub Reserved: [WORD; 3usize], -} -#[test] -fn bindgen_test_layout__GROUP_AFFINITY() { - assert_eq!( - ::std::mem::size_of::<_GROUP_AFFINITY>(), - 16usize, - concat!("Size of: ", stringify!(_GROUP_AFFINITY)) - ); - assert_eq!( - ::std::mem::align_of::<_GROUP_AFFINITY>(), - 8usize, - concat!("Alignment of ", stringify!(_GROUP_AFFINITY)) - ); - fn test_field_Mask() { + test_field_Xmm0(); + fn test_field_Xmm1() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_GROUP_AFFINITY>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm1) as usize - ptr as usize }, - 0usize, + 176usize, concat!( "Offset of field: ", - stringify!(_GROUP_AFFINITY), + stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Mask) + stringify!(Xmm1) ) ); } - test_field_Mask(); - fn test_field_Group() { + test_field_Xmm1(); + fn test_field_Xmm2() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_GROUP_AFFINITY>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Group) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm2) as usize - ptr as usize }, - 8usize, + 192usize, concat!( "Offset of field: ", - stringify!(_GROUP_AFFINITY), + stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Group) + stringify!(Xmm2) ) ); } - test_field_Group(); - fn test_field_Reserved() { + test_field_Xmm2(); + fn test_field_Xmm3() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_GROUP_AFFINITY>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm3) as usize - ptr as usize }, - 10usize, + 208usize, concat!( "Offset of field: ", - stringify!(_GROUP_AFFINITY), + stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Reserved) + stringify!(Xmm3) ) ); } - test_field_Reserved(); -} -pub type GROUP_AFFINITY = _GROUP_AFFINITY; -pub type PGROUP_AFFINITY = *mut _GROUP_AFFINITY; -pub type HANDLE = *mut ::std::os::raw::c_void; -pub type PHANDLE = *mut HANDLE; -pub type FCHAR = BYTE; -pub type FSHORT = WORD; -pub type FLONG = DWORD; -pub type HRESULT = ::std::os::raw::c_long; -pub type CCHAR = ::std::os::raw::c_char; -pub type LCID = DWORD; -pub type PLCID = PDWORD; -pub type LANGID = WORD; -#[repr(i32)] -#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] -pub enum COMPARTMENT_ID { - UNSPECIFIED_COMPARTMENT_ID = 0, - DEFAULT_COMPARTMENT_ID = 1, -} -pub type PCOMPARTMENT_ID = *mut COMPARTMENT_ID; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _FLOAT128 { - pub LowPart: ::std::os::raw::c_longlong, - pub HighPart: ::std::os::raw::c_longlong, -} -#[test] -fn bindgen_test_layout__FLOAT128() { - assert_eq!( - ::std::mem::size_of::<_FLOAT128>(), - 16usize, - concat!("Size of: ", stringify!(_FLOAT128)) - ); - assert_eq!( - ::std::mem::align_of::<_FLOAT128>(), - 8usize, - concat!("Alignment of ", stringify!(_FLOAT128)) - ); - fn test_field_LowPart() { + test_field_Xmm3(); + fn test_field_Xmm4() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_FLOAT128>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).LowPart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm4) as usize - ptr as usize }, - 0usize, + 224usize, concat!( "Offset of field: ", - stringify!(_FLOAT128), + stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(LowPart) + stringify!(Xmm4) ) ); } - test_field_LowPart(); - fn test_field_HighPart() { + test_field_Xmm4(); + fn test_field_Xmm5() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_FLOAT128>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).HighPart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm5) as usize - ptr as usize }, - 8usize, + 240usize, concat!( "Offset of field: ", - stringify!(_FLOAT128), + stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(HighPart) + stringify!(Xmm5) ) ); } - test_field_HighPart(); -} -pub type FLOAT128 = _FLOAT128; -pub type PFLOAT128 = *mut FLOAT128; -pub type LONGLONG = ::std::os::raw::c_longlong; -pub type ULONGLONG = ::std::os::raw::c_ulonglong; -pub type PLONGLONG = *mut LONGLONG; -pub type PULONGLONG = *mut ULONGLONG; -pub type USN = LONGLONG; -#[repr(C)] -#[derive(Copy, Clone)] -pub union _LARGE_INTEGER { - pub __bindgen_anon_1: _LARGE_INTEGER__bindgen_ty_1, - pub u: _LARGE_INTEGER__bindgen_ty_2, - pub QuadPart: LONGLONG, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _LARGE_INTEGER__bindgen_ty_1 { - pub LowPart: DWORD, - pub HighPart: LONG, -} -#[test] -fn bindgen_test_layout__LARGE_INTEGER__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_LARGE_INTEGER__bindgen_ty_1>(), - 8usize, - concat!("Size of: ", stringify!(_LARGE_INTEGER__bindgen_ty_1)) - ); - assert_eq!( - ::std::mem::align_of::<_LARGE_INTEGER__bindgen_ty_1>(), - 4usize, - concat!("Alignment of ", stringify!(_LARGE_INTEGER__bindgen_ty_1)) - ); - fn test_field_LowPart() { + test_field_Xmm5(); + fn test_field_Xmm6() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_LARGE_INTEGER__bindgen_ty_1>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).LowPart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm6) as usize - ptr as usize }, - 0usize, + 256usize, concat!( "Offset of field: ", - stringify!(_LARGE_INTEGER__bindgen_ty_1), + stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(LowPart) + stringify!(Xmm6) ) ); } - test_field_LowPart(); - fn test_field_HighPart() { + test_field_Xmm6(); + fn test_field_Xmm7() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_LARGE_INTEGER__bindgen_ty_1>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).HighPart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm7) as usize - ptr as usize }, - 4usize, + 272usize, concat!( "Offset of field: ", - stringify!(_LARGE_INTEGER__bindgen_ty_1), + stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(HighPart) + stringify!(Xmm7) ) ); } - test_field_HighPart(); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _LARGE_INTEGER__bindgen_ty_2 { - pub LowPart: DWORD, - pub HighPart: LONG, -} -#[test] -fn bindgen_test_layout__LARGE_INTEGER__bindgen_ty_2() { - assert_eq!( - ::std::mem::size_of::<_LARGE_INTEGER__bindgen_ty_2>(), - 8usize, - concat!("Size of: ", stringify!(_LARGE_INTEGER__bindgen_ty_2)) - ); - assert_eq!( - ::std::mem::align_of::<_LARGE_INTEGER__bindgen_ty_2>(), - 4usize, - concat!("Alignment of ", stringify!(_LARGE_INTEGER__bindgen_ty_2)) - ); - fn test_field_LowPart() { + test_field_Xmm7(); + fn test_field_Xmm8() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_LARGE_INTEGER__bindgen_ty_2>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).LowPart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm8) as usize - ptr as usize }, - 0usize, + 288usize, concat!( "Offset of field: ", - stringify!(_LARGE_INTEGER__bindgen_ty_2), + stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(LowPart) + stringify!(Xmm8) ) ); } - test_field_LowPart(); - fn test_field_HighPart() { + test_field_Xmm8(); + fn test_field_Xmm9() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_LARGE_INTEGER__bindgen_ty_2>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).HighPart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm9) as usize - ptr as usize }, - 4usize, + 304usize, concat!( "Offset of field: ", - stringify!(_LARGE_INTEGER__bindgen_ty_2), + stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(HighPart) + stringify!(Xmm9) ) ); } - test_field_HighPart(); -} -#[test] -fn bindgen_test_layout__LARGE_INTEGER() { - assert_eq!( - ::std::mem::size_of::<_LARGE_INTEGER>(), - 8usize, - concat!("Size of: ", stringify!(_LARGE_INTEGER)) - ); - assert_eq!( - ::std::mem::align_of::<_LARGE_INTEGER>(), - 8usize, - concat!("Alignment of ", stringify!(_LARGE_INTEGER)) - ); - fn test_field_u() { + test_field_Xmm9(); + fn test_field_Xmm10() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_LARGE_INTEGER>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm10) as usize - ptr as usize }, - 0usize, + 320usize, concat!( "Offset of field: ", - stringify!(_LARGE_INTEGER), + stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(u) + stringify!(Xmm10) ) ); } - test_field_u(); - fn test_field_QuadPart() { + test_field_Xmm10(); + fn test_field_Xmm11() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_LARGE_INTEGER>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).QuadPart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm11) as usize - ptr as usize }, - 0usize, + 336usize, concat!( "Offset of field: ", - stringify!(_LARGE_INTEGER), + stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(QuadPart) + stringify!(Xmm11) ) ); } - test_field_QuadPart(); -} -pub type LARGE_INTEGER = _LARGE_INTEGER; -pub type PLARGE_INTEGER = *mut LARGE_INTEGER; -#[repr(C)] -#[derive(Copy, Clone)] -pub union _ULARGE_INTEGER { - pub __bindgen_anon_1: _ULARGE_INTEGER__bindgen_ty_1, - pub u: _ULARGE_INTEGER__bindgen_ty_2, - pub QuadPart: ULONGLONG, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _ULARGE_INTEGER__bindgen_ty_1 { - pub LowPart: DWORD, - pub HighPart: DWORD, -} -#[test] -fn bindgen_test_layout__ULARGE_INTEGER__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_ULARGE_INTEGER__bindgen_ty_1>(), - 8usize, - concat!("Size of: ", stringify!(_ULARGE_INTEGER__bindgen_ty_1)) - ); - assert_eq!( - ::std::mem::align_of::<_ULARGE_INTEGER__bindgen_ty_1>(), - 4usize, - concat!("Alignment of ", stringify!(_ULARGE_INTEGER__bindgen_ty_1)) - ); - fn test_field_LowPart() { + test_field_Xmm11(); + fn test_field_Xmm12() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ULARGE_INTEGER__bindgen_ty_1>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).LowPart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm12) as usize - ptr as usize }, - 0usize, + 352usize, concat!( "Offset of field: ", - stringify!(_ULARGE_INTEGER__bindgen_ty_1), + stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(LowPart) + stringify!(Xmm12) ) ); } - test_field_LowPart(); - fn test_field_HighPart() { + test_field_Xmm12(); + fn test_field_Xmm13() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ULARGE_INTEGER__bindgen_ty_1>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).HighPart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm13) as usize - ptr as usize }, - 4usize, + 368usize, concat!( "Offset of field: ", - stringify!(_ULARGE_INTEGER__bindgen_ty_1), + stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(HighPart) + stringify!(Xmm13) ) ); } - test_field_HighPart(); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _ULARGE_INTEGER__bindgen_ty_2 { - pub LowPart: DWORD, - pub HighPart: DWORD, -} -#[test] -fn bindgen_test_layout__ULARGE_INTEGER__bindgen_ty_2() { - assert_eq!( - ::std::mem::size_of::<_ULARGE_INTEGER__bindgen_ty_2>(), - 8usize, - concat!("Size of: ", stringify!(_ULARGE_INTEGER__bindgen_ty_2)) - ); - assert_eq!( - ::std::mem::align_of::<_ULARGE_INTEGER__bindgen_ty_2>(), - 4usize, - concat!("Alignment of ", stringify!(_ULARGE_INTEGER__bindgen_ty_2)) - ); - fn test_field_LowPart() { + test_field_Xmm13(); + fn test_field_Xmm14() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ULARGE_INTEGER__bindgen_ty_2>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).LowPart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm14) as usize - ptr as usize }, - 0usize, + 384usize, concat!( "Offset of field: ", - stringify!(_ULARGE_INTEGER__bindgen_ty_2), + stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(LowPart) + stringify!(Xmm14) ) ); } - test_field_LowPart(); - fn test_field_HighPart() { + test_field_Xmm14(); + fn test_field_Xmm15() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ULARGE_INTEGER__bindgen_ty_2>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).HighPart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm15) as usize - ptr as usize }, - 4usize, + 400usize, concat!( "Offset of field: ", - stringify!(_ULARGE_INTEGER__bindgen_ty_2), + stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(HighPart) + stringify!(Xmm15) ) ); } - test_field_HighPart(); + test_field_Xmm15(); } #[test] -fn bindgen_test_layout__ULARGE_INTEGER() { +fn bindgen_test_layout__CONTEXT__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_ULARGE_INTEGER>(), - 8usize, - concat!("Size of: ", stringify!(_ULARGE_INTEGER)) + ::std::mem::size_of::<_CONTEXT__bindgen_ty_1>(), + 512usize, + concat!("Size of: ", stringify!(_CONTEXT__bindgen_ty_1)) ); assert_eq!( - ::std::mem::align_of::<_ULARGE_INTEGER>(), - 8usize, - concat!("Alignment of ", stringify!(_ULARGE_INTEGER)) + ::std::mem::align_of::<_CONTEXT__bindgen_ty_1>(), + 16usize, + concat!("Alignment of ", stringify!(_CONTEXT__bindgen_ty_1)) ); - fn test_field_u() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_ULARGE_INTEGER>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_ULARGE_INTEGER), - "::", - stringify!(u) - ) - ); - } - test_field_u(); - fn test_field_QuadPart() { + fn test_field_FltSave() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ULARGE_INTEGER>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).QuadPart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).FltSave) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_ULARGE_INTEGER), + stringify!(_CONTEXT__bindgen_ty_1), "::", - stringify!(QuadPart) + stringify!(FltSave) ) ); } - test_field_QuadPart(); -} -pub type ULARGE_INTEGER = _ULARGE_INTEGER; -pub type PULARGE_INTEGER = *mut ULARGE_INTEGER; -pub type RTL_REFERENCE_COUNT = LONG_PTR; -pub type PRTL_REFERENCE_COUNT = *mut LONG_PTR; -pub type RTL_REFERENCE_COUNT32 = LONG; -pub type PRTL_REFERENCE_COUNT32 = *mut LONG; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _LUID { - pub LowPart: DWORD, - pub HighPart: LONG, + test_field_FltSave(); } #[test] -fn bindgen_test_layout__LUID() { +fn bindgen_test_layout__CONTEXT() { assert_eq!( - ::std::mem::size_of::<_LUID>(), - 8usize, - concat!("Size of: ", stringify!(_LUID)) + ::std::mem::size_of::<_CONTEXT>(), + 1232usize, + concat!("Size of: ", stringify!(_CONTEXT)) ); assert_eq!( - ::std::mem::align_of::<_LUID>(), - 4usize, - concat!("Alignment of ", stringify!(_LUID)) + ::std::mem::align_of::<_CONTEXT>(), + 16usize, + concat!("Alignment of ", stringify!(_CONTEXT)) ); - fn test_field_LowPart() { + fn test_field_P1Home() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_LUID>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).LowPart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).P1Home) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_LUID), + stringify!(_CONTEXT), "::", - stringify!(LowPart) + stringify!(P1Home) ) ); } - test_field_LowPart(); - fn test_field_HighPart() { + test_field_P1Home(); + fn test_field_P2Home() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_LUID>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).HighPart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).P2Home) as usize - ptr as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", - stringify!(_LUID), + stringify!(_CONTEXT), "::", - stringify!(HighPart) + stringify!(P2Home) ) ); } - test_field_HighPart(); -} -pub type LUID = _LUID; -pub type PLUID = *mut _LUID; -pub type DWORDLONG = ULONGLONG; -pub type PDWORDLONG = *mut DWORDLONG; -extern "C" { - pub fn _rotl8( - Value: ::std::os::raw::c_uchar, - Shift: ::std::os::raw::c_uchar, - ) -> ::std::os::raw::c_uchar; -} -extern "C" { - pub fn _rotl16( - Value: ::std::os::raw::c_ushort, - Shift: ::std::os::raw::c_uchar, - ) -> ::std::os::raw::c_ushort; -} -extern "C" { - pub fn _rotr8( - Value: ::std::os::raw::c_uchar, - Shift: ::std::os::raw::c_uchar, - ) -> ::std::os::raw::c_uchar; -} -extern "C" { - pub fn _rotr16( - Value: ::std::os::raw::c_ushort, - Shift: ::std::os::raw::c_uchar, - ) -> ::std::os::raw::c_ushort; -} -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 _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 _rotr64( - Value: ::std::os::raw::c_ulonglong, - Shift: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_ulonglong; -} -pub type BOOLEAN = BYTE; -pub type PBOOLEAN = *mut BOOLEAN; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _LIST_ENTRY { - pub Flink: *mut _LIST_ENTRY, - pub Blink: *mut _LIST_ENTRY, -} -#[test] -fn bindgen_test_layout__LIST_ENTRY() { - assert_eq!( - ::std::mem::size_of::<_LIST_ENTRY>(), - 16usize, - concat!("Size of: ", stringify!(_LIST_ENTRY)) - ); - assert_eq!( - ::std::mem::align_of::<_LIST_ENTRY>(), - 8usize, - concat!("Alignment of ", stringify!(_LIST_ENTRY)) - ); - fn test_field_Flink() { + test_field_P2Home(); + fn test_field_P3Home() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_LIST_ENTRY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flink) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).P3Home) as usize - ptr as usize }, - 0usize, + 16usize, concat!( "Offset of field: ", - stringify!(_LIST_ENTRY), + stringify!(_CONTEXT), "::", - stringify!(Flink) + stringify!(P3Home) ) ); } - test_field_Flink(); - fn test_field_Blink() { + test_field_P3Home(); + fn test_field_P4Home() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_LIST_ENTRY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Blink) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).P4Home) as usize - ptr as usize }, - 8usize, + 24usize, concat!( "Offset of field: ", - stringify!(_LIST_ENTRY), + stringify!(_CONTEXT), "::", - stringify!(Blink) + stringify!(P4Home) ) ); } - test_field_Blink(); -} -pub type LIST_ENTRY = _LIST_ENTRY; -pub type PLIST_ENTRY = *mut _LIST_ENTRY; -pub type PRLIST_ENTRY = *mut _LIST_ENTRY; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SINGLE_LIST_ENTRY { - pub Next: *mut _SINGLE_LIST_ENTRY, -} -#[test] -fn bindgen_test_layout__SINGLE_LIST_ENTRY() { - assert_eq!( - ::std::mem::size_of::<_SINGLE_LIST_ENTRY>(), - 8usize, - concat!("Size of: ", stringify!(_SINGLE_LIST_ENTRY)) - ); - assert_eq!( - ::std::mem::align_of::<_SINGLE_LIST_ENTRY>(), - 8usize, - concat!("Alignment of ", stringify!(_SINGLE_LIST_ENTRY)) - ); - fn test_field_Next() { + test_field_P4Home(); + fn test_field_P5Home() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SINGLE_LIST_ENTRY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Next) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).P5Home) as usize - ptr as usize }, - 0usize, + 32usize, concat!( "Offset of field: ", - stringify!(_SINGLE_LIST_ENTRY), + stringify!(_CONTEXT), "::", - stringify!(Next) + stringify!(P5Home) ) ); } - test_field_Next(); -} -pub type SINGLE_LIST_ENTRY = _SINGLE_LIST_ENTRY; -pub type PSINGLE_LIST_ENTRY = *mut _SINGLE_LIST_ENTRY; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct LIST_ENTRY32 { - pub Flink: DWORD, - pub Blink: DWORD, -} -#[test] -fn bindgen_test_layout_LIST_ENTRY32() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(LIST_ENTRY32)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(LIST_ENTRY32)) - ); - fn test_field_Flink() { + test_field_P5Home(); + fn test_field_P6Home() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flink) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).P6Home) as usize - ptr as usize }, - 0usize, + 40usize, concat!( "Offset of field: ", - stringify!(LIST_ENTRY32), + stringify!(_CONTEXT), "::", - stringify!(Flink) + stringify!(P6Home) ) ); } - test_field_Flink(); - fn test_field_Blink() { + test_field_P6Home(); + fn test_field_ContextFlags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Blink) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ContextFlags) as usize - ptr as usize }, - 4usize, + 48usize, concat!( "Offset of field: ", - stringify!(LIST_ENTRY32), + stringify!(_CONTEXT), "::", - stringify!(Blink) + stringify!(ContextFlags) ) ); } - test_field_Blink(); -} -pub type PLIST_ENTRY32 = *mut LIST_ENTRY32; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct LIST_ENTRY64 { - pub Flink: ULONGLONG, - pub Blink: ULONGLONG, -} -#[test] -fn bindgen_test_layout_LIST_ENTRY64() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(LIST_ENTRY64)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(LIST_ENTRY64)) - ); - fn test_field_Flink() { + test_field_ContextFlags(); + fn test_field_MxCsr() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flink) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).MxCsr) as usize - ptr as usize }, - 0usize, + 52usize, concat!( "Offset of field: ", - stringify!(LIST_ENTRY64), + stringify!(_CONTEXT), "::", - stringify!(Flink) + stringify!(MxCsr) ) ); } - test_field_Flink(); - fn test_field_Blink() { + test_field_MxCsr(); + fn test_field_SegCs() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Blink) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SegCs) as usize - ptr as usize }, - 8usize, + 56usize, concat!( "Offset of field: ", - stringify!(LIST_ENTRY64), + stringify!(_CONTEXT), "::", - stringify!(Blink) + stringify!(SegCs) ) ); } - test_field_Blink(); -} -pub type PLIST_ENTRY64 = *mut LIST_ENTRY64; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _GUID { - pub Data1: ::std::os::raw::c_ulong, - pub Data2: ::std::os::raw::c_ushort, - pub Data3: ::std::os::raw::c_ushort, - pub Data4: [::std::os::raw::c_uchar; 8usize], -} -#[test] -fn bindgen_test_layout__GUID() { - assert_eq!( - ::std::mem::size_of::<_GUID>(), - 16usize, - concat!("Size of: ", stringify!(_GUID)) - ); - assert_eq!( - ::std::mem::align_of::<_GUID>(), - 4usize, - concat!("Alignment of ", stringify!(_GUID)) - ); - fn test_field_Data1() { + test_field_SegCs(); + fn test_field_SegDs() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_GUID>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Data1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SegDs) as usize - ptr as usize }, - 0usize, + 58usize, concat!( "Offset of field: ", - stringify!(_GUID), + stringify!(_CONTEXT), "::", - stringify!(Data1) + stringify!(SegDs) ) ); } - test_field_Data1(); - fn test_field_Data2() { + test_field_SegDs(); + fn test_field_SegEs() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_GUID>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Data2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SegEs) as usize - ptr as usize }, - 4usize, + 60usize, concat!( "Offset of field: ", - stringify!(_GUID), + stringify!(_CONTEXT), "::", - stringify!(Data2) + stringify!(SegEs) ) ); } - test_field_Data2(); - fn test_field_Data3() { + test_field_SegEs(); + fn test_field_SegFs() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_GUID>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Data3) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SegFs) as usize - ptr as usize }, - 6usize, + 62usize, concat!( "Offset of field: ", - stringify!(_GUID), + stringify!(_CONTEXT), "::", - stringify!(Data3) + stringify!(SegFs) ) ); } - test_field_Data3(); - fn test_field_Data4() { + test_field_SegFs(); + fn test_field_SegGs() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_GUID>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Data4) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SegGs) as usize - ptr as usize }, - 8usize, + 64usize, concat!( "Offset of field: ", - stringify!(_GUID), + stringify!(_CONTEXT), "::", - stringify!(Data4) + stringify!(SegGs) ) ); } - test_field_Data4(); -} -pub type GUID = _GUID; -pub type LPGUID = *mut GUID; -pub type LPCGUID = *const GUID; -pub type IID = GUID; -pub type LPIID = *mut IID; -pub type CLSID = GUID; -pub type LPCLSID = *mut CLSID; -pub type FMTID = GUID; -pub type LPFMTID = *mut FMTID; -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 __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 memchr( - _Buf: *const ::std::os::raw::c_void, - _Val: ::std::os::raw::c_int, - _MaxCount: usize, - ) -> *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: usize, - ) -> ::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: usize, - ) -> *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: usize, - ) -> *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: usize, - ) -> *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: usize, - ) -> ::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: usize, - _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: usize, - ) -> *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: usize, - ) -> ::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) -> usize; -} -extern "C" { - pub fn wcslen(_String: *const u16) -> usize; -} -extern "C" { - pub fn wcsnlen(_Source: *const u16, _MaxCount: usize) -> usize; -} -extern "C" { - pub fn wcsncat(_Destination: *mut u16, _Source: *const u16, _Count: usize) -> *mut u16; -} -extern "C" { - pub fn wcsncmp( - _String1: *const u16, - _String2: *const u16, - _MaxCount: usize, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn wcsncpy(_Destination: *mut u16, _Source: *const u16, _Count: usize) -> *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) -> usize; -} -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: usize, - _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: usize, - _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: usize, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn _wcsnicmp_l( - _String1: *const u16, - _String2: *const u16, - _MaxCount: usize, - _Locale: _locale_t, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn _wcsnset_s( - _Destination: *mut u16, - _SizeInWords: usize, - _Value: u16, - _MaxCount: usize, - ) -> errno_t; -} -extern "C" { - pub fn _wcsnset(_String: *mut u16, _Value: u16, _MaxCount: usize) -> *mut u16; -} -extern "C" { - pub fn _wcsrev(_String: *mut u16) -> *mut u16; -} -extern "C" { - pub fn _wcsset_s(_Destination: *mut u16, _SizeInWords: usize, _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: usize) -> errno_t; -} -extern "C" { - pub fn _wcslwr(_String: *mut u16) -> *mut u16; -} -extern "C" { - pub fn _wcslwr_s_l(_String: *mut u16, _SizeInWords: usize, _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: usize) -> errno_t; -} -extern "C" { - pub fn _wcsupr(_String: *mut u16) -> *mut u16; -} -extern "C" { - pub fn _wcsupr_s_l(_String: *mut u16, _Size: usize, _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: usize) -> usize; -} -extern "C" { - pub fn _wcsxfrm_l( - _Destination: *mut u16, - _Source: *const u16, - _MaxCount: usize, - _Locale: _locale_t, - ) -> usize; -} -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: usize, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn _wcsncoll_l( - _String1: *const u16, - _String2: *const u16, - _MaxCount: usize, - _Locale: _locale_t, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn _wcsnicoll( - _String1: *const u16, - _String2: *const u16, - _MaxCount: usize, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn _wcsnicoll_l( - _String1: *const u16, - _String2: *const u16, - _MaxCount: usize, - _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: usize, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn wcsnset(_String: *mut u16, _Value: u16, _MaxCount: usize) -> *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: usize, - _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: usize, - ) -> *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, - ) -> usize; -} -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: usize, - _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) -> usize; -} -extern "C" { - pub fn _strlwr_s(_String: *mut ::std::os::raw::c_char, _Size: usize) -> 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: usize, - _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: usize, - ) -> *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: usize, - ) -> ::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: usize, - ) -> ::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: usize, - _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: usize, - ) -> ::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: usize, - _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: usize, - ) -> ::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: usize, - _Locale: _locale_t, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn __strncnt(_String: *const ::std::os::raw::c_char, _Count: usize) -> usize; -} -extern "C" { - pub fn strncpy( - _Destination: *mut ::std::os::raw::c_char, - _Source: *const ::std::os::raw::c_char, - _Count: usize, - ) -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn strnlen(_String: *const ::std::os::raw::c_char, _MaxCount: usize) -> usize; -} -extern "C" { - pub fn _strnset_s( - _String: *mut ::std::os::raw::c_char, - _SizeInBytes: usize, - _Value: ::std::os::raw::c_int, - _MaxCount: usize, - ) -> errno_t; -} -extern "C" { - pub fn _strnset( - _Destination: *mut ::std::os::raw::c_char, - _Value: ::std::os::raw::c_int, - _Count: usize, - ) -> *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: usize, - _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, - ) -> usize; -} -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: usize) -> 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: usize, - _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: usize, - ) -> usize; -} -extern "C" { - pub fn _strxfrm_l( - _Destination: *mut ::std::os::raw::c_char, - _Source: *const ::std::os::raw::c_char, - _MaxCount: usize, - _Locale: _locale_t, - ) -> usize; -} -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: usize, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn strnset( - _String: *mut ::std::os::raw::c_char, - _Value: ::std::os::raw::c_int, - _MaxCount: usize, - ) -> *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; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _OBJECTID { - pub Lineage: GUID, - pub Uniquifier: DWORD, -} -#[test] -fn bindgen_test_layout__OBJECTID() { - assert_eq!( - ::std::mem::size_of::<_OBJECTID>(), - 20usize, - concat!("Size of: ", stringify!(_OBJECTID)) - ); - assert_eq!( - ::std::mem::align_of::<_OBJECTID>(), - 4usize, - concat!("Alignment of ", stringify!(_OBJECTID)) - ); - fn test_field_Lineage() { + test_field_SegGs(); + fn test_field_SegSs() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_OBJECTID>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Lineage) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SegSs) as usize - ptr as usize }, - 0usize, + 66usize, concat!( "Offset of field: ", - stringify!(_OBJECTID), + stringify!(_CONTEXT), "::", - stringify!(Lineage) + stringify!(SegSs) ) ); } - test_field_Lineage(); - fn test_field_Uniquifier() { + test_field_SegSs(); + fn test_field_EFlags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_OBJECTID>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Uniquifier) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).EFlags) as usize - ptr as usize }, - 16usize, + 68usize, concat!( "Offset of field: ", - stringify!(_OBJECTID), + stringify!(_CONTEXT), "::", - stringify!(Uniquifier) + stringify!(EFlags) ) ); } - test_field_Uniquifier(); -} -pub type OBJECTID = _OBJECTID; -pub type PEXCEPTION_ROUTINE = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut _EXCEPTION_RECORD, - arg2: PVOID, - arg3: *mut _CONTEXT, - arg4: PVOID, - ) -> EXCEPTION_DISPOSITION, ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _ENUM_FLAG_SIZED_INTEGER { - pub _address: u8, -} -pub type _ENUM_FLAG_SIZED_INTEGER_type = u8; -pub type KSPIN_LOCK = ULONG_PTR; -pub type PKSPIN_LOCK = *mut KSPIN_LOCK; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _M128A { - pub Low: ULONGLONG, - pub High: LONGLONG, -} -#[test] -fn bindgen_test_layout__M128A() { - assert_eq!( - ::std::mem::size_of::<_M128A>(), - 16usize, - concat!("Size of: ", stringify!(_M128A)) - ); - assert_eq!( - ::std::mem::align_of::<_M128A>(), - 16usize, - concat!("Alignment of ", stringify!(_M128A)) - ); - fn test_field_Low() { + test_field_EFlags(); + fn test_field_Dr0() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_M128A>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Low) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Dr0) as usize - ptr as usize }, - 0usize, + 72usize, concat!( "Offset of field: ", - stringify!(_M128A), + stringify!(_CONTEXT), "::", - stringify!(Low) + stringify!(Dr0) ) ); } - test_field_Low(); - fn test_field_High() { + test_field_Dr0(); + fn test_field_Dr1() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_M128A>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).High) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Dr1) as usize - ptr as usize }, - 8usize, + 80usize, concat!( "Offset of field: ", - stringify!(_M128A), + stringify!(_CONTEXT), "::", - stringify!(High) + stringify!(Dr1) ) ); } - test_field_High(); -} -pub type M128A = _M128A; -pub type PM128A = *mut _M128A; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _XSAVE_FORMAT { - pub ControlWord: WORD, - pub StatusWord: WORD, - pub TagWord: BYTE, - pub Reserved1: BYTE, - pub ErrorOpcode: WORD, - pub ErrorOffset: DWORD, - pub ErrorSelector: WORD, - pub Reserved2: WORD, - pub DataOffset: DWORD, - pub DataSelector: WORD, - pub Reserved3: WORD, - pub MxCsr: DWORD, - pub MxCsr_Mask: DWORD, - pub FloatRegisters: [M128A; 8usize], - pub XmmRegisters: [M128A; 16usize], - pub Reserved4: [BYTE; 96usize], -} -#[test] -fn bindgen_test_layout__XSAVE_FORMAT() { - assert_eq!( - ::std::mem::size_of::<_XSAVE_FORMAT>(), - 512usize, - concat!("Size of: ", stringify!(_XSAVE_FORMAT)) - ); - assert_eq!( - ::std::mem::align_of::<_XSAVE_FORMAT>(), - 16usize, - concat!("Alignment of ", stringify!(_XSAVE_FORMAT)) - ); - fn test_field_ControlWord() { + test_field_Dr1(); + fn test_field_Dr2() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ControlWord) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Dr2) as usize - ptr as usize }, - 0usize, + 88usize, concat!( "Offset of field: ", - stringify!(_XSAVE_FORMAT), + stringify!(_CONTEXT), "::", - stringify!(ControlWord) + stringify!(Dr2) ) ); } - test_field_ControlWord(); - fn test_field_StatusWord() { + test_field_Dr2(); + fn test_field_Dr3() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).StatusWord) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Dr3) as usize - ptr as usize }, - 2usize, + 96usize, concat!( "Offset of field: ", - stringify!(_XSAVE_FORMAT), + stringify!(_CONTEXT), "::", - stringify!(StatusWord) + stringify!(Dr3) ) ); } - test_field_StatusWord(); - fn test_field_TagWord() { + test_field_Dr3(); + fn test_field_Dr6() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).TagWord) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Dr6) as usize - ptr as usize }, - 4usize, + 104usize, concat!( "Offset of field: ", - stringify!(_XSAVE_FORMAT), + stringify!(_CONTEXT), "::", - stringify!(TagWord) + stringify!(Dr6) ) ); } - test_field_TagWord(); - fn test_field_Reserved1() { + test_field_Dr6(); + fn test_field_Dr7() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Reserved1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Dr7) as usize - ptr as usize }, - 5usize, + 112usize, concat!( "Offset of field: ", - stringify!(_XSAVE_FORMAT), + stringify!(_CONTEXT), "::", - stringify!(Reserved1) + stringify!(Dr7) ) ); } - test_field_Reserved1(); - fn test_field_ErrorOpcode() { + test_field_Dr7(); + fn test_field_Rax() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ErrorOpcode) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Rax) as usize - ptr as usize }, - 6usize, + 120usize, concat!( "Offset of field: ", - stringify!(_XSAVE_FORMAT), + stringify!(_CONTEXT), "::", - stringify!(ErrorOpcode) + stringify!(Rax) ) ); } - test_field_ErrorOpcode(); - fn test_field_ErrorOffset() { + test_field_Rax(); + fn test_field_Rcx() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ErrorOffset) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Rcx) as usize - ptr as usize }, - 8usize, + 128usize, concat!( "Offset of field: ", - stringify!(_XSAVE_FORMAT), + stringify!(_CONTEXT), "::", - stringify!(ErrorOffset) + stringify!(Rcx) ) ); } - test_field_ErrorOffset(); - fn test_field_ErrorSelector() { + test_field_Rcx(); + fn test_field_Rdx() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ErrorSelector) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Rdx) as usize - ptr as usize }, - 12usize, + 136usize, concat!( "Offset of field: ", - stringify!(_XSAVE_FORMAT), + stringify!(_CONTEXT), "::", - stringify!(ErrorSelector) + stringify!(Rdx) ) ); } - test_field_ErrorSelector(); - fn test_field_Reserved2() { + test_field_Rdx(); + fn test_field_Rbx() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Reserved2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Rbx) as usize - ptr as usize }, - 14usize, + 144usize, concat!( "Offset of field: ", - stringify!(_XSAVE_FORMAT), + stringify!(_CONTEXT), "::", - stringify!(Reserved2) + stringify!(Rbx) ) ); } - test_field_Reserved2(); - fn test_field_DataOffset() { + test_field_Rbx(); + fn test_field_Rsp() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).DataOffset) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Rsp) as usize - ptr as usize }, - 16usize, + 152usize, concat!( "Offset of field: ", - stringify!(_XSAVE_FORMAT), + stringify!(_CONTEXT), "::", - stringify!(DataOffset) + stringify!(Rsp) ) ); } - test_field_DataOffset(); - fn test_field_DataSelector() { + test_field_Rsp(); + fn test_field_Rbp() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).DataSelector) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Rbp) as usize - ptr as usize }, - 20usize, + 160usize, concat!( "Offset of field: ", - stringify!(_XSAVE_FORMAT), + stringify!(_CONTEXT), "::", - stringify!(DataSelector) + stringify!(Rbp) ) ); } - test_field_DataSelector(); - fn test_field_Reserved3() { + test_field_Rbp(); + fn test_field_Rsi() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Reserved3) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Rsi) as usize - ptr as usize }, - 22usize, + 168usize, concat!( "Offset of field: ", - stringify!(_XSAVE_FORMAT), + stringify!(_CONTEXT), "::", - stringify!(Reserved3) + stringify!(Rsi) ) ); } - test_field_Reserved3(); - fn test_field_MxCsr() { + test_field_Rsi(); + fn test_field_Rdi() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).MxCsr) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Rdi) as usize - ptr as usize }, - 24usize, + 176usize, concat!( "Offset of field: ", - stringify!(_XSAVE_FORMAT), + stringify!(_CONTEXT), "::", - stringify!(MxCsr) + stringify!(Rdi) ) ); } - test_field_MxCsr(); - fn test_field_MxCsr_Mask() { + test_field_Rdi(); + fn test_field_R8() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).MxCsr_Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).R8) as usize - ptr as usize }, - 28usize, + 184usize, concat!( "Offset of field: ", - stringify!(_XSAVE_FORMAT), + stringify!(_CONTEXT), "::", - stringify!(MxCsr_Mask) + stringify!(R8) ) ); } - test_field_MxCsr_Mask(); - fn test_field_FloatRegisters() { + test_field_R8(); + fn test_field_R9() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).FloatRegisters) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).R9) as usize - ptr as usize }, - 32usize, + 192usize, concat!( "Offset of field: ", - stringify!(_XSAVE_FORMAT), + stringify!(_CONTEXT), "::", - stringify!(FloatRegisters) + stringify!(R9) ) ); } - test_field_FloatRegisters(); - fn test_field_XmmRegisters() { + test_field_R9(); + fn test_field_R10() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).XmmRegisters) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).R10) as usize - ptr as usize }, - 160usize, + 200usize, concat!( "Offset of field: ", - stringify!(_XSAVE_FORMAT), + stringify!(_CONTEXT), "::", - stringify!(XmmRegisters) + stringify!(R10) ) ); } - test_field_XmmRegisters(); - fn test_field_Reserved4() { + test_field_R10(); + fn test_field_R11() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_FORMAT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Reserved4) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).R11) as usize - ptr as usize }, - 416usize, + 208usize, concat!( "Offset of field: ", - stringify!(_XSAVE_FORMAT), + stringify!(_CONTEXT), "::", - stringify!(Reserved4) + stringify!(R11) ) ); } - test_field_Reserved4(); -} -pub type XSAVE_FORMAT = _XSAVE_FORMAT; -pub type PXSAVE_FORMAT = *mut _XSAVE_FORMAT; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _XSAVE_CET_U_FORMAT { - pub Ia32CetUMsr: DWORD64, - pub Ia32Pl3SspMsr: DWORD64, -} -#[test] -fn bindgen_test_layout__XSAVE_CET_U_FORMAT() { - assert_eq!( - ::std::mem::size_of::<_XSAVE_CET_U_FORMAT>(), - 16usize, - concat!("Size of: ", stringify!(_XSAVE_CET_U_FORMAT)) - ); - assert_eq!( - ::std::mem::align_of::<_XSAVE_CET_U_FORMAT>(), - 8usize, - concat!("Alignment of ", stringify!(_XSAVE_CET_U_FORMAT)) - ); - fn test_field_Ia32CetUMsr() { + test_field_R11(); + fn test_field_R12() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_CET_U_FORMAT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Ia32CetUMsr) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).R12) as usize - ptr as usize }, - 0usize, + 216usize, concat!( "Offset of field: ", - stringify!(_XSAVE_CET_U_FORMAT), + stringify!(_CONTEXT), "::", - stringify!(Ia32CetUMsr) + stringify!(R12) ) ); } - test_field_Ia32CetUMsr(); - fn test_field_Ia32Pl3SspMsr() { + test_field_R12(); + fn test_field_R13() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_CET_U_FORMAT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Ia32Pl3SspMsr) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).R13) as usize - ptr as usize }, - 8usize, + 224usize, concat!( "Offset of field: ", - stringify!(_XSAVE_CET_U_FORMAT), + stringify!(_CONTEXT), "::", - stringify!(Ia32Pl3SspMsr) + stringify!(R13) ) ); } - test_field_Ia32Pl3SspMsr(); + test_field_R13(); + fn test_field_R14() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).R14) as usize - ptr as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(_CONTEXT), + "::", + stringify!(R14) + ) + ); + } + test_field_R14(); + fn test_field_R15() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).R15) as usize - ptr as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(_CONTEXT), + "::", + stringify!(R15) + ) + ); + } + test_field_R15(); + fn test_field_Rip() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Rip) as usize - ptr as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(_CONTEXT), + "::", + stringify!(Rip) + ) + ); + } + test_field_Rip(); + fn test_field_VectorRegister() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).VectorRegister) as usize - ptr as usize + }, + 768usize, + concat!( + "Offset of field: ", + stringify!(_CONTEXT), + "::", + stringify!(VectorRegister) + ) + ); + } + test_field_VectorRegister(); + fn test_field_VectorControl() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).VectorControl) as usize - ptr as usize + }, + 1184usize, + concat!( + "Offset of field: ", + stringify!(_CONTEXT), + "::", + stringify!(VectorControl) + ) + ); + } + test_field_VectorControl(); + fn test_field_DebugControl() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).DebugControl) as usize - ptr as usize + }, + 1192usize, + concat!( + "Offset of field: ", + stringify!(_CONTEXT), + "::", + stringify!(DebugControl) + ) + ); + } + test_field_DebugControl(); + fn test_field_LastBranchToRip() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).LastBranchToRip) as usize - ptr as usize + }, + 1200usize, + concat!( + "Offset of field: ", + stringify!(_CONTEXT), + "::", + stringify!(LastBranchToRip) + ) + ); + } + test_field_LastBranchToRip(); + fn test_field_LastBranchFromRip() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).LastBranchFromRip) as usize - ptr as usize + }, + 1208usize, + concat!( + "Offset of field: ", + stringify!(_CONTEXT), + "::", + stringify!(LastBranchFromRip) + ) + ); + } + test_field_LastBranchFromRip(); + fn test_field_LastExceptionToRip() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).LastExceptionToRip) as usize - ptr as usize + }, + 1216usize, + concat!( + "Offset of field: ", + stringify!(_CONTEXT), + "::", + stringify!(LastExceptionToRip) + ) + ); + } + test_field_LastExceptionToRip(); + fn test_field_LastExceptionFromRip() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).LastExceptionFromRip) as usize - ptr as usize + }, + 1224usize, + concat!( + "Offset of field: ", + stringify!(_CONTEXT), + "::", + stringify!(LastExceptionFromRip) + ) + ); + } + test_field_LastExceptionFromRip(); } -pub type XSAVE_CET_U_FORMAT = _XSAVE_CET_U_FORMAT; -pub type PXSAVE_CET_U_FORMAT = *mut _XSAVE_CET_U_FORMAT; +pub type CONTEXT = _CONTEXT; +pub type PCONTEXT = *mut _CONTEXT; +pub type RUNTIME_FUNCTION = _IMAGE_RUNTIME_FUNCTION_ENTRY; +pub type PRUNTIME_FUNCTION = *mut _IMAGE_RUNTIME_FUNCTION_ENTRY; +pub type SCOPE_TABLE = SCOPE_TABLE_AMD64; +pub type PSCOPE_TABLE = *mut SCOPE_TABLE_AMD64; +pub type GET_RUNTIME_FUNCTION_CALLBACK = ::std::option::Option< + unsafe extern "C" fn(ControlPc: DWORD64, Context: PVOID) -> PRUNTIME_FUNCTION, +>; +pub type PGET_RUNTIME_FUNCTION_CALLBACK = GET_RUNTIME_FUNCTION_CALLBACK; +pub type OUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK = ::std::option::Option< + unsafe extern "C" fn( + Process: HANDLE, + TableAddress: PVOID, + Entries: PDWORD, + Functions: *mut PRUNTIME_FUNCTION, + ) -> DWORD, +>; +pub type POUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK = OUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _XSAVE_AREA_HEADER { - pub Mask: DWORD64, - pub CompactionMask: DWORD64, - pub Reserved2: [DWORD64; 6usize], +pub struct _DISPATCHER_CONTEXT { + pub ControlPc: DWORD64, + pub ImageBase: DWORD64, + pub FunctionEntry: PRUNTIME_FUNCTION, + pub EstablisherFrame: DWORD64, + pub TargetIp: DWORD64, + pub ContextRecord: PCONTEXT, + pub LanguageHandler: PEXCEPTION_ROUTINE, + pub HandlerData: PVOID, + pub HistoryTable: *mut _UNWIND_HISTORY_TABLE, + pub ScopeIndex: DWORD, + pub Fill0: DWORD, } #[test] -fn bindgen_test_layout__XSAVE_AREA_HEADER() { +fn bindgen_test_layout__DISPATCHER_CONTEXT() { assert_eq!( - ::std::mem::size_of::<_XSAVE_AREA_HEADER>(), - 64usize, - concat!("Size of: ", stringify!(_XSAVE_AREA_HEADER)) + ::std::mem::size_of::<_DISPATCHER_CONTEXT>(), + 80usize, + concat!("Size of: ", stringify!(_DISPATCHER_CONTEXT)) ); assert_eq!( - ::std::mem::align_of::<_XSAVE_AREA_HEADER>(), + ::std::mem::align_of::<_DISPATCHER_CONTEXT>(), 8usize, - concat!("Alignment of ", stringify!(_XSAVE_AREA_HEADER)) + concat!("Alignment of ", stringify!(_DISPATCHER_CONTEXT)) ); - fn test_field_Mask() { + fn test_field_ControlPc() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_AREA_HEADER>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ControlPc) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_XSAVE_AREA_HEADER), + stringify!(_DISPATCHER_CONTEXT), "::", - stringify!(Mask) + stringify!(ControlPc) ) ); } - test_field_Mask(); - fn test_field_CompactionMask() { + test_field_ControlPc(); + fn test_field_ImageBase() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_AREA_HEADER>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).CompactionMask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ImageBase) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_XSAVE_AREA_HEADER), + stringify!(_DISPATCHER_CONTEXT), "::", - stringify!(CompactionMask) + stringify!(ImageBase) ) ); } - test_field_CompactionMask(); - fn test_field_Reserved2() { + test_field_ImageBase(); + fn test_field_FunctionEntry() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_AREA_HEADER>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Reserved2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).FunctionEntry) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", - stringify!(_XSAVE_AREA_HEADER), + stringify!(_DISPATCHER_CONTEXT), "::", - stringify!(Reserved2) + stringify!(FunctionEntry) ) ); } - test_field_Reserved2(); -} -pub type XSAVE_AREA_HEADER = _XSAVE_AREA_HEADER; -pub type PXSAVE_AREA_HEADER = *mut _XSAVE_AREA_HEADER; -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _XSAVE_AREA { - pub LegacyState: XSAVE_FORMAT, - pub Header: XSAVE_AREA_HEADER, -} -#[test] -fn bindgen_test_layout__XSAVE_AREA() { - assert_eq!( - ::std::mem::size_of::<_XSAVE_AREA>(), - 576usize, - concat!("Size of: ", stringify!(_XSAVE_AREA)) - ); - assert_eq!( - ::std::mem::align_of::<_XSAVE_AREA>(), - 16usize, - concat!("Alignment of ", stringify!(_XSAVE_AREA)) - ); - fn test_field_LegacyState() { + test_field_FunctionEntry(); + fn test_field_EstablisherFrame() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_AREA>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).LegacyState) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).EstablisherFrame) as usize - ptr as usize }, - 0usize, + 24usize, concat!( "Offset of field: ", - stringify!(_XSAVE_AREA), + stringify!(_DISPATCHER_CONTEXT), "::", - stringify!(LegacyState) + stringify!(EstablisherFrame) ) ); } - test_field_LegacyState(); - fn test_field_Header() { + test_field_EstablisherFrame(); + fn test_field_TargetIp() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSAVE_AREA>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).TargetIp) as usize - ptr as usize }, - 512usize, + 32usize, concat!( "Offset of field: ", - stringify!(_XSAVE_AREA), + stringify!(_DISPATCHER_CONTEXT), "::", - stringify!(Header) + stringify!(TargetIp) ) ); } - test_field_Header(); -} -pub type XSAVE_AREA = _XSAVE_AREA; -pub type PXSAVE_AREA = *mut _XSAVE_AREA; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _XSTATE_CONTEXT { - pub Mask: DWORD64, - pub Length: DWORD, - pub Reserved1: DWORD, - pub Area: PXSAVE_AREA, - pub Buffer: PVOID, -} -#[test] -fn bindgen_test_layout__XSTATE_CONTEXT() { - assert_eq!( - ::std::mem::size_of::<_XSTATE_CONTEXT>(), - 32usize, - concat!("Size of: ", stringify!(_XSTATE_CONTEXT)) - ); - assert_eq!( - ::std::mem::align_of::<_XSTATE_CONTEXT>(), - 8usize, - concat!("Alignment of ", stringify!(_XSTATE_CONTEXT)) - ); - fn test_field_Mask() { + test_field_TargetIp(); + fn test_field_ContextRecord() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSTATE_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ContextRecord) as usize - ptr as usize }, - 0usize, + 40usize, concat!( "Offset of field: ", - stringify!(_XSTATE_CONTEXT), + stringify!(_DISPATCHER_CONTEXT), "::", - stringify!(Mask) + stringify!(ContextRecord) ) ); } - test_field_Mask(); - fn test_field_Length() { + test_field_ContextRecord(); + fn test_field_LanguageHandler() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSTATE_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Length) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).LanguageHandler) as usize - ptr as usize }, - 8usize, + 48usize, concat!( "Offset of field: ", - stringify!(_XSTATE_CONTEXT), + stringify!(_DISPATCHER_CONTEXT), "::", - stringify!(Length) + stringify!(LanguageHandler) ) ); } - test_field_Length(); - fn test_field_Reserved1() { + test_field_LanguageHandler(); + fn test_field_HandlerData() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSTATE_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Reserved1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).HandlerData) as usize - ptr as usize }, - 12usize, + 56usize, concat!( "Offset of field: ", - stringify!(_XSTATE_CONTEXT), + stringify!(_DISPATCHER_CONTEXT), "::", - stringify!(Reserved1) + stringify!(HandlerData) ) ); } - test_field_Reserved1(); - fn test_field_Area() { + test_field_HandlerData(); + fn test_field_HistoryTable() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSTATE_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Area) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).HistoryTable) as usize - ptr as usize }, - 16usize, + 64usize, concat!( "Offset of field: ", - stringify!(_XSTATE_CONTEXT), + stringify!(_DISPATCHER_CONTEXT), "::", - stringify!(Area) + stringify!(HistoryTable) ) ); } - test_field_Area(); - fn test_field_Buffer() { + test_field_HistoryTable(); + fn test_field_ScopeIndex() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_XSTATE_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Buffer) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ScopeIndex) as usize - ptr as usize }, - 24usize, + 72usize, concat!( "Offset of field: ", - stringify!(_XSTATE_CONTEXT), + stringify!(_DISPATCHER_CONTEXT), "::", - stringify!(Buffer) + stringify!(ScopeIndex) ) ); } - test_field_Buffer(); + test_field_ScopeIndex(); + fn test_field_Fill0() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Fill0) as usize - ptr as usize + }, + 76usize, + concat!( + "Offset of field: ", + stringify!(_DISPATCHER_CONTEXT), + "::", + stringify!(Fill0) + ) + ); + } + test_field_Fill0(); } -pub type XSTATE_CONTEXT = _XSTATE_CONTEXT; -pub type PXSTATE_CONTEXT = *mut _XSTATE_CONTEXT; +pub type DISPATCHER_CONTEXT = _DISPATCHER_CONTEXT; +pub type PDISPATCHER_CONTEXT = *mut _DISPATCHER_CONTEXT; +pub type PEXCEPTION_FILTER = ::std::option::Option< + unsafe extern "C" fn( + ExceptionPointers: *mut _EXCEPTION_POINTERS, + EstablisherFrame: PVOID, + ) -> LONG, +>; +pub type PTERMINATION_HANDLER = ::std::option::Option< + unsafe extern "C" fn(_abnormal_termination: BOOLEAN, EstablisherFrame: PVOID), +>; #[repr(C)] #[derive(Copy, Clone)] -pub struct _KERNEL_CET_CONTEXT { - pub Ssp: DWORD64, - pub Rip: DWORD64, - pub SegCs: WORD, - pub __bindgen_anon_1: _KERNEL_CET_CONTEXT__bindgen_ty_1, - pub Fill: [WORD; 2usize], +pub struct _KNONVOLATILE_CONTEXT_POINTERS { + pub __bindgen_anon_1: _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1, + pub __bindgen_anon_2: _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2, } #[repr(C)] #[derive(Copy, Clone)] -pub union _KERNEL_CET_CONTEXT__bindgen_ty_1 { - pub AllFlags: WORD, - pub __bindgen_anon_1: _KERNEL_CET_CONTEXT__bindgen_ty_1__bindgen_ty_1, +pub union _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1 { + pub FloatingContext: [PM128A; 16usize], + pub __bindgen_anon_1: _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, } #[repr(C)] -#[repr(align(2))] #[derive(Debug, Copy, Clone)] -pub struct _KERNEL_CET_CONTEXT__bindgen_ty_1__bindgen_ty_1 { - pub _bitfield_align_1: [u16; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, +pub struct _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1 { + pub Xmm0: PM128A, + pub Xmm1: PM128A, + pub Xmm2: PM128A, + pub Xmm3: PM128A, + pub Xmm4: PM128A, + pub Xmm5: PM128A, + pub Xmm6: PM128A, + pub Xmm7: PM128A, + pub Xmm8: PM128A, + pub Xmm9: PM128A, + pub Xmm10: PM128A, + pub Xmm11: PM128A, + pub Xmm12: PM128A, + pub Xmm13: PM128A, + pub Xmm14: PM128A, + pub Xmm15: PM128A, } #[test] -fn bindgen_test_layout__KERNEL_CET_CONTEXT__bindgen_ty_1__bindgen_ty_1() { +fn bindgen_test_layout__KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_KERNEL_CET_CONTEXT__bindgen_ty_1__bindgen_ty_1>(), - 2usize, + ::std::mem::size_of::<_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1>(), + 128usize, concat!( "Size of: ", - stringify!(_KERNEL_CET_CONTEXT__bindgen_ty_1__bindgen_ty_1) + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1) ) ); assert_eq!( - ::std::mem::align_of::<_KERNEL_CET_CONTEXT__bindgen_ty_1__bindgen_ty_1>(), - 2usize, + ::std::mem::align_of::<_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1>(), + 8usize, concat!( "Alignment of ", - stringify!(_KERNEL_CET_CONTEXT__bindgen_ty_1__bindgen_ty_1) + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1) ) ); -} -impl _KERNEL_CET_CONTEXT__bindgen_ty_1__bindgen_ty_1 { - #[inline] - pub fn UseWrss(&self) -> WORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) } - } - #[inline] - pub fn set_UseWrss(&mut self, val: WORD) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub fn PopShadowStackOne(&self) -> WORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16) } + fn test_field_Xmm0() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + >::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Xmm0) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + "::", + stringify!(Xmm0) + ) + ); } - #[inline] - pub fn set_PopShadowStackOne(&mut self, val: WORD) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } + test_field_Xmm0(); + fn test_field_Xmm1() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + >::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Xmm1) as usize - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + "::", + stringify!(Xmm1) + ) + ); } - #[inline] - pub fn Unused(&self) -> WORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 14u8) as u16) } + test_field_Xmm1(); + fn test_field_Xmm2() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + >::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Xmm2) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + "::", + stringify!(Xmm2) + ) + ); } - #[inline] - pub fn set_Unused(&mut self, val: WORD) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 14u8, val as u64) - } + test_field_Xmm2(); + fn test_field_Xmm3() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + >::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Xmm3) as usize - ptr as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + "::", + stringify!(Xmm3) + ) + ); } - #[inline] - pub fn new_bitfield_1( - UseWrss: WORD, - PopShadowStackOne: WORD, - Unused: WORD, - ) -> __BindgenBitfieldUnit<[u8; 2usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let UseWrss: u16 = unsafe { ::std::mem::transmute(UseWrss) }; - UseWrss as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let PopShadowStackOne: u16 = unsafe { ::std::mem::transmute(PopShadowStackOne) }; - PopShadowStackOne as u64 - }); - __bindgen_bitfield_unit.set(2usize, 14u8, { - let Unused: u16 = unsafe { ::std::mem::transmute(Unused) }; - Unused as u64 - }); - __bindgen_bitfield_unit + test_field_Xmm3(); + fn test_field_Xmm4() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + >::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Xmm4) as usize - ptr as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + "::", + stringify!(Xmm4) + ) + ); } -} -#[test] -fn bindgen_test_layout__KERNEL_CET_CONTEXT__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_KERNEL_CET_CONTEXT__bindgen_ty_1>(), - 2usize, - concat!("Size of: ", stringify!(_KERNEL_CET_CONTEXT__bindgen_ty_1)) - ); - assert_eq!( - ::std::mem::align_of::<_KERNEL_CET_CONTEXT__bindgen_ty_1>(), - 2usize, - concat!( - "Alignment of ", - stringify!(_KERNEL_CET_CONTEXT__bindgen_ty_1) - ) - ); - fn test_field_AllFlags() { + test_field_Xmm4(); + fn test_field_Xmm5() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_KERNEL_CET_CONTEXT__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AllFlags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm5) as usize - ptr as usize }, - 0usize, + 40usize, concat!( "Offset of field: ", - stringify!(_KERNEL_CET_CONTEXT__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(AllFlags) + stringify!(Xmm5) ) ); } - test_field_AllFlags(); -} -#[test] -fn bindgen_test_layout__KERNEL_CET_CONTEXT() { - assert_eq!( - ::std::mem::size_of::<_KERNEL_CET_CONTEXT>(), - 24usize, - concat!("Size of: ", stringify!(_KERNEL_CET_CONTEXT)) - ); - assert_eq!( - ::std::mem::align_of::<_KERNEL_CET_CONTEXT>(), - 8usize, - concat!("Alignment of ", stringify!(_KERNEL_CET_CONTEXT)) - ); - fn test_field_Ssp() { + test_field_Xmm5(); + fn test_field_Xmm6() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_KERNEL_CET_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Ssp) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm6) as usize - ptr as usize }, - 0usize, + 48usize, concat!( "Offset of field: ", - stringify!(_KERNEL_CET_CONTEXT), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Ssp) + stringify!(Xmm6) ) ); } - test_field_Ssp(); - fn test_field_Rip() { + test_field_Xmm6(); + fn test_field_Xmm7() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_KERNEL_CET_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Rip) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm7) as usize - ptr as usize }, - 8usize, + 56usize, concat!( "Offset of field: ", - stringify!(_KERNEL_CET_CONTEXT), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Rip) + stringify!(Xmm7) ) ); } - test_field_Rip(); - fn test_field_SegCs() { + test_field_Xmm7(); + fn test_field_Xmm8() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_KERNEL_CET_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SegCs) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm8) as usize - ptr as usize }, - 16usize, + 64usize, concat!( "Offset of field: ", - stringify!(_KERNEL_CET_CONTEXT), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(SegCs) + stringify!(Xmm8) ) ); } - test_field_SegCs(); - fn test_field_Fill() { + test_field_Xmm8(); + fn test_field_Xmm9() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_KERNEL_CET_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Fill) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm9) as usize - ptr as usize }, - 20usize, + 72usize, concat!( "Offset of field: ", - stringify!(_KERNEL_CET_CONTEXT), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Fill) + stringify!(Xmm9) ) ); } - test_field_Fill(); -} -pub type KERNEL_CET_CONTEXT = _KERNEL_CET_CONTEXT; -pub type PKERNEL_CET_CONTEXT = *mut _KERNEL_CET_CONTEXT; -pub type __C_ASSERT__ = [::std::os::raw::c_char; 1usize]; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SCOPE_TABLE_AMD64 { - pub Count: DWORD, - pub ScopeRecord: [_SCOPE_TABLE_AMD64__bindgen_ty_1; 1usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SCOPE_TABLE_AMD64__bindgen_ty_1 { - pub BeginAddress: DWORD, - pub EndAddress: DWORD, - pub HandlerAddress: DWORD, - pub JumpTarget: DWORD, -} -#[test] -fn bindgen_test_layout__SCOPE_TABLE_AMD64__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_SCOPE_TABLE_AMD64__bindgen_ty_1>(), - 16usize, - concat!("Size of: ", stringify!(_SCOPE_TABLE_AMD64__bindgen_ty_1)) - ); - assert_eq!( - ::std::mem::align_of::<_SCOPE_TABLE_AMD64__bindgen_ty_1>(), - 4usize, - concat!( - "Alignment of ", - stringify!(_SCOPE_TABLE_AMD64__bindgen_ty_1) - ) - ); - fn test_field_BeginAddress() { + test_field_Xmm9(); + fn test_field_Xmm10() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_AMD64__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).BeginAddress) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm10) as usize - ptr as usize }, - 0usize, + 80usize, concat!( "Offset of field: ", - stringify!(_SCOPE_TABLE_AMD64__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(BeginAddress) + stringify!(Xmm10) ) ); } - test_field_BeginAddress(); - fn test_field_EndAddress() { + test_field_Xmm10(); + fn test_field_Xmm11() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_AMD64__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).EndAddress) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm11) as usize - ptr as usize }, - 4usize, + 88usize, concat!( "Offset of field: ", - stringify!(_SCOPE_TABLE_AMD64__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(EndAddress) + stringify!(Xmm11) ) ); } - test_field_EndAddress(); - fn test_field_HandlerAddress() { + test_field_Xmm11(); + fn test_field_Xmm12() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_AMD64__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).HandlerAddress) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm12) as usize - ptr as usize }, - 8usize, + 96usize, concat!( "Offset of field: ", - stringify!(_SCOPE_TABLE_AMD64__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(HandlerAddress) + stringify!(Xmm12) ) ); } - test_field_HandlerAddress(); - fn test_field_JumpTarget() { + test_field_Xmm12(); + fn test_field_Xmm13() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_AMD64__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).JumpTarget) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm13) as usize - ptr as usize }, - 12usize, + 104usize, concat!( "Offset of field: ", - stringify!(_SCOPE_TABLE_AMD64__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(JumpTarget) + stringify!(Xmm13) ) ); } - test_field_JumpTarget(); -} -#[test] -fn bindgen_test_layout__SCOPE_TABLE_AMD64() { - assert_eq!( - ::std::mem::size_of::<_SCOPE_TABLE_AMD64>(), - 20usize, - concat!("Size of: ", stringify!(_SCOPE_TABLE_AMD64)) - ); - assert_eq!( - ::std::mem::align_of::<_SCOPE_TABLE_AMD64>(), - 4usize, - concat!("Alignment of ", stringify!(_SCOPE_TABLE_AMD64)) - ); - fn test_field_Count() { + test_field_Xmm13(); + fn test_field_Xmm14() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_AMD64>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Count) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm14) as usize - ptr as usize }, - 0usize, + 112usize, concat!( "Offset of field: ", - stringify!(_SCOPE_TABLE_AMD64), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Count) + stringify!(Xmm14) ) ); } - test_field_Count(); - fn test_field_ScopeRecord() { + test_field_Xmm14(); + fn test_field_Xmm15() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_AMD64>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ScopeRecord) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Xmm15) as usize - ptr as usize }, - 4usize, + 120usize, concat!( "Offset of field: ", - stringify!(_SCOPE_TABLE_AMD64), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(ScopeRecord) + stringify!(Xmm15) ) ); } - test_field_ScopeRecord(); -} -pub type SCOPE_TABLE_AMD64 = _SCOPE_TABLE_AMD64; -pub type PSCOPE_TABLE_AMD64 = *mut _SCOPE_TABLE_AMD64; -extern "C" { - pub fn _bittest(Base: *const LONG, Offset: LONG) -> BOOLEAN; -} -extern "C" { - pub fn _bittestandcomplement(Base: *mut LONG, Offset: LONG) -> BOOLEAN; -} -extern "C" { - pub fn _bittestandset(Base: *mut LONG, Offset: LONG) -> BOOLEAN; -} -extern "C" { - pub fn _bittestandreset(Base: *mut LONG, Offset: LONG) -> BOOLEAN; -} -extern "C" { - pub fn _interlockedbittestandset(Base: *mut LONG, Offset: LONG) -> BOOLEAN; -} -extern "C" { - pub fn _interlockedbittestandreset(Base: *mut LONG, Offset: LONG) -> BOOLEAN; -} -extern "C" { - pub fn _bittest64(Base: *const LONG64, Offset: LONG64) -> BOOLEAN; -} -extern "C" { - pub fn _bittestandcomplement64(Base: *mut LONG64, Offset: LONG64) -> BOOLEAN; -} -extern "C" { - pub fn _bittestandset64(Base: *mut LONG64, Offset: LONG64) -> BOOLEAN; -} -extern "C" { - pub fn _bittestandreset64(Base: *mut LONG64, Offset: LONG64) -> BOOLEAN; -} -extern "C" { - pub fn _interlockedbittestandset64(Base: *mut LONG64, Offset: LONG64) -> BOOLEAN; -} -extern "C" { - pub fn _interlockedbittestandreset64(Base: *mut LONG64, Offset: LONG64) -> BOOLEAN; -} -extern "C" { - pub fn _BitScanForward(Index: *mut DWORD, Mask: DWORD) -> BOOLEAN; -} -extern "C" { - pub fn _BitScanReverse(Index: *mut DWORD, Mask: DWORD) -> BOOLEAN; -} -extern "C" { - pub fn _BitScanForward64(Index: *mut DWORD, Mask: DWORD64) -> BOOLEAN; -} -extern "C" { - pub fn _BitScanReverse64(Index: *mut DWORD, Mask: DWORD64) -> BOOLEAN; -} -extern "C" { - pub fn _InterlockedIncrement16(Addend: *mut SHORT) -> SHORT; -} -extern "C" { - pub fn _InterlockedDecrement16(Addend: *mut SHORT) -> SHORT; -} -extern "C" { - pub fn _InterlockedCompareExchange16( - Destination: *mut SHORT, - ExChange: SHORT, - Comperand: SHORT, - ) -> SHORT; -} -extern "C" { - pub fn _InterlockedAnd(Destination: *mut LONG, Value: LONG) -> LONG; -} -extern "C" { - pub fn _InterlockedOr(Destination: *mut LONG, Value: LONG) -> LONG; -} -extern "C" { - pub fn _InterlockedXor(Destination: *mut LONG, Value: LONG) -> LONG; -} -extern "C" { - pub fn _InterlockedAnd64(Destination: *mut LONG64, Value: LONG64) -> LONG64; -} -extern "C" { - pub fn _InterlockedOr64(Destination: *mut LONG64, Value: LONG64) -> LONG64; -} -extern "C" { - pub fn _InterlockedXor64(Destination: *mut LONG64, Value: LONG64) -> LONG64; -} -extern "C" { - pub fn _InterlockedIncrement(Addend: *mut LONG) -> LONG; -} -extern "C" { - pub fn _InterlockedDecrement(Addend: *mut LONG) -> LONG; -} -extern "C" { - pub fn _InterlockedExchange(Target: *mut LONG, Value: LONG) -> LONG; -} -extern "C" { - pub fn _InterlockedExchangeAdd(Addend: *mut LONG, Value: LONG) -> LONG; -} -extern "C" { - pub fn _InterlockedCompareExchange( - Destination: *mut LONG, - ExChange: LONG, - Comperand: LONG, - ) -> LONG; -} -extern "C" { - pub fn _InterlockedIncrement64(Addend: *mut LONG64) -> LONG64; -} -extern "C" { - pub fn _InterlockedDecrement64(Addend: *mut LONG64) -> LONG64; -} -extern "C" { - pub fn _InterlockedExchange64(Target: *mut LONG64, Value: LONG64) -> LONG64; -} -extern "C" { - pub fn _InterlockedExchangeAdd64(Addend: *mut LONG64, Value: LONG64) -> LONG64; -} -extern "C" { - pub fn _InterlockedCompareExchange64( - Destination: *mut LONG64, - ExChange: LONG64, - Comperand: LONG64, - ) -> LONG64; -} -extern "C" { - pub fn _InterlockedCompareExchange128( - Destination: *mut LONG64, - ExchangeHigh: LONG64, - ExchangeLow: LONG64, - ComparandResult: *mut LONG64, - ) -> BOOLEAN; -} -extern "C" { - pub fn _InterlockedCompareExchangePointer( - Destination: *mut PVOID, - Exchange: PVOID, - Comperand: PVOID, - ) -> PVOID; -} -extern "C" { - pub fn _InterlockedExchangePointer(Target: *mut PVOID, Value: PVOID) -> PVOID; -} -extern "C" { - pub fn _InterlockedExchange8(Target: *mut CHAR, Value: CHAR) -> CHAR; -} -extern "C" { - pub fn _InterlockedExchange16(Destination: *mut SHORT, ExChange: SHORT) -> SHORT; -} -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 _InterlockedAnd8( - Destination: *mut ::std::os::raw::c_char, - Value: ::std::os::raw::c_char, - ) -> ::std::os::raw::c_char; -} -extern "C" { - pub fn _InterlockedOr8( - Destination: *mut ::std::os::raw::c_char, - Value: ::std::os::raw::c_char, - ) -> ::std::os::raw::c_char; -} -extern "C" { - pub fn _InterlockedXor8( - Destination: *mut ::std::os::raw::c_char, - Value: ::std::os::raw::c_char, - ) -> ::std::os::raw::c_char; -} -extern "C" { - pub fn _InterlockedAnd16(Destination: *mut SHORT, Value: SHORT) -> SHORT; -} -extern "C" { - pub fn _InterlockedOr16(Destination: *mut SHORT, Value: SHORT) -> SHORT; -} -extern "C" { - pub fn _InterlockedXor16(Destination: *mut SHORT, Value: SHORT) -> SHORT; -} -extern "C" { - pub fn __cpuidex( - CPUInfo: *mut ::std::os::raw::c_int, - Function: ::std::os::raw::c_int, - SubLeaf: ::std::os::raw::c_int, - ); -} -extern "C" { - pub fn _mm_clflush(Address: *const ::std::os::raw::c_void); -} -extern "C" { - pub fn _ReadWriteBarrier(); -} -extern "C" { - pub fn __faststorefence(); -} -extern "C" { - pub fn _mm_lfence(); -} -extern "C" { - pub fn _mm_mfence(); -} -extern "C" { - pub fn _mm_sfence(); -} -extern "C" { - pub fn _mm_pause(); -} -extern "C" { - pub fn _mm_prefetch(a: *const CHAR, sel: ::std::os::raw::c_int); -} -extern "C" { - pub fn _m_prefetchw(Source: *const ::std::os::raw::c_void); -} -extern "C" { - pub fn _mm_getcsr() -> ::std::os::raw::c_uint; -} -extern "C" { - pub fn _mm_setcsr(MxCsr: ::std::os::raw::c_uint); -} -extern "C" { - pub fn __getcallerseflags() -> ::std::os::raw::c_uint; -} -extern "C" { - pub fn __segmentlimit(Selector: DWORD) -> DWORD; -} -extern "C" { - pub fn __readpmc(Counter: DWORD) -> DWORD64; -} -extern "C" { - pub fn __rdtsc() -> DWORD64; -} -extern "C" { - pub fn __movsb(Destination: PBYTE, Source: *const BYTE, Count: SIZE_T); -} -extern "C" { - pub fn __movsw(Destination: PWORD, Source: *const WORD, Count: SIZE_T); -} -extern "C" { - pub fn __movsd(Destination: PDWORD, Source: *const DWORD, Count: SIZE_T); -} -extern "C" { - pub fn __movsq(Destination: PDWORD64, Source: *const DWORD64, Count: SIZE_T); -} -extern "C" { - pub fn __stosb(Destination: PBYTE, Value: BYTE, Count: SIZE_T); -} -extern "C" { - pub fn __stosw(Destination: PWORD, Value: WORD, Count: SIZE_T); -} -extern "C" { - pub fn __stosd(Destination: PDWORD, Value: DWORD, Count: SIZE_T); -} -extern "C" { - pub fn __stosq(Destination: PDWORD64, Value: DWORD64, Count: SIZE_T); -} -extern "C" { - pub fn __mulh(Multiplier: LONG64, Multiplicand: LONG64) -> LONGLONG; -} -extern "C" { - pub fn __umulh(Multiplier: DWORD64, Multiplicand: DWORD64) -> ULONGLONG; -} -extern "C" { - pub fn __popcnt64(operand: DWORD64) -> DWORD64; -} -extern "C" { - pub fn __shiftleft128(LowPart: DWORD64, HighPart: DWORD64, Shift: BYTE) -> DWORD64; -} -extern "C" { - pub fn __shiftright128(LowPart: DWORD64, HighPart: DWORD64, Shift: BYTE) -> DWORD64; -} -extern "C" { - pub fn _mul128(Multiplier: LONG64, Multiplicand: LONG64, HighProduct: *mut LONG64) -> LONG64; -} -extern "C" { - pub fn UnsignedMultiply128( - Multiplier: DWORD64, - Multiplicand: DWORD64, - HighProduct: *mut DWORD64, - ) -> DWORD64; -} -extern "C" { - pub fn _umul128( - Multiplier: DWORD64, - Multiplicand: DWORD64, - HighProduct: *mut DWORD64, - ) -> DWORD64; -} -extern "C" { - pub fn __readgsbyte(Offset: DWORD) -> BYTE; -} -extern "C" { - pub fn __readgsword(Offset: DWORD) -> WORD; -} -extern "C" { - pub fn __readgsdword(Offset: DWORD) -> DWORD; -} -extern "C" { - pub fn __readgsqword(Offset: DWORD) -> DWORD64; -} -extern "C" { - pub fn __writegsbyte(Offset: DWORD, Data: BYTE); -} -extern "C" { - pub fn __writegsword(Offset: DWORD, Data: WORD); -} -extern "C" { - pub fn __writegsdword(Offset: DWORD, Data: DWORD); -} -extern "C" { - pub fn __writegsqword(Offset: DWORD, Data: DWORD64); -} -extern "C" { - pub fn __incgsbyte(Offset: DWORD); -} -extern "C" { - pub fn __addgsbyte(Offset: DWORD, Value: BYTE); -} -extern "C" { - pub fn __incgsword(Offset: DWORD); -} -extern "C" { - pub fn __addgsword(Offset: DWORD, Value: WORD); -} -extern "C" { - pub fn __incgsdword(Offset: DWORD); -} -extern "C" { - pub fn __addgsdword(Offset: DWORD, Value: DWORD); -} -extern "C" { - pub fn __incgsqword(Offset: DWORD); -} -extern "C" { - pub fn __addgsqword(Offset: DWORD, Value: DWORD64); -} -pub type XMM_SAVE_AREA32 = XSAVE_FORMAT; -pub type PXMM_SAVE_AREA32 = *mut XSAVE_FORMAT; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _CONTEXT { - pub P1Home: DWORD64, - pub P2Home: DWORD64, - pub P3Home: DWORD64, - pub P4Home: DWORD64, - pub P5Home: DWORD64, - pub P6Home: DWORD64, - pub ContextFlags: DWORD, - pub MxCsr: DWORD, - pub SegCs: WORD, - pub SegDs: WORD, - pub SegEs: WORD, - pub SegFs: WORD, - pub SegGs: WORD, - pub SegSs: WORD, - pub EFlags: DWORD, - pub Dr0: DWORD64, - pub Dr1: DWORD64, - pub Dr2: DWORD64, - pub Dr3: DWORD64, - pub Dr6: DWORD64, - pub Dr7: DWORD64, - pub Rax: DWORD64, - pub Rcx: DWORD64, - pub Rdx: DWORD64, - pub Rbx: DWORD64, - pub Rsp: DWORD64, - pub Rbp: DWORD64, - pub Rsi: DWORD64, - pub Rdi: DWORD64, - pub R8: DWORD64, - pub R9: DWORD64, - pub R10: DWORD64, - pub R11: DWORD64, - pub R12: DWORD64, - pub R13: DWORD64, - pub R14: DWORD64, - pub R15: DWORD64, - pub Rip: DWORD64, - pub __bindgen_anon_1: _CONTEXT__bindgen_ty_1, - pub VectorRegister: [M128A; 26usize], - pub VectorControl: DWORD64, - pub DebugControl: DWORD64, - pub LastBranchToRip: DWORD64, - pub LastBranchFromRip: DWORD64, - pub LastExceptionToRip: DWORD64, - pub LastExceptionFromRip: DWORD64, -} -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub union _CONTEXT__bindgen_ty_1 { - pub FltSave: XMM_SAVE_AREA32, - pub __bindgen_anon_1: _CONTEXT__bindgen_ty_1__bindgen_ty_1, -} -#[repr(C)] -#[repr(align(16))] -#[derive(Debug, Copy, Clone)] -pub struct _CONTEXT__bindgen_ty_1__bindgen_ty_1 { - pub Header: [M128A; 2usize], - pub Legacy: [M128A; 8usize], - pub Xmm0: M128A, - pub Xmm1: M128A, - pub Xmm2: M128A, - pub Xmm3: M128A, - pub Xmm4: M128A, - pub Xmm5: M128A, - pub Xmm6: M128A, - pub Xmm7: M128A, - pub Xmm8: M128A, - pub Xmm9: M128A, - pub Xmm10: M128A, - pub Xmm11: M128A, - pub Xmm12: M128A, - pub Xmm13: M128A, - pub Xmm14: M128A, - pub Xmm15: M128A, + test_field_Xmm15(); } #[test] -fn bindgen_test_layout__CONTEXT__bindgen_ty_1__bindgen_ty_1() { +fn bindgen_test_layout__KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>(), - 416usize, + ::std::mem::size_of::<_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1>(), + 128usize, concat!( "Size of: ", - stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1) + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1) ) ); assert_eq!( - ::std::mem::align_of::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>(), - 16usize, + ::std::mem::align_of::<_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1>(), + 8usize, concat!( "Alignment of ", - stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1) + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1) ) ); - fn test_field_Header() { + fn test_field_FloatingContext() { assert_eq!( unsafe { let uninit = - ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1>::uninit( + ); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).FloatingContext) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), - "::", - stringify!(Header) - ) - ); - } - test_field_Header(); - fn test_field_Legacy() { - assert_eq!( - unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Legacy) as usize - ptr as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1), "::", - stringify!(Legacy) + stringify!(FloatingContext) ) ); } - test_field_Legacy(); - fn test_field_Xmm0() { + test_field_FloatingContext(); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2 { + pub IntegerContext: [PDWORD64; 16usize], + pub __bindgen_anon_1: _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1 { + pub Rax: PDWORD64, + pub Rcx: PDWORD64, + pub Rdx: PDWORD64, + pub Rbx: PDWORD64, + pub Rsp: PDWORD64, + pub Rbp: PDWORD64, + pub Rsi: PDWORD64, + pub Rdi: PDWORD64, + pub R8: PDWORD64, + pub R9: PDWORD64, + pub R10: PDWORD64, + pub R11: PDWORD64, + pub R12: PDWORD64, + pub R13: PDWORD64, + pub R14: PDWORD64, + pub R15: PDWORD64, +} +#[test] +fn bindgen_test_layout__KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1>(), + 128usize, + concat!( + "Size of: ", + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1) + ) + ); + assert_eq!( + ::std::mem::align_of::<_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1>(), + 8usize, + concat!( + "Alignment of ", + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1) + ) + ); + fn test_field_Rax() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm0) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Rax) as usize - ptr as usize }, - 160usize, + 0usize, concat!( "Offset of field: ", - stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), "::", - stringify!(Xmm0) + stringify!(Rax) ) ); } - test_field_Xmm0(); - fn test_field_Xmm1() { + test_field_Rax(); + fn test_field_Rcx() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Rcx) as usize - ptr as usize }, - 176usize, + 8usize, concat!( "Offset of field: ", - stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), "::", - stringify!(Xmm1) + stringify!(Rcx) ) ); } - test_field_Xmm1(); - fn test_field_Xmm2() { + test_field_Rcx(); + fn test_field_Rdx() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Rdx) as usize - ptr as usize }, - 192usize, + 16usize, concat!( "Offset of field: ", - stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), "::", - stringify!(Xmm2) + stringify!(Rdx) ) ); } - test_field_Xmm2(); - fn test_field_Xmm3() { + test_field_Rdx(); + fn test_field_Rbx() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm3) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Rbx) as usize - ptr as usize }, - 208usize, + 24usize, concat!( "Offset of field: ", - stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), "::", - stringify!(Xmm3) + stringify!(Rbx) ) ); } - test_field_Xmm3(); - fn test_field_Xmm4() { + test_field_Rbx(); + fn test_field_Rsp() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm4) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Rsp) as usize - ptr as usize }, - 224usize, + 32usize, concat!( "Offset of field: ", - stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), "::", - stringify!(Xmm4) + stringify!(Rsp) ) ); } - test_field_Xmm4(); - fn test_field_Xmm5() { + test_field_Rsp(); + fn test_field_Rbp() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm5) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Rbp) as usize - ptr as usize }, - 240usize, + 40usize, concat!( "Offset of field: ", - stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), "::", - stringify!(Xmm5) + stringify!(Rbp) ) ); } - test_field_Xmm5(); - fn test_field_Xmm6() { + test_field_Rbp(); + fn test_field_Rsi() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm6) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Rsi) as usize - ptr as usize }, - 256usize, + 48usize, concat!( "Offset of field: ", - stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), "::", - stringify!(Xmm6) + stringify!(Rsi) ) ); } - test_field_Xmm6(); - fn test_field_Xmm7() { + test_field_Rsi(); + fn test_field_Rdi() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm7) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Rdi) as usize - ptr as usize }, - 272usize, + 56usize, concat!( "Offset of field: ", - stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), "::", - stringify!(Xmm7) + stringify!(Rdi) ) ); } - test_field_Xmm7(); - fn test_field_Xmm8() { + test_field_Rdi(); + fn test_field_R8() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm8) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).R8) as usize - ptr as usize }, - 288usize, + 64usize, concat!( "Offset of field: ", - stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), "::", - stringify!(Xmm8) + stringify!(R8) ) ); } - test_field_Xmm8(); - fn test_field_Xmm9() { + test_field_R8(); + fn test_field_R9() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm9) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).R9) as usize - ptr as usize }, - 304usize, + 72usize, concat!( "Offset of field: ", - stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), "::", - stringify!(Xmm9) + stringify!(R9) ) ); } - test_field_Xmm9(); - fn test_field_Xmm10() { + test_field_R9(); + fn test_field_R10() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm10) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).R10) as usize - ptr as usize }, - 320usize, + 80usize, concat!( "Offset of field: ", - stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), "::", - stringify!(Xmm10) + stringify!(R10) ) ); } - test_field_Xmm10(); - fn test_field_Xmm11() { + test_field_R10(); + fn test_field_R11() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm11) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).R11) as usize - ptr as usize }, - 336usize, + 88usize, concat!( "Offset of field: ", - stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), "::", - stringify!(Xmm11) + stringify!(R11) ) ); } - test_field_Xmm11(); - fn test_field_Xmm12() { + test_field_R11(); + fn test_field_R12() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm12) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).R12) as usize - ptr as usize }, - 352usize, + 96usize, concat!( "Offset of field: ", - stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), "::", - stringify!(Xmm12) + stringify!(R12) ) ); } - test_field_Xmm12(); - fn test_field_Xmm13() { + test_field_R12(); + fn test_field_R13() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm13) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).R13) as usize - ptr as usize }, - 368usize, + 104usize, concat!( "Offset of field: ", - stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), "::", - stringify!(Xmm13) + stringify!(R13) ) ); } - test_field_Xmm13(); - fn test_field_Xmm14() { + test_field_R13(); + fn test_field_R14() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm14) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).R14) as usize - ptr as usize }, - 384usize, + 112usize, concat!( "Offset of field: ", - stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), "::", - stringify!(Xmm14) + stringify!(R14) ) ); } - test_field_Xmm14(); - fn test_field_Xmm15() { + test_field_R14(); + fn test_field_R15() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm15) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).R15) as usize - ptr as usize }, - 400usize, + 120usize, concat!( "Offset of field: ", - stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), "::", - stringify!(Xmm15) + stringify!(R15) ) ); } - test_field_Xmm15(); + test_field_R15(); } #[test] -fn bindgen_test_layout__CONTEXT__bindgen_ty_1() { +fn bindgen_test_layout__KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2() { assert_eq!( - ::std::mem::size_of::<_CONTEXT__bindgen_ty_1>(), - 512usize, - concat!("Size of: ", stringify!(_CONTEXT__bindgen_ty_1)) + ::std::mem::size_of::<_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2>(), + 128usize, + concat!( + "Size of: ", + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2) + ) ); assert_eq!( - ::std::mem::align_of::<_CONTEXT__bindgen_ty_1>(), - 16usize, - concat!("Alignment of ", stringify!(_CONTEXT__bindgen_ty_1)) + ::std::mem::align_of::<_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2>(), + 8usize, + concat!( + "Alignment of ", + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2) + ) ); - fn test_field_FltSave() { + fn test_field_IntegerContext() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT__bindgen_ty_1>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2>::uninit( + ); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).FltSave) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).IntegerContext) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_CONTEXT__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2), "::", - stringify!(FltSave) + stringify!(IntegerContext) ) ); } - test_field_FltSave(); + test_field_IntegerContext(); } #[test] -fn bindgen_test_layout__CONTEXT() { +fn bindgen_test_layout__KNONVOLATILE_CONTEXT_POINTERS() { assert_eq!( - ::std::mem::size_of::<_CONTEXT>(), - 1232usize, - concat!("Size of: ", stringify!(_CONTEXT)) + ::std::mem::size_of::<_KNONVOLATILE_CONTEXT_POINTERS>(), + 256usize, + concat!("Size of: ", stringify!(_KNONVOLATILE_CONTEXT_POINTERS)) ); assert_eq!( - ::std::mem::align_of::<_CONTEXT>(), + ::std::mem::align_of::<_KNONVOLATILE_CONTEXT_POINTERS>(), + 8usize, + concat!("Alignment of ", stringify!(_KNONVOLATILE_CONTEXT_POINTERS)) + ); +} +pub type KNONVOLATILE_CONTEXT_POINTERS = _KNONVOLATILE_CONTEXT_POINTERS; +pub type PKNONVOLATILE_CONTEXT_POINTERS = *mut _KNONVOLATILE_CONTEXT_POINTERS; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SCOPE_TABLE_ARM { + pub Count: DWORD, + pub ScopeRecord: [_SCOPE_TABLE_ARM__bindgen_ty_1; 1usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SCOPE_TABLE_ARM__bindgen_ty_1 { + pub BeginAddress: DWORD, + pub EndAddress: DWORD, + pub HandlerAddress: DWORD, + pub JumpTarget: DWORD, +} +#[test] +fn bindgen_test_layout__SCOPE_TABLE_ARM__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<_SCOPE_TABLE_ARM__bindgen_ty_1>(), 16usize, - concat!("Alignment of ", stringify!(_CONTEXT)) + concat!("Size of: ", stringify!(_SCOPE_TABLE_ARM__bindgen_ty_1)) ); - fn test_field_P1Home() { + assert_eq!( + ::std::mem::align_of::<_SCOPE_TABLE_ARM__bindgen_ty_1>(), + 4usize, + concat!("Alignment of ", stringify!(_SCOPE_TABLE_ARM__bindgen_ty_1)) + ); + fn test_field_BeginAddress() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).P1Home) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).BeginAddress) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_SCOPE_TABLE_ARM__bindgen_ty_1), "::", - stringify!(P1Home) + stringify!(BeginAddress) ) ); } - test_field_P1Home(); - fn test_field_P2Home() { + test_field_BeginAddress(); + fn test_field_EndAddress() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).P2Home) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).EndAddress) as usize - ptr as usize }, - 8usize, + 4usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_SCOPE_TABLE_ARM__bindgen_ty_1), "::", - stringify!(P2Home) + stringify!(EndAddress) ) ); } - test_field_P2Home(); - fn test_field_P3Home() { + test_field_EndAddress(); + fn test_field_HandlerAddress() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).P3Home) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).HandlerAddress) as usize - ptr as usize }, - 16usize, + 8usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_SCOPE_TABLE_ARM__bindgen_ty_1), "::", - stringify!(P3Home) + stringify!(HandlerAddress) ) ); } - test_field_P3Home(); - fn test_field_P4Home() { + test_field_HandlerAddress(); + fn test_field_JumpTarget() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).P4Home) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).JumpTarget) as usize - ptr as usize }, - 24usize, + 12usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_SCOPE_TABLE_ARM__bindgen_ty_1), "::", - stringify!(P4Home) + stringify!(JumpTarget) ) ); } - test_field_P4Home(); - fn test_field_P5Home() { + test_field_JumpTarget(); +} +#[test] +fn bindgen_test_layout__SCOPE_TABLE_ARM() { + assert_eq!( + ::std::mem::size_of::<_SCOPE_TABLE_ARM>(), + 20usize, + concat!("Size of: ", stringify!(_SCOPE_TABLE_ARM)) + ); + assert_eq!( + ::std::mem::align_of::<_SCOPE_TABLE_ARM>(), + 4usize, + concat!("Alignment of ", stringify!(_SCOPE_TABLE_ARM)) + ); + fn test_field_Count() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).P5Home) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Count) as usize - ptr as usize }, - 32usize, + 0usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_SCOPE_TABLE_ARM), "::", - stringify!(P5Home) + stringify!(Count) ) ); } - test_field_P5Home(); - fn test_field_P6Home() { + test_field_Count(); + fn test_field_ScopeRecord() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).P6Home) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ScopeRecord) as usize - ptr as usize }, - 40usize, + 4usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_SCOPE_TABLE_ARM), "::", - stringify!(P6Home) + stringify!(ScopeRecord) ) ); } - test_field_P6Home(); - fn test_field_ContextFlags() { + test_field_ScopeRecord(); +} +pub type SCOPE_TABLE_ARM = _SCOPE_TABLE_ARM; +pub type PSCOPE_TABLE_ARM = *mut _SCOPE_TABLE_ARM; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SCOPE_TABLE_ARM64 { + pub Count: DWORD, + pub ScopeRecord: [_SCOPE_TABLE_ARM64__bindgen_ty_1; 1usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SCOPE_TABLE_ARM64__bindgen_ty_1 { + pub BeginAddress: DWORD, + pub EndAddress: DWORD, + pub HandlerAddress: DWORD, + pub JumpTarget: DWORD, +} +#[test] +fn bindgen_test_layout__SCOPE_TABLE_ARM64__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<_SCOPE_TABLE_ARM64__bindgen_ty_1>(), + 16usize, + concat!("Size of: ", stringify!(_SCOPE_TABLE_ARM64__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::<_SCOPE_TABLE_ARM64__bindgen_ty_1>(), + 4usize, + concat!( + "Alignment of ", + stringify!(_SCOPE_TABLE_ARM64__bindgen_ty_1) + ) + ); + fn test_field_BeginAddress() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM64__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ContextFlags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).BeginAddress) as usize - ptr as usize }, - 48usize, + 0usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_SCOPE_TABLE_ARM64__bindgen_ty_1), "::", - stringify!(ContextFlags) + stringify!(BeginAddress) ) ); } - test_field_ContextFlags(); - fn test_field_MxCsr() { + test_field_BeginAddress(); + fn test_field_EndAddress() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM64__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).MxCsr) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).EndAddress) as usize - ptr as usize }, - 52usize, + 4usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_SCOPE_TABLE_ARM64__bindgen_ty_1), "::", - stringify!(MxCsr) + stringify!(EndAddress) ) ); } - test_field_MxCsr(); - fn test_field_SegCs() { + test_field_EndAddress(); + fn test_field_HandlerAddress() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM64__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SegCs) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).HandlerAddress) as usize - ptr as usize }, - 56usize, + 8usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_SCOPE_TABLE_ARM64__bindgen_ty_1), "::", - stringify!(SegCs) + stringify!(HandlerAddress) ) ); } - test_field_SegCs(); - fn test_field_SegDs() { + test_field_HandlerAddress(); + fn test_field_JumpTarget() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM64__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SegDs) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).JumpTarget) as usize - ptr as usize }, - 58usize, + 12usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), - "::", - stringify!(SegDs) - ) - ); - } - test_field_SegDs(); - fn test_field_SegEs() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SegEs) as usize - ptr as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_SCOPE_TABLE_ARM64__bindgen_ty_1), "::", - stringify!(SegEs) + stringify!(JumpTarget) ) ); } - test_field_SegEs(); - fn test_field_SegFs() { + test_field_JumpTarget(); +} +#[test] +fn bindgen_test_layout__SCOPE_TABLE_ARM64() { + assert_eq!( + ::std::mem::size_of::<_SCOPE_TABLE_ARM64>(), + 20usize, + concat!("Size of: ", stringify!(_SCOPE_TABLE_ARM64)) + ); + assert_eq!( + ::std::mem::align_of::<_SCOPE_TABLE_ARM64>(), + 4usize, + concat!("Alignment of ", stringify!(_SCOPE_TABLE_ARM64)) + ); + fn test_field_Count() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SegFs) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Count) as usize - ptr as usize }, - 62usize, + 0usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_SCOPE_TABLE_ARM64), "::", - stringify!(SegFs) + stringify!(Count) ) ); } - test_field_SegFs(); - fn test_field_SegGs() { + test_field_Count(); + fn test_field_ScopeRecord() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SegGs) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ScopeRecord) as usize - ptr as usize }, - 64usize, + 4usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_SCOPE_TABLE_ARM64), "::", - stringify!(SegGs) + stringify!(ScopeRecord) ) ); } - test_field_SegGs(); - fn test_field_SegSs() { + test_field_ScopeRecord(); +} +pub type SCOPE_TABLE_ARM64 = _SCOPE_TABLE_ARM64; +pub type PSCOPE_TABLE_ARM64 = *mut _SCOPE_TABLE_ARM64; +#[repr(C)] +#[derive(Copy, Clone)] +pub union _ARM64_NT_NEON128 { + pub __bindgen_anon_1: _ARM64_NT_NEON128__bindgen_ty_1, + pub D: [f64; 2usize], + pub S: [f32; 4usize], + pub H: [WORD; 8usize], + pub B: [BYTE; 16usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _ARM64_NT_NEON128__bindgen_ty_1 { + pub Low: ULONGLONG, + pub High: LONGLONG, +} +#[test] +fn bindgen_test_layout__ARM64_NT_NEON128__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<_ARM64_NT_NEON128__bindgen_ty_1>(), + 16usize, + concat!("Size of: ", stringify!(_ARM64_NT_NEON128__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::<_ARM64_NT_NEON128__bindgen_ty_1>(), + 8usize, + concat!("Alignment of ", stringify!(_ARM64_NT_NEON128__bindgen_ty_1)) + ); + fn test_field_Low() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_NEON128__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SegSs) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Low) as usize - ptr as usize }, - 66usize, + 0usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_NEON128__bindgen_ty_1), "::", - stringify!(SegSs) + stringify!(Low) ) ); } - test_field_SegSs(); - fn test_field_EFlags() { + test_field_Low(); + fn test_field_High() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_NEON128__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).EFlags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).High) as usize - ptr as usize }, - 68usize, + 8usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_NEON128__bindgen_ty_1), "::", - stringify!(EFlags) + stringify!(High) ) ); } - test_field_EFlags(); - fn test_field_Dr0() { + test_field_High(); +} +#[test] +fn bindgen_test_layout__ARM64_NT_NEON128() { + assert_eq!( + ::std::mem::size_of::<_ARM64_NT_NEON128>(), + 16usize, + concat!("Size of: ", stringify!(_ARM64_NT_NEON128)) + ); + assert_eq!( + ::std::mem::align_of::<_ARM64_NT_NEON128>(), + 8usize, + concat!("Alignment of ", stringify!(_ARM64_NT_NEON128)) + ); + fn test_field_D() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_NEON128>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Dr0) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).D) as usize - ptr as usize }, - 72usize, + 0usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_NEON128), "::", - stringify!(Dr0) + stringify!(D) ) ); } - test_field_Dr0(); - fn test_field_Dr1() { + test_field_D(); + fn test_field_S() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_NEON128>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Dr1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).S) as usize - ptr as usize }, - 80usize, + 0usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_NEON128), "::", - stringify!(Dr1) + stringify!(S) ) ); } - test_field_Dr1(); - fn test_field_Dr2() { + test_field_S(); + fn test_field_H() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_NEON128>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Dr2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 88usize, + 0usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_NEON128), "::", - stringify!(Dr2) + stringify!(H) ) ); } - test_field_Dr2(); - fn test_field_Dr3() { + test_field_H(); + fn test_field_B() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_NEON128>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Dr3) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).B) as usize - ptr as usize }, - 96usize, + 0usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_NEON128), "::", - stringify!(Dr3) + stringify!(B) ) ); } - test_field_Dr3(); - fn test_field_Dr6() { + test_field_B(); +} +pub type ARM64_NT_NEON128 = _ARM64_NT_NEON128; +pub type PARM64_NT_NEON128 = *mut _ARM64_NT_NEON128; +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub struct _ARM64_NT_CONTEXT { + pub ContextFlags: DWORD, + pub Cpsr: DWORD, + pub __bindgen_anon_1: _ARM64_NT_CONTEXT__bindgen_ty_1, + pub Sp: DWORD64, + pub Pc: DWORD64, + pub V: [ARM64_NT_NEON128; 32usize], + pub Fpcr: DWORD, + pub Fpsr: DWORD, + pub Bcr: [DWORD; 8usize], + pub Bvr: [DWORD64; 8usize], + pub Wcr: [DWORD; 2usize], + pub Wvr: [DWORD64; 2usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _ARM64_NT_CONTEXT__bindgen_ty_1 { + pub __bindgen_anon_1: _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + pub X: [DWORD64; 31usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 { + pub X0: DWORD64, + pub X1: DWORD64, + pub X2: DWORD64, + pub X3: DWORD64, + pub X4: DWORD64, + pub X5: DWORD64, + pub X6: DWORD64, + pub X7: DWORD64, + pub X8: DWORD64, + pub X9: DWORD64, + pub X10: DWORD64, + pub X11: DWORD64, + pub X12: DWORD64, + pub X13: DWORD64, + pub X14: DWORD64, + pub X15: DWORD64, + pub X16: DWORD64, + pub X17: DWORD64, + pub X18: DWORD64, + pub X19: DWORD64, + pub X20: DWORD64, + pub X21: DWORD64, + pub X22: DWORD64, + pub X23: DWORD64, + pub X24: DWORD64, + pub X25: DWORD64, + pub X26: DWORD64, + pub X27: DWORD64, + pub X28: DWORD64, + pub Fp: DWORD64, + pub Lr: DWORD64, +} +#[test] +fn bindgen_test_layout__ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1>(), + 248usize, + concat!( + "Size of: ", + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1) + ) + ); + assert_eq!( + ::std::mem::align_of::<_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1>(), + 8usize, + concat!( + "Alignment of ", + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1) + ) + ); + fn test_field_X0() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Dr6) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X0) as usize - ptr as usize }, - 104usize, + 0usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Dr6) + stringify!(X0) ) ); } - test_field_Dr6(); - fn test_field_Dr7() { + test_field_X0(); + fn test_field_X1() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Dr7) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X1) as usize - ptr as usize }, - 112usize, + 8usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Dr7) + stringify!(X1) ) ); } - test_field_Dr7(); - fn test_field_Rax() { + test_field_X1(); + fn test_field_X2() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Rax) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X2) as usize - ptr as usize }, - 120usize, + 16usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Rax) + stringify!(X2) ) ); } - test_field_Rax(); - fn test_field_Rcx() { + test_field_X2(); + fn test_field_X3() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Rcx) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X3) as usize - ptr as usize }, - 128usize, + 24usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Rcx) + stringify!(X3) ) ); } - test_field_Rcx(); - fn test_field_Rdx() { + test_field_X3(); + fn test_field_X4() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Rdx) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X4) as usize - ptr as usize }, - 136usize, + 32usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Rdx) + stringify!(X4) ) ); } - test_field_Rdx(); - fn test_field_Rbx() { + test_field_X4(); + fn test_field_X5() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Rbx) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X5) as usize - ptr as usize }, - 144usize, + 40usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Rbx) + stringify!(X5) ) ); } - test_field_Rbx(); - fn test_field_Rsp() { + test_field_X5(); + fn test_field_X6() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Rsp) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X6) as usize - ptr as usize }, - 152usize, + 48usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Rsp) + stringify!(X6) ) ); } - test_field_Rsp(); - fn test_field_Rbp() { + test_field_X6(); + fn test_field_X7() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Rbp) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X7) as usize - ptr as usize }, - 160usize, + 56usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Rbp) + stringify!(X7) ) ); } - test_field_Rbp(); - fn test_field_Rsi() { + test_field_X7(); + fn test_field_X8() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Rsi) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X8) as usize - ptr as usize }, - 168usize, + 64usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Rsi) + stringify!(X8) ) ); } - test_field_Rsi(); - fn test_field_Rdi() { + test_field_X8(); + fn test_field_X9() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Rdi) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X9) as usize - ptr as usize }, - 176usize, + 72usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Rdi) + stringify!(X9) ) ); } - test_field_Rdi(); - fn test_field_R8() { + test_field_X9(); + fn test_field_X10() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).R8) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X10) as usize - ptr as usize }, - 184usize, + 80usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(R8) + stringify!(X10) ) ); } - test_field_R8(); - fn test_field_R9() { + test_field_X10(); + fn test_field_X11() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).R9) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X11) as usize - ptr as usize }, - 192usize, + 88usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(R9) + stringify!(X11) ) ); } - test_field_R9(); - fn test_field_R10() { + test_field_X11(); + fn test_field_X12() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).R10) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X12) as usize - ptr as usize }, - 200usize, + 96usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(R10) + stringify!(X12) ) ); } - test_field_R10(); - fn test_field_R11() { + test_field_X12(); + fn test_field_X13() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).R11) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X13) as usize - ptr as usize }, - 208usize, + 104usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(R11) + stringify!(X13) ) ); } - test_field_R11(); - fn test_field_R12() { + test_field_X13(); + fn test_field_X14() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).R12) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X14) as usize - ptr as usize }, - 216usize, + 112usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(R12) + stringify!(X14) ) ); } - test_field_R12(); - fn test_field_R13() { + test_field_X14(); + fn test_field_X15() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).R13) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X15) as usize - ptr as usize }, - 224usize, + 120usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(R13) + stringify!(X15) ) ); } - test_field_R13(); - fn test_field_R14() { + test_field_X15(); + fn test_field_X16() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).R14) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X16) as usize - ptr as usize }, - 232usize, + 128usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(R14) + stringify!(X16) ) ); } - test_field_R14(); - fn test_field_R15() { + test_field_X16(); + fn test_field_X17() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).R15) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X17) as usize - ptr as usize }, - 240usize, + 136usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(R15) + stringify!(X17) ) ); } - test_field_R15(); - fn test_field_Rip() { + test_field_X17(); + fn test_field_X18() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Rip) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X18) as usize - ptr as usize }, - 248usize, + 144usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Rip) + stringify!(X18) ) ); } - test_field_Rip(); - fn test_field_VectorRegister() { + test_field_X18(); + fn test_field_X19() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).VectorRegister) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X19) as usize - ptr as usize }, - 768usize, + 152usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(VectorRegister) + stringify!(X19) ) ); } - test_field_VectorRegister(); - fn test_field_VectorControl() { + test_field_X19(); + fn test_field_X20() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).VectorControl) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X20) as usize - ptr as usize }, - 1184usize, + 160usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(VectorControl) + stringify!(X20) ) ); } - test_field_VectorControl(); - fn test_field_DebugControl() { + test_field_X20(); + fn test_field_X21() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).DebugControl) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X21) as usize - ptr as usize }, - 1192usize, + 168usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(DebugControl) + stringify!(X21) ) ); } - test_field_DebugControl(); - fn test_field_LastBranchToRip() { + test_field_X21(); + fn test_field_X22() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).LastBranchToRip) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X22) as usize - ptr as usize }, - 1200usize, + 176usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(LastBranchToRip) + stringify!(X22) ) ); } - test_field_LastBranchToRip(); - fn test_field_LastBranchFromRip() { + test_field_X22(); + fn test_field_X23() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).LastBranchFromRip) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X23) as usize - ptr as usize }, - 1208usize, + 184usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(LastBranchFromRip) + stringify!(X23) ) ); } - test_field_LastBranchFromRip(); - fn test_field_LastExceptionToRip() { + test_field_X23(); + fn test_field_X24() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).LastExceptionToRip) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X24) as usize - ptr as usize }, - 1216usize, + 192usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(LastExceptionToRip) + stringify!(X24) ) ); } - test_field_LastExceptionToRip(); - fn test_field_LastExceptionFromRip() { + test_field_X24(); + fn test_field_X25() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).LastExceptionFromRip) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X25) as usize - ptr as usize }, - 1224usize, + 200usize, concat!( "Offset of field: ", - stringify!(_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(LastExceptionFromRip) + stringify!(X25) ) ); } - test_field_LastExceptionFromRip(); -} -pub type CONTEXT = _CONTEXT; -pub type PCONTEXT = *mut _CONTEXT; -pub type RUNTIME_FUNCTION = _IMAGE_RUNTIME_FUNCTION_ENTRY; -pub type PRUNTIME_FUNCTION = *mut _IMAGE_RUNTIME_FUNCTION_ENTRY; -pub type SCOPE_TABLE = SCOPE_TABLE_AMD64; -pub type PSCOPE_TABLE = *mut SCOPE_TABLE_AMD64; -pub type GET_RUNTIME_FUNCTION_CALLBACK = ::std::option::Option< - unsafe extern "C" fn(ControlPc: DWORD64, Context: PVOID) -> PRUNTIME_FUNCTION, ->; -pub type PGET_RUNTIME_FUNCTION_CALLBACK = GET_RUNTIME_FUNCTION_CALLBACK; -pub type OUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK = ::std::option::Option< - unsafe extern "C" fn( - Process: HANDLE, - TableAddress: PVOID, - Entries: PDWORD, - Functions: *mut PRUNTIME_FUNCTION, - ) -> DWORD, ->; -pub type POUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK = OUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _DISPATCHER_CONTEXT { - pub ControlPc: DWORD64, - pub ImageBase: DWORD64, - pub FunctionEntry: PRUNTIME_FUNCTION, - pub EstablisherFrame: DWORD64, - pub TargetIp: DWORD64, - pub ContextRecord: PCONTEXT, - pub LanguageHandler: PEXCEPTION_ROUTINE, - pub HandlerData: PVOID, - pub HistoryTable: *mut _UNWIND_HISTORY_TABLE, - pub ScopeIndex: DWORD, - pub Fill0: DWORD, -} -#[test] -fn bindgen_test_layout__DISPATCHER_CONTEXT() { - assert_eq!( - ::std::mem::size_of::<_DISPATCHER_CONTEXT>(), - 80usize, - concat!("Size of: ", stringify!(_DISPATCHER_CONTEXT)) - ); - assert_eq!( - ::std::mem::align_of::<_DISPATCHER_CONTEXT>(), - 8usize, - concat!("Alignment of ", stringify!(_DISPATCHER_CONTEXT)) - ); - fn test_field_ControlPc() { + test_field_X25(); + fn test_field_X26() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ControlPc) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X26) as usize - ptr as usize }, - 0usize, + 208usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(ControlPc) + stringify!(X26) ) ); } - test_field_ControlPc(); - fn test_field_ImageBase() { + test_field_X26(); + fn test_field_X27() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ImageBase) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X27) as usize - ptr as usize }, - 8usize, + 216usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(ImageBase) + stringify!(X27) ) ); } - test_field_ImageBase(); - fn test_field_FunctionEntry() { + test_field_X27(); + fn test_field_X28() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).FunctionEntry) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X28) as usize - ptr as usize }, - 16usize, + 224usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(FunctionEntry) + stringify!(X28) ) ); } - test_field_FunctionEntry(); - fn test_field_EstablisherFrame() { + test_field_X28(); + fn test_field_Fp() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).EstablisherFrame) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Fp) as usize - ptr as usize }, - 24usize, + 232usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(EstablisherFrame) + stringify!(Fp) ) ); } - test_field_EstablisherFrame(); - fn test_field_TargetIp() { + test_field_Fp(); + fn test_field_Lr() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).TargetIp) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Lr) as usize - ptr as usize }, - 32usize, + 240usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(TargetIp) + stringify!(Lr) ) ); } - test_field_TargetIp(); - fn test_field_ContextRecord() { + test_field_Lr(); +} +#[test] +fn bindgen_test_layout__ARM64_NT_CONTEXT__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<_ARM64_NT_CONTEXT__bindgen_ty_1>(), + 248usize, + concat!("Size of: ", stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::<_ARM64_NT_CONTEXT__bindgen_ty_1>(), + 8usize, + concat!("Alignment of ", stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1)) + ); + fn test_field_X() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ContextRecord) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize }, - 40usize, + 0usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT), + stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1), "::", - stringify!(ContextRecord) + stringify!(X) ) ); } - test_field_ContextRecord(); - fn test_field_LanguageHandler() { + test_field_X(); +} +#[test] +fn bindgen_test_layout__ARM64_NT_CONTEXT() { + assert_eq!( + ::std::mem::size_of::<_ARM64_NT_CONTEXT>(), + 912usize, + concat!("Size of: ", stringify!(_ARM64_NT_CONTEXT)) + ); + assert_eq!( + ::std::mem::align_of::<_ARM64_NT_CONTEXT>(), + 16usize, + concat!("Alignment of ", stringify!(_ARM64_NT_CONTEXT)) + ); + fn test_field_ContextFlags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).LanguageHandler) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ContextFlags) as usize - ptr as usize }, - 48usize, + 0usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT), + stringify!(_ARM64_NT_CONTEXT), "::", - stringify!(LanguageHandler) + stringify!(ContextFlags) ) ); } - test_field_LanguageHandler(); - fn test_field_HandlerData() { + test_field_ContextFlags(); + fn test_field_Cpsr() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).HandlerData) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Cpsr) as usize - ptr as usize }, - 56usize, + 4usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT), + stringify!(_ARM64_NT_CONTEXT), "::", - stringify!(HandlerData) + stringify!(Cpsr) ) ); } - test_field_HandlerData(); - fn test_field_HistoryTable() { + test_field_Cpsr(); + fn test_field_Sp() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).HistoryTable) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Sp) as usize - ptr as usize }, - 64usize, + 256usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT), + stringify!(_ARM64_NT_CONTEXT), "::", - stringify!(HistoryTable) + stringify!(Sp) ) ); } - test_field_HistoryTable(); - fn test_field_ScopeIndex() { + test_field_Sp(); + fn test_field_Pc() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ScopeIndex) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Pc) as usize - ptr as usize }, - 72usize, + 264usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT), + stringify!(_ARM64_NT_CONTEXT), "::", - stringify!(ScopeIndex) + stringify!(Pc) ) ); } - test_field_ScopeIndex(); - fn test_field_Fill0() { + test_field_Pc(); + fn test_field_V() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Fill0) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).V) as usize - ptr as usize }, - 76usize, + 272usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT), + stringify!(_ARM64_NT_CONTEXT), "::", - stringify!(Fill0) + stringify!(V) ) ); } - test_field_Fill0(); -} -pub type DISPATCHER_CONTEXT = _DISPATCHER_CONTEXT; -pub type PDISPATCHER_CONTEXT = *mut _DISPATCHER_CONTEXT; -pub type PEXCEPTION_FILTER = ::std::option::Option< - unsafe extern "C" fn( - ExceptionPointers: *mut _EXCEPTION_POINTERS, - EstablisherFrame: PVOID, - ) -> LONG, ->; -pub type PTERMINATION_HANDLER = ::std::option::Option< - unsafe extern "C" fn(_abnormal_termination: BOOLEAN, EstablisherFrame: PVOID), ->; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _KNONVOLATILE_CONTEXT_POINTERS { - pub __bindgen_anon_1: _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1, - pub __bindgen_anon_2: _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1 { - pub FloatingContext: [PM128A; 16usize], - pub __bindgen_anon_1: _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1 { - pub Xmm0: PM128A, - pub Xmm1: PM128A, - pub Xmm2: PM128A, - pub Xmm3: PM128A, - pub Xmm4: PM128A, - pub Xmm5: PM128A, - pub Xmm6: PM128A, - pub Xmm7: PM128A, - pub Xmm8: PM128A, - pub Xmm9: PM128A, - pub Xmm10: PM128A, - pub Xmm11: PM128A, - pub Xmm12: PM128A, - pub Xmm13: PM128A, - pub Xmm14: PM128A, - pub Xmm15: PM128A, -} -#[test] -fn bindgen_test_layout__KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1>(), - 128usize, - concat!( - "Size of: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1) - ) - ); - assert_eq!( - ::std::mem::align_of::<_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - concat!( - "Alignment of ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1) - ) - ); - fn test_field_Xmm0() { + test_field_V(); + fn test_field_Fpcr() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm0) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Fpcr) as usize - ptr as usize }, - 0usize, + 784usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64_NT_CONTEXT), "::", - stringify!(Xmm0) + stringify!(Fpcr) ) ); } - test_field_Xmm0(); - fn test_field_Xmm1() { + test_field_Fpcr(); + fn test_field_Fpsr() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Fpsr) as usize - ptr as usize }, - 8usize, + 788usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64_NT_CONTEXT), "::", - stringify!(Xmm1) + stringify!(Fpsr) ) ); } - test_field_Xmm1(); - fn test_field_Xmm2() { + test_field_Fpsr(); + fn test_field_Bcr() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Bcr) as usize - ptr as usize }, - 16usize, + 792usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64_NT_CONTEXT), "::", - stringify!(Xmm2) + stringify!(Bcr) ) ); } - test_field_Xmm2(); - fn test_field_Xmm3() { + test_field_Bcr(); + fn test_field_Bvr() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm3) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Bvr) as usize - ptr as usize }, - 24usize, + 824usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64_NT_CONTEXT), "::", - stringify!(Xmm3) + stringify!(Bvr) ) ); } - test_field_Xmm3(); - fn test_field_Xmm4() { + test_field_Bvr(); + fn test_field_Wcr() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm4) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Wcr) as usize - ptr as usize }, - 32usize, + 888usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64_NT_CONTEXT), "::", - stringify!(Xmm4) + stringify!(Wcr) ) ); } - test_field_Xmm4(); - fn test_field_Xmm5() { + test_field_Wcr(); + fn test_field_Wvr() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm5) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Wvr) as usize - ptr as usize }, - 40usize, + 896usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64_NT_CONTEXT), "::", - stringify!(Xmm5) + stringify!(Wvr) ) ); } - test_field_Xmm5(); - fn test_field_Xmm6() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + test_field_Wvr(); +} +pub type ARM64_NT_CONTEXT = _ARM64_NT_CONTEXT; +pub type PARM64_NT_CONTEXT = *mut _ARM64_NT_CONTEXT; +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub struct _ARM64EC_NT_CONTEXT { + pub __bindgen_anon_1: _ARM64EC_NT_CONTEXT__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _ARM64EC_NT_CONTEXT__bindgen_ty_1 { + pub __bindgen_anon_1: _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 { + pub AMD64_P1Home: DWORD64, + pub AMD64_P2Home: DWORD64, + pub AMD64_P3Home: DWORD64, + pub AMD64_P4Home: DWORD64, + pub AMD64_P5Home: DWORD64, + pub AMD64_P6Home: DWORD64, + pub ContextFlags: DWORD, + pub AMD64_MxCsr_copy: DWORD, + pub AMD64_SegCs: WORD, + pub AMD64_SegDs: WORD, + pub AMD64_SegEs: WORD, + pub AMD64_SegFs: WORD, + pub AMD64_SegGs: WORD, + pub AMD64_SegSs: WORD, + pub AMD64_EFlags: DWORD, + pub AMD64_Dr0: DWORD64, + pub AMD64_Dr1: DWORD64, + pub AMD64_Dr2: DWORD64, + pub AMD64_Dr3: DWORD64, + pub AMD64_Dr6: DWORD64, + pub AMD64_Dr7: DWORD64, + pub X8: DWORD64, + pub X0: DWORD64, + pub X1: DWORD64, + pub X27: DWORD64, + pub Sp: DWORD64, + pub Fp: DWORD64, + pub X25: DWORD64, + pub X26: DWORD64, + pub X2: DWORD64, + pub X3: DWORD64, + pub X4: DWORD64, + pub X5: DWORD64, + pub X19: DWORD64, + pub X20: DWORD64, + pub X21: DWORD64, + pub X22: DWORD64, + pub Pc: DWORD64, + pub __bindgen_anon_1: _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + pub AMD64_VectorRegister: [ARM64_NT_NEON128; 26usize], + pub AMD64_VectorControl: DWORD64, + pub AMD64_DebugControl: DWORD64, + pub AMD64_LastBranchToRip: DWORD64, + pub AMD64_LastBranchFromRip: DWORD64, + pub AMD64_LastExceptionToRip: DWORD64, + pub AMD64_LastExceptionFromRip: DWORD64, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 { + pub AMD64_ControlWord: WORD, + pub AMD64_StatusWord: WORD, + pub AMD64_TagWord: BYTE, + pub AMD64_Reserved1: BYTE, + pub AMD64_ErrorOpcode: WORD, + pub AMD64_ErrorOffset: DWORD, + pub AMD64_ErrorSelector: WORD, + pub AMD64_Reserved2: WORD, + pub AMD64_DataOffset: DWORD, + pub AMD64_DataSelector: WORD, + pub AMD64_Reserved3: WORD, + pub AMD64_MxCsr: DWORD, + pub AMD64_MxCsr_Mask: DWORD, + pub Lr: DWORD64, + pub X16_0: WORD, + pub AMD64_St0_Reserved1: WORD, + pub AMD64_St0_Reserved2: DWORD, + pub X6: DWORD64, + pub X16_1: WORD, + pub AMD64_St1_Reserved1: WORD, + pub AMD64_St1_Reserved2: DWORD, + pub X7: DWORD64, + pub X16_2: WORD, + pub AMD64_St2_Reserved1: WORD, + pub AMD64_St2_Reserved2: DWORD, + pub X9: DWORD64, + pub X16_3: WORD, + pub AMD64_St3_Reserved1: WORD, + pub AMD64_St3_Reserved2: DWORD, + pub X10: DWORD64, + pub X17_0: WORD, + pub AMD64_St4_Reserved1: WORD, + pub AMD64_St4_Reserved2: DWORD, + pub X11: DWORD64, + pub X17_1: WORD, + pub AMD64_St5_Reserved1: WORD, + pub AMD64_St5_Reserved2: DWORD, + pub X12: DWORD64, + pub X17_2: WORD, + pub AMD64_St6_Reserved1: WORD, + pub AMD64_St6_Reserved2: DWORD, + pub X15: DWORD64, + pub X17_3: WORD, + pub AMD64_St7_Reserved1: WORD, + pub AMD64_St7_Reserved2: DWORD, + pub V: [ARM64_NT_NEON128; 16usize], + pub AMD64_XSAVE_FORMAT_Reserved4: [BYTE; 96usize], +} +#[test] +fn bindgen_test_layout__ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1>(), + 512usize, + concat!( + "Size of: ", + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1) + ) + ); + assert_eq!( + ::std::mem::align_of::<_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1>(), + 8usize, + concat!( + "Alignment of ", + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1) + ) + ); + fn test_field_AMD64_ControlWord() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm6) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_ControlWord) as usize - ptr as usize }, - 48usize, + 0usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Xmm6) + stringify!(AMD64_ControlWord) ) ); } - test_field_Xmm6(); - fn test_field_Xmm7() { + test_field_AMD64_ControlWord(); + fn test_field_AMD64_StatusWord() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm7) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_StatusWord) as usize - ptr as usize }, - 56usize, + 2usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Xmm7) + stringify!(AMD64_StatusWord) ) ); } - test_field_Xmm7(); - fn test_field_Xmm8() { + test_field_AMD64_StatusWord(); + fn test_field_AMD64_TagWord() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm8) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_TagWord) as usize - ptr as usize }, - 64usize, + 4usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Xmm8) + stringify!(AMD64_TagWord) ) ); } - test_field_Xmm8(); - fn test_field_Xmm9() { + test_field_AMD64_TagWord(); + fn test_field_AMD64_Reserved1() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm9) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_Reserved1) as usize - ptr as usize }, - 72usize, + 5usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Xmm9) + stringify!(AMD64_Reserved1) ) ); } - test_field_Xmm9(); - fn test_field_Xmm10() { + test_field_AMD64_Reserved1(); + fn test_field_AMD64_ErrorOpcode() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm10) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_ErrorOpcode) as usize - ptr as usize }, - 80usize, + 6usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Xmm10) + stringify!(AMD64_ErrorOpcode) ) ); } - test_field_Xmm10(); - fn test_field_Xmm11() { + test_field_AMD64_ErrorOpcode(); + fn test_field_AMD64_ErrorOffset() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm11) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_ErrorOffset) as usize - ptr as usize }, - 88usize, + 8usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Xmm11) + stringify!(AMD64_ErrorOffset) ) ); } - test_field_Xmm11(); - fn test_field_Xmm12() { + test_field_AMD64_ErrorOffset(); + fn test_field_AMD64_ErrorSelector() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm12) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_ErrorSelector) as usize - ptr as usize }, - 96usize, + 12usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Xmm12) + stringify!(AMD64_ErrorSelector) ) ); } - test_field_Xmm12(); - fn test_field_Xmm13() { + test_field_AMD64_ErrorSelector(); + fn test_field_AMD64_Reserved2() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm13) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_Reserved2) as usize - ptr as usize }, - 104usize, + 14usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Xmm13) + stringify!(AMD64_Reserved2) ) ); } - test_field_Xmm13(); - fn test_field_Xmm14() { + test_field_AMD64_Reserved2(); + fn test_field_AMD64_DataOffset() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm14) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_DataOffset) as usize - ptr as usize }, - 112usize, + 16usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Xmm14) + stringify!(AMD64_DataOffset) ) ); } - test_field_Xmm14(); - fn test_field_Xmm15() { + test_field_AMD64_DataOffset(); + fn test_field_AMD64_DataSelector() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Xmm15) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_DataSelector) as usize - ptr as usize }, - 120usize, + 20usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Xmm15) + stringify!(AMD64_DataSelector) ) ); } - test_field_Xmm15(); -} -#[test] -fn bindgen_test_layout__KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1>(), - 128usize, - concat!( - "Size of: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1) - ) - ); - assert_eq!( - ::std::mem::align_of::<_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1>(), - 8usize, - concat!( - "Alignment of ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1) - ) - ); - fn test_field_FloatingContext() { + test_field_AMD64_DataSelector(); + fn test_field_AMD64_Reserved3() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1>::uninit( - ); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).FloatingContext) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_Reserved3) as usize - ptr as usize }, - 0usize, + 22usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(FloatingContext) + stringify!(AMD64_Reserved3) ) ); } - test_field_FloatingContext(); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2 { - pub IntegerContext: [PDWORD64; 16usize], - pub __bindgen_anon_1: _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1 { - pub Rax: PDWORD64, - pub Rcx: PDWORD64, - pub Rdx: PDWORD64, - pub Rbx: PDWORD64, - pub Rsp: PDWORD64, - pub Rbp: PDWORD64, - pub Rsi: PDWORD64, - pub Rdi: PDWORD64, - pub R8: PDWORD64, - pub R9: PDWORD64, - pub R10: PDWORD64, - pub R11: PDWORD64, - pub R12: PDWORD64, - pub R13: PDWORD64, - pub R14: PDWORD64, - pub R15: PDWORD64, -} -#[test] -fn bindgen_test_layout__KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1>(), - 128usize, - concat!( - "Size of: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1) - ) - ); - assert_eq!( - ::std::mem::align_of::<_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1>(), - 8usize, - concat!( - "Alignment of ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1) - ) - ); - fn test_field_Rax() { + test_field_AMD64_Reserved3(); + fn test_field_AMD64_MxCsr() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Rax) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_MxCsr) as usize - ptr as usize }, - 0usize, + 24usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Rax) + stringify!(AMD64_MxCsr) ) ); } - test_field_Rax(); - fn test_field_Rcx() { + test_field_AMD64_MxCsr(); + fn test_field_AMD64_MxCsr_Mask() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Rcx) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_MxCsr_Mask) as usize - ptr as usize }, - 8usize, + 28usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Rcx) + stringify!(AMD64_MxCsr_Mask) ) ); } - test_field_Rcx(); - fn test_field_Rdx() { + test_field_AMD64_MxCsr_Mask(); + fn test_field_Lr() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Rdx) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Lr) as usize - ptr as usize }, - 16usize, + 32usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Rdx) + stringify!(Lr) ) ); } - test_field_Rdx(); - fn test_field_Rbx() { + test_field_Lr(); + fn test_field_X16_0() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Rbx) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X16_0) as usize - ptr as usize }, - 24usize, + 40usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Rbx) + stringify!(X16_0) ) ); } - test_field_Rbx(); - fn test_field_Rsp() { + test_field_X16_0(); + fn test_field_AMD64_St0_Reserved1() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Rsp) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_St0_Reserved1) as usize - ptr as usize }, - 32usize, + 42usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Rsp) + stringify!(AMD64_St0_Reserved1) ) ); } - test_field_Rsp(); - fn test_field_Rbp() { + test_field_AMD64_St0_Reserved1(); + fn test_field_AMD64_St0_Reserved2() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Rbp) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_St0_Reserved2) as usize - ptr as usize }, - 40usize, + 44usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Rbp) + stringify!(AMD64_St0_Reserved2) ) ); } - test_field_Rbp(); - fn test_field_Rsi() { + test_field_AMD64_St0_Reserved2(); + fn test_field_X6() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Rsi) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X6) as usize - ptr as usize }, 48usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Rsi) + stringify!(X6) ) ); } - test_field_Rsi(); - fn test_field_Rdi() { + test_field_X6(); + fn test_field_X16_1() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Rdi) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X16_1) as usize - ptr as usize }, 56usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Rdi) + stringify!(X16_1) ) ); } - test_field_Rdi(); - fn test_field_R8() { + test_field_X16_1(); + fn test_field_AMD64_St1_Reserved1() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).R8) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_St1_Reserved1) as usize - ptr as usize }, - 64usize, + 58usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(R8) + stringify!(AMD64_St1_Reserved1) ) ); } - test_field_R8(); - fn test_field_R9() { + test_field_AMD64_St1_Reserved1(); + fn test_field_AMD64_St1_Reserved2() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).R9) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_St1_Reserved2) as usize - ptr as usize }, - 72usize, + 60usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(R9) + stringify!(AMD64_St1_Reserved2) ) ); } - test_field_R9(); - fn test_field_R10() { + test_field_AMD64_St1_Reserved2(); + fn test_field_X7() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).R10) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X7) as usize - ptr as usize }, - 80usize, + 64usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(R10) + stringify!(X7) ) ); } - test_field_R10(); - fn test_field_R11() { + test_field_X7(); + fn test_field_X16_2() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).R11) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X16_2) as usize - ptr as usize }, - 88usize, + 72usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(R11) + stringify!(X16_2) ) ); } - test_field_R11(); - fn test_field_R12() { + test_field_X16_2(); + fn test_field_AMD64_St2_Reserved1() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).R12) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_St2_Reserved1) as usize - ptr as usize }, - 96usize, + 74usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(R12) + stringify!(AMD64_St2_Reserved1) ) ); } - test_field_R12(); - fn test_field_R13() { + test_field_AMD64_St2_Reserved1(); + fn test_field_AMD64_St2_Reserved2() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).R13) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_St2_Reserved2) as usize - ptr as usize }, - 104usize, + 76usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(R13) + stringify!(AMD64_St2_Reserved2) ) ); } - test_field_R13(); - fn test_field_R14() { + test_field_AMD64_St2_Reserved2(); + fn test_field_X9() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).R14) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X9) as usize - ptr as usize }, - 112usize, + 80usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(R14) + stringify!(X9) ) ); } - test_field_R14(); - fn test_field_R15() { + test_field_X9(); + fn test_field_X16_3() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1, + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).R15) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X16_3) as usize - ptr as usize }, - 120usize, + 88usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(R15) + stringify!(X16_3) ) ); } - test_field_R15(); -} -#[test] -fn bindgen_test_layout__KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2() { - assert_eq!( - ::std::mem::size_of::<_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2>(), - 128usize, - concat!( - "Size of: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2) - ) - ); - assert_eq!( - ::std::mem::align_of::<_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2>(), - 8usize, - concat!( - "Alignment of ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2) - ) - ); - fn test_field_IntegerContext() { + test_field_X16_3(); + fn test_field_AMD64_St3_Reserved1() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2>::uninit( - ); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).IntegerContext) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_St3_Reserved1) as usize - ptr as usize }, - 0usize, + 90usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS__bindgen_ty_2), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(IntegerContext) + stringify!(AMD64_St3_Reserved1) ) ); } - test_field_IntegerContext(); -} -#[test] -fn bindgen_test_layout__KNONVOLATILE_CONTEXT_POINTERS() { - assert_eq!( - ::std::mem::size_of::<_KNONVOLATILE_CONTEXT_POINTERS>(), - 256usize, - concat!("Size of: ", stringify!(_KNONVOLATILE_CONTEXT_POINTERS)) - ); - assert_eq!( - ::std::mem::align_of::<_KNONVOLATILE_CONTEXT_POINTERS>(), - 8usize, - concat!("Alignment of ", stringify!(_KNONVOLATILE_CONTEXT_POINTERS)) - ); -} -pub type KNONVOLATILE_CONTEXT_POINTERS = _KNONVOLATILE_CONTEXT_POINTERS; -pub type PKNONVOLATILE_CONTEXT_POINTERS = *mut _KNONVOLATILE_CONTEXT_POINTERS; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SCOPE_TABLE_ARM { - pub Count: DWORD, - pub ScopeRecord: [_SCOPE_TABLE_ARM__bindgen_ty_1; 1usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SCOPE_TABLE_ARM__bindgen_ty_1 { - pub BeginAddress: DWORD, - pub EndAddress: DWORD, - pub HandlerAddress: DWORD, - pub JumpTarget: DWORD, -} -#[test] -fn bindgen_test_layout__SCOPE_TABLE_ARM__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_SCOPE_TABLE_ARM__bindgen_ty_1>(), - 16usize, - concat!("Size of: ", stringify!(_SCOPE_TABLE_ARM__bindgen_ty_1)) - ); - assert_eq!( - ::std::mem::align_of::<_SCOPE_TABLE_ARM__bindgen_ty_1>(), - 4usize, - concat!("Alignment of ", stringify!(_SCOPE_TABLE_ARM__bindgen_ty_1)) - ); - fn test_field_BeginAddress() { + test_field_AMD64_St3_Reserved1(); + fn test_field_AMD64_St3_Reserved2() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).BeginAddress) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_St3_Reserved2) as usize - ptr as usize }, - 0usize, + 92usize, concat!( "Offset of field: ", - stringify!(_SCOPE_TABLE_ARM__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(BeginAddress) + stringify!(AMD64_St3_Reserved2) ) ); } - test_field_BeginAddress(); - fn test_field_EndAddress() { + test_field_AMD64_St3_Reserved2(); + fn test_field_X10() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).EndAddress) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X10) as usize - ptr as usize }, - 4usize, + 96usize, concat!( "Offset of field: ", - stringify!(_SCOPE_TABLE_ARM__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(EndAddress) + stringify!(X10) ) ); } - test_field_EndAddress(); - fn test_field_HandlerAddress() { + test_field_X10(); + fn test_field_X17_0() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).HandlerAddress) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X17_0) as usize - ptr as usize }, - 8usize, + 104usize, concat!( "Offset of field: ", - stringify!(_SCOPE_TABLE_ARM__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(HandlerAddress) + stringify!(X17_0) ) ); } - test_field_HandlerAddress(); - fn test_field_JumpTarget() { + test_field_X17_0(); + fn test_field_AMD64_St4_Reserved1() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).JumpTarget) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_St4_Reserved1) as usize - ptr as usize }, - 12usize, + 106usize, concat!( "Offset of field: ", - stringify!(_SCOPE_TABLE_ARM__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(JumpTarget) + stringify!(AMD64_St4_Reserved1) ) ); } - test_field_JumpTarget(); -} -#[test] -fn bindgen_test_layout__SCOPE_TABLE_ARM() { - assert_eq!( - ::std::mem::size_of::<_SCOPE_TABLE_ARM>(), - 20usize, - concat!("Size of: ", stringify!(_SCOPE_TABLE_ARM)) - ); - assert_eq!( - ::std::mem::align_of::<_SCOPE_TABLE_ARM>(), - 4usize, - concat!("Alignment of ", stringify!(_SCOPE_TABLE_ARM)) - ); - fn test_field_Count() { + test_field_AMD64_St4_Reserved1(); + fn test_field_AMD64_St4_Reserved2() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Count) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_St4_Reserved2) as usize - ptr as usize }, - 0usize, + 108usize, concat!( "Offset of field: ", - stringify!(_SCOPE_TABLE_ARM), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Count) + stringify!(AMD64_St4_Reserved2) ) ); } - test_field_Count(); - fn test_field_ScopeRecord() { + test_field_AMD64_St4_Reserved2(); + fn test_field_X11() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ScopeRecord) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X11) as usize - ptr as usize }, - 4usize, + 112usize, concat!( "Offset of field: ", - stringify!(_SCOPE_TABLE_ARM), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(ScopeRecord) + stringify!(X11) ) ); } - test_field_ScopeRecord(); -} -pub type SCOPE_TABLE_ARM = _SCOPE_TABLE_ARM; -pub type PSCOPE_TABLE_ARM = *mut _SCOPE_TABLE_ARM; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SCOPE_TABLE_ARM64 { - pub Count: DWORD, - pub ScopeRecord: [_SCOPE_TABLE_ARM64__bindgen_ty_1; 1usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SCOPE_TABLE_ARM64__bindgen_ty_1 { - pub BeginAddress: DWORD, - pub EndAddress: DWORD, - pub HandlerAddress: DWORD, - pub JumpTarget: DWORD, -} -#[test] -fn bindgen_test_layout__SCOPE_TABLE_ARM64__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_SCOPE_TABLE_ARM64__bindgen_ty_1>(), - 16usize, - concat!("Size of: ", stringify!(_SCOPE_TABLE_ARM64__bindgen_ty_1)) - ); - assert_eq!( - ::std::mem::align_of::<_SCOPE_TABLE_ARM64__bindgen_ty_1>(), - 4usize, - concat!( - "Alignment of ", - stringify!(_SCOPE_TABLE_ARM64__bindgen_ty_1) - ) - ); - fn test_field_BeginAddress() { + test_field_X11(); + fn test_field_X17_1() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM64__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).BeginAddress) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X17_1) as usize - ptr as usize }, - 0usize, + 120usize, concat!( "Offset of field: ", - stringify!(_SCOPE_TABLE_ARM64__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(BeginAddress) + stringify!(X17_1) ) ); } - test_field_BeginAddress(); - fn test_field_EndAddress() { + test_field_X17_1(); + fn test_field_AMD64_St5_Reserved1() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM64__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).EndAddress) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_St5_Reserved1) as usize - ptr as usize }, - 4usize, + 122usize, concat!( "Offset of field: ", - stringify!(_SCOPE_TABLE_ARM64__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(EndAddress) + stringify!(AMD64_St5_Reserved1) ) ); } - test_field_EndAddress(); - fn test_field_HandlerAddress() { + test_field_AMD64_St5_Reserved1(); + fn test_field_AMD64_St5_Reserved2() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM64__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).HandlerAddress) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_St5_Reserved2) as usize - ptr as usize }, - 8usize, + 124usize, concat!( "Offset of field: ", - stringify!(_SCOPE_TABLE_ARM64__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(HandlerAddress) + stringify!(AMD64_St5_Reserved2) ) ); } - test_field_HandlerAddress(); - fn test_field_JumpTarget() { + test_field_AMD64_St5_Reserved2(); + fn test_field_X12() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM64__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).JumpTarget) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X12) as usize - ptr as usize }, - 12usize, + 128usize, concat!( "Offset of field: ", - stringify!(_SCOPE_TABLE_ARM64__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(JumpTarget) + stringify!(X12) ) ); } - test_field_JumpTarget(); -} -#[test] -fn bindgen_test_layout__SCOPE_TABLE_ARM64() { - assert_eq!( - ::std::mem::size_of::<_SCOPE_TABLE_ARM64>(), - 20usize, - concat!("Size of: ", stringify!(_SCOPE_TABLE_ARM64)) - ); - assert_eq!( - ::std::mem::align_of::<_SCOPE_TABLE_ARM64>(), - 4usize, - concat!("Alignment of ", stringify!(_SCOPE_TABLE_ARM64)) - ); - fn test_field_Count() { + test_field_X12(); + fn test_field_X17_2() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Count) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X17_2) as usize - ptr as usize }, - 0usize, + 136usize, concat!( "Offset of field: ", - stringify!(_SCOPE_TABLE_ARM64), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Count) + stringify!(X17_2) ) ); } - test_field_Count(); - fn test_field_ScopeRecord() { + test_field_X17_2(); + fn test_field_AMD64_St6_Reserved1() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SCOPE_TABLE_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ScopeRecord) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_St6_Reserved1) as usize - ptr as usize }, - 4usize, + 138usize, concat!( "Offset of field: ", - stringify!(_SCOPE_TABLE_ARM64), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(ScopeRecord) + stringify!(AMD64_St6_Reserved1) ) ); } - test_field_ScopeRecord(); -} -pub type SCOPE_TABLE_ARM64 = _SCOPE_TABLE_ARM64; -pub type PSCOPE_TABLE_ARM64 = *mut _SCOPE_TABLE_ARM64; -#[repr(C)] -#[derive(Copy, Clone)] -pub union _ARM64_NT_NEON128 { - pub __bindgen_anon_1: _ARM64_NT_NEON128__bindgen_ty_1, - pub D: [f64; 2usize], - pub S: [f32; 4usize], - pub H: [WORD; 8usize], - pub B: [BYTE; 16usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _ARM64_NT_NEON128__bindgen_ty_1 { - pub Low: ULONGLONG, - pub High: LONGLONG, -} -#[test] -fn bindgen_test_layout__ARM64_NT_NEON128__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_ARM64_NT_NEON128__bindgen_ty_1>(), - 16usize, - concat!("Size of: ", stringify!(_ARM64_NT_NEON128__bindgen_ty_1)) - ); - assert_eq!( - ::std::mem::align_of::<_ARM64_NT_NEON128__bindgen_ty_1>(), - 8usize, - concat!("Alignment of ", stringify!(_ARM64_NT_NEON128__bindgen_ty_1)) - ); - fn test_field_Low() { + test_field_AMD64_St6_Reserved1(); + fn test_field_AMD64_St6_Reserved2() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_NEON128__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Low) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_St6_Reserved2) as usize - ptr as usize }, - 0usize, + 140usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_NEON128__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Low) + stringify!(AMD64_St6_Reserved2) ) ); } - test_field_Low(); - fn test_field_High() { + test_field_AMD64_St6_Reserved2(); + fn test_field_X15() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_NEON128__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).High) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X15) as usize - ptr as usize }, - 8usize, + 144usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_NEON128__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(High) + stringify!(X15) ) ); } - test_field_High(); -} -#[test] -fn bindgen_test_layout__ARM64_NT_NEON128() { - assert_eq!( - ::std::mem::size_of::<_ARM64_NT_NEON128>(), - 16usize, - concat!("Size of: ", stringify!(_ARM64_NT_NEON128)) - ); - assert_eq!( - ::std::mem::align_of::<_ARM64_NT_NEON128>(), - 8usize, - concat!("Alignment of ", stringify!(_ARM64_NT_NEON128)) - ); - fn test_field_D() { + test_field_X15(); + fn test_field_X17_3() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_NEON128>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).D) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X17_3) as usize - ptr as usize }, - 0usize, + 152usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_NEON128), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(D) + stringify!(X17_3) ) ); } - test_field_D(); - fn test_field_S() { + test_field_X17_3(); + fn test_field_AMD64_St7_Reserved1() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_NEON128>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).S) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_St7_Reserved1) as usize - ptr as usize }, - 0usize, + 154usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_NEON128), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(S) + stringify!(AMD64_St7_Reserved1) ) ); } - test_field_S(); - fn test_field_H() { + test_field_AMD64_St7_Reserved1(); + fn test_field_AMD64_St7_Reserved2() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_NEON128>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_St7_Reserved2) as usize - ptr as usize }, - 0usize, + 156usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_NEON128), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(H) + stringify!(AMD64_St7_Reserved2) ) ); } - test_field_H(); - fn test_field_B() { + test_field_AMD64_St7_Reserved2(); + fn test_field_V() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_NEON128>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).B) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).V) as usize - ptr as usize }, - 0usize, + 160usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_NEON128), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(B) + stringify!(V) ) ); } - test_field_B(); -} -pub type ARM64_NT_NEON128 = _ARM64_NT_NEON128; -pub type PARM64_NT_NEON128 = *mut _ARM64_NT_NEON128; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _ARM64_NT_CONTEXT { - pub ContextFlags: DWORD, - pub Cpsr: DWORD, - pub __bindgen_anon_1: _ARM64_NT_CONTEXT__bindgen_ty_1, - pub Sp: DWORD64, - pub Pc: DWORD64, - pub V: [ARM64_NT_NEON128; 32usize], - pub Fpcr: DWORD, - pub Fpsr: DWORD, - pub Bcr: [DWORD; 8usize], - pub Bvr: [DWORD64; 8usize], - pub Wcr: [DWORD; 2usize], - pub Wvr: [DWORD64; 2usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _ARM64_NT_CONTEXT__bindgen_ty_1 { - pub __bindgen_anon_1: _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - pub X: [DWORD64; 31usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 { - pub X0: DWORD64, - pub X1: DWORD64, - pub X2: DWORD64, - pub X3: DWORD64, - pub X4: DWORD64, - pub X5: DWORD64, - pub X6: DWORD64, - pub X7: DWORD64, - pub X8: DWORD64, - pub X9: DWORD64, - pub X10: DWORD64, - pub X11: DWORD64, - pub X12: DWORD64, - pub X13: DWORD64, - pub X14: DWORD64, - pub X15: DWORD64, - pub X16: DWORD64, - pub X17: DWORD64, - pub X18: DWORD64, - pub X19: DWORD64, - pub X20: DWORD64, - pub X21: DWORD64, - pub X22: DWORD64, - pub X23: DWORD64, - pub X24: DWORD64, - pub X25: DWORD64, - pub X26: DWORD64, - pub X27: DWORD64, - pub X28: DWORD64, - pub Fp: DWORD64, - pub Lr: DWORD64, + test_field_V(); + fn test_field_AMD64_XSAVE_FORMAT_Reserved4() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).AMD64_XSAVE_FORMAT_Reserved4) as usize - ptr as usize + }, + 416usize, + concat!( + "Offset of field: ", + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + "::", + stringify!(AMD64_XSAVE_FORMAT_Reserved4) + ) + ); + } + test_field_AMD64_XSAVE_FORMAT_Reserved4(); } #[test] -fn bindgen_test_layout__ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1() { +fn bindgen_test_layout__ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1>(), - 248usize, + ::std::mem::size_of::<_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1>(), + 1232usize, concat!( "Size of: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1) + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1) ) ); assert_eq!( - ::std::mem::align_of::<_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1>(), + ::std::mem::align_of::<_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1>(), 8usize, concat!( "Alignment of ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1) + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1) ) ); - fn test_field_X0() { + fn test_field_AMD64_P1Home() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X0) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_P1Home) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X0) + stringify!(AMD64_P1Home) ) ); } - test_field_X0(); - fn test_field_X1() { + test_field_AMD64_P1Home(); + fn test_field_AMD64_P2Home() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_P2Home) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X1) + stringify!(AMD64_P2Home) ) ); } - test_field_X1(); - fn test_field_X2() { + test_field_AMD64_P2Home(); + fn test_field_AMD64_P3Home() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_P3Home) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X2) + stringify!(AMD64_P3Home) ) ); } - test_field_X2(); - fn test_field_X3() { + test_field_AMD64_P3Home(); + fn test_field_AMD64_P4Home() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X3) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_P4Home) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X3) + stringify!(AMD64_P4Home) ) ); } - test_field_X3(); - fn test_field_X4() { + test_field_AMD64_P4Home(); + fn test_field_AMD64_P5Home() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X4) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_P5Home) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X4) + stringify!(AMD64_P5Home) ) ); } - test_field_X4(); - fn test_field_X5() { + test_field_AMD64_P5Home(); + fn test_field_AMD64_P6Home() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X5) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_P6Home) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X5) + stringify!(AMD64_P6Home) ) ); } - test_field_X5(); - fn test_field_X6() { + test_field_AMD64_P6Home(); + fn test_field_ContextFlags() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X6) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ContextFlags) as usize - ptr as usize }, 48usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X6) + stringify!(ContextFlags) ) ); } - test_field_X6(); - fn test_field_X7() { + test_field_ContextFlags(); + fn test_field_AMD64_MxCsr_copy() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X7) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_MxCsr_copy) as usize - ptr as usize + }, + 52usize, + concat!( + "Offset of field: ", + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + "::", + stringify!(AMD64_MxCsr_copy) + ) + ); + } + test_field_AMD64_MxCsr_copy(); + fn test_field_AMD64_SegCs() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).AMD64_SegCs) as usize - ptr as usize }, 56usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X7) + stringify!(AMD64_SegCs) ) ); } - test_field_X7(); - fn test_field_X8() { + test_field_AMD64_SegCs(); + fn test_field_AMD64_SegDs() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X8) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_SegDs) as usize - ptr as usize }, - 64usize, + 58usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X8) + stringify!(AMD64_SegDs) ) ); } - test_field_X8(); - fn test_field_X9() { + test_field_AMD64_SegDs(); + fn test_field_AMD64_SegEs() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X9) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_SegEs) as usize - ptr as usize }, - 72usize, + 60usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X9) + stringify!(AMD64_SegEs) ) ); } - test_field_X9(); - fn test_field_X10() { + test_field_AMD64_SegEs(); + fn test_field_AMD64_SegFs() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X10) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_SegFs) as usize - ptr as usize }, - 80usize, + 62usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X10) + stringify!(AMD64_SegFs) ) ); } - test_field_X10(); - fn test_field_X11() { + test_field_AMD64_SegFs(); + fn test_field_AMD64_SegGs() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X11) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_SegGs) as usize - ptr as usize }, - 88usize, + 64usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X11) + stringify!(AMD64_SegGs) ) ); } - test_field_X11(); - fn test_field_X12() { + test_field_AMD64_SegGs(); + fn test_field_AMD64_SegSs() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X12) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_SegSs) as usize - ptr as usize }, - 96usize, + 66usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X12) + stringify!(AMD64_SegSs) ) ); } - test_field_X12(); - fn test_field_X13() { + test_field_AMD64_SegSs(); + fn test_field_AMD64_EFlags() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X13) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_EFlags) as usize - ptr as usize }, - 104usize, + 68usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X13) + stringify!(AMD64_EFlags) ) ); } - test_field_X13(); - fn test_field_X14() { + test_field_AMD64_EFlags(); + fn test_field_AMD64_Dr0() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X14) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_Dr0) as usize - ptr as usize }, - 112usize, + 72usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X14) + stringify!(AMD64_Dr0) ) ); } - test_field_X14(); - fn test_field_X15() { + test_field_AMD64_Dr0(); + fn test_field_AMD64_Dr1() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X15) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_Dr1) as usize - ptr as usize }, - 120usize, + 80usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X15) + stringify!(AMD64_Dr1) ) ); } - test_field_X15(); - fn test_field_X16() { + test_field_AMD64_Dr1(); + fn test_field_AMD64_Dr2() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X16) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_Dr2) as usize - ptr as usize }, - 128usize, + 88usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X16) + stringify!(AMD64_Dr2) ) ); } - test_field_X16(); - fn test_field_X17() { + test_field_AMD64_Dr2(); + fn test_field_AMD64_Dr3() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X17) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_Dr3) as usize - ptr as usize }, - 136usize, + 96usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X17) + stringify!(AMD64_Dr3) ) ); } - test_field_X17(); - fn test_field_X18() { + test_field_AMD64_Dr3(); + fn test_field_AMD64_Dr6() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X18) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_Dr6) as usize - ptr as usize }, - 144usize, + 104usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X18) + stringify!(AMD64_Dr6) ) ); } - test_field_X18(); - fn test_field_X19() { + test_field_AMD64_Dr6(); + fn test_field_AMD64_Dr7() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X19) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_Dr7) as usize - ptr as usize }, - 152usize, + 112usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X19) + stringify!(AMD64_Dr7) ) ); } - test_field_X19(); - fn test_field_X20() { + test_field_AMD64_Dr7(); + fn test_field_X8() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X20) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X8) as usize - ptr as usize }, - 160usize, + 120usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X20) + stringify!(X8) ) ); } - test_field_X20(); - fn test_field_X21() { + test_field_X8(); + fn test_field_X0() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X21) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X0) as usize - ptr as usize }, - 168usize, + 128usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X21) + stringify!(X0) ) ); } - test_field_X21(); - fn test_field_X22() { + test_field_X0(); + fn test_field_X1() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X22) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X1) as usize - ptr as usize }, - 176usize, + 136usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X22) + stringify!(X1) ) ); } - test_field_X22(); - fn test_field_X23() { + test_field_X1(); + fn test_field_X27() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X23) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X27) as usize - ptr as usize }, - 184usize, + 144usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X23) + stringify!(X27) ) ); } - test_field_X23(); - fn test_field_X24() { + test_field_X27(); + fn test_field_Sp() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X24) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Sp) as usize - ptr as usize }, - 192usize, + 152usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X24) + stringify!(Sp) ) ); } - test_field_X24(); + test_field_Sp(); + fn test_field_Fp() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Fp) as usize - ptr as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + "::", + stringify!(Fp) + ) + ); + } + test_field_Fp(); fn test_field_X25() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); ::std::ptr::addr_of!((*ptr).X25) as usize - ptr as usize }, - 200usize, + 168usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", stringify!(X25) ) @@ -30437,5822 +31105,5665 @@ fn bindgen_test_layout__ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1() { fn test_field_X26() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); ::std::ptr::addr_of!((*ptr).X26) as usize - ptr as usize }, - 208usize, + 176usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", stringify!(X26) ) ); } test_field_X26(); - fn test_field_X27() { + fn test_field_X2() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X27) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X2) as usize - ptr as usize }, - 216usize, + 184usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X27) + stringify!(X2) ) ); } - test_field_X27(); - fn test_field_X28() { + test_field_X2(); + fn test_field_X3() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X28) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X3) as usize - ptr as usize }, - 224usize, + 192usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X28) + stringify!(X3) ) ); } - test_field_X28(); - fn test_field_Fp() { + test_field_X3(); + fn test_field_X4() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Fp) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X4) as usize - ptr as usize }, - 232usize, + 200usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Fp) + stringify!(X4) ) ); } - test_field_Fp(); - fn test_field_Lr() { + test_field_X4(); + fn test_field_X5() { assert_eq!( unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 > :: uninit () ; + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Lr) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X5) as usize - ptr as usize }, - 240usize, + 208usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Lr) + stringify!(X5) ) ); } - test_field_Lr(); -} -#[test] -fn bindgen_test_layout__ARM64_NT_CONTEXT__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_ARM64_NT_CONTEXT__bindgen_ty_1>(), - 248usize, - concat!("Size of: ", stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1)) - ); - assert_eq!( - ::std::mem::align_of::<_ARM64_NT_CONTEXT__bindgen_ty_1>(), - 8usize, - concat!("Alignment of ", stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1)) - ); - fn test_field_X() { + test_field_X5(); + fn test_field_X19() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X19) as usize - ptr as usize }, - 0usize, + 216usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT__bindgen_ty_1), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X) + stringify!(X19) ) ); } - test_field_X(); -} -#[test] -fn bindgen_test_layout__ARM64_NT_CONTEXT() { - assert_eq!( - ::std::mem::size_of::<_ARM64_NT_CONTEXT>(), - 912usize, - concat!("Size of: ", stringify!(_ARM64_NT_CONTEXT)) - ); - assert_eq!( - ::std::mem::align_of::<_ARM64_NT_CONTEXT>(), - 16usize, - concat!("Alignment of ", stringify!(_ARM64_NT_CONTEXT)) - ); - fn test_field_ContextFlags() { + test_field_X19(); + fn test_field_X20() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ContextFlags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X20) as usize - ptr as usize }, - 0usize, + 224usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(ContextFlags) + stringify!(X20) ) ); } - test_field_ContextFlags(); - fn test_field_Cpsr() { + test_field_X20(); + fn test_field_X21() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Cpsr) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X21) as usize - ptr as usize }, - 4usize, + 232usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Cpsr) + stringify!(X21) ) ); } - test_field_Cpsr(); - fn test_field_Sp() { + test_field_X21(); + fn test_field_X22() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Sp) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X22) as usize - ptr as usize }, - 256usize, + 240usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Sp) + stringify!(X22) ) ); } - test_field_Sp(); + test_field_X22(); fn test_field_Pc() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); ::std::ptr::addr_of!((*ptr).Pc) as usize - ptr as usize }, - 264usize, + 248usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", stringify!(Pc) ) ); } test_field_Pc(); - fn test_field_V() { + fn test_field_AMD64_VectorRegister() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).V) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_VectorRegister) as usize - ptr as usize }, - 272usize, + 768usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(V) + stringify!(AMD64_VectorRegister) ) ); } - test_field_V(); - fn test_field_Fpcr() { + test_field_AMD64_VectorRegister(); + fn test_field_AMD64_VectorControl() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Fpcr) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_VectorControl) as usize - ptr as usize }, - 784usize, + 1184usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Fpcr) + stringify!(AMD64_VectorControl) ) ); } - test_field_Fpcr(); - fn test_field_Fpsr() { + test_field_AMD64_VectorControl(); + fn test_field_AMD64_DebugControl() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Fpsr) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_DebugControl) as usize - ptr as usize }, - 788usize, + 1192usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Fpsr) + stringify!(AMD64_DebugControl) ) ); } - test_field_Fpsr(); - fn test_field_Bcr() { + test_field_AMD64_DebugControl(); + fn test_field_AMD64_LastBranchToRip() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Bcr) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_LastBranchToRip) as usize - ptr as usize }, - 792usize, + 1200usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Bcr) + stringify!(AMD64_LastBranchToRip) ) ); } - test_field_Bcr(); - fn test_field_Bvr() { + test_field_AMD64_LastBranchToRip(); + fn test_field_AMD64_LastBranchFromRip() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Bvr) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_LastBranchFromRip) as usize - ptr as usize }, - 824usize, + 1208usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Bvr) + stringify!(AMD64_LastBranchFromRip) ) ); } - test_field_Bvr(); - fn test_field_Wcr() { + test_field_AMD64_LastBranchFromRip(); + fn test_field_AMD64_LastExceptionToRip() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Wcr) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_LastExceptionToRip) as usize - ptr as usize }, - 888usize, + 1216usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Wcr) + stringify!(AMD64_LastExceptionToRip) ) ); } - test_field_Wcr(); - fn test_field_Wvr() { + test_field_AMD64_LastExceptionToRip(); + fn test_field_AMD64_LastExceptionFromRip() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ARM64_NT_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Wvr) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AMD64_LastExceptionFromRip) as usize - ptr as usize }, - 896usize, + 1224usize, concat!( "Offset of field: ", - stringify!(_ARM64_NT_CONTEXT), + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(Wvr) + stringify!(AMD64_LastExceptionFromRip) ) ); } - test_field_Wvr(); + test_field_AMD64_LastExceptionFromRip(); } -pub type ARM64_NT_CONTEXT = _ARM64_NT_CONTEXT; -pub type PARM64_NT_CONTEXT = *mut _ARM64_NT_CONTEXT; -#[repr(C)] -#[repr(align(16))] -#[derive(Copy, Clone)] -pub struct _ARM64EC_NT_CONTEXT { - pub __bindgen_anon_1: _ARM64EC_NT_CONTEXT__bindgen_ty_1, +#[test] +fn bindgen_test_layout__ARM64EC_NT_CONTEXT__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<_ARM64EC_NT_CONTEXT__bindgen_ty_1>(), + 1232usize, + concat!("Size of: ", stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::<_ARM64EC_NT_CONTEXT__bindgen_ty_1>(), + 8usize, + concat!( + "Alignment of ", + stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1) + ) + ); } -#[repr(C)] -#[derive(Copy, Clone)] -pub union _ARM64EC_NT_CONTEXT__bindgen_ty_1 { - pub __bindgen_anon_1: _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, +#[test] +fn bindgen_test_layout__ARM64EC_NT_CONTEXT() { + assert_eq!( + ::std::mem::size_of::<_ARM64EC_NT_CONTEXT>(), + 1232usize, + concat!("Size of: ", stringify!(_ARM64EC_NT_CONTEXT)) + ); + assert_eq!( + ::std::mem::align_of::<_ARM64EC_NT_CONTEXT>(), + 16usize, + concat!("Alignment of ", stringify!(_ARM64EC_NT_CONTEXT)) + ); } +pub type ARM64EC_NT_CONTEXT = _ARM64EC_NT_CONTEXT; +pub type PARM64EC_NT_CONTEXT = *mut _ARM64EC_NT_CONTEXT; +pub type ARM64_RUNTIME_FUNCTION = _IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY; +pub type PARM64_RUNTIME_FUNCTION = *mut _IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY; #[repr(C)] #[derive(Copy, Clone)] -pub struct _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1 { - pub AMD64_P1Home: DWORD64, - pub AMD64_P2Home: DWORD64, - pub AMD64_P3Home: DWORD64, - pub AMD64_P4Home: DWORD64, - pub AMD64_P5Home: DWORD64, - pub AMD64_P6Home: DWORD64, - pub ContextFlags: DWORD, - pub AMD64_MxCsr_copy: DWORD, - pub AMD64_SegCs: WORD, - pub AMD64_SegDs: WORD, - pub AMD64_SegEs: WORD, - pub AMD64_SegFs: WORD, - pub AMD64_SegGs: WORD, - pub AMD64_SegSs: WORD, - pub AMD64_EFlags: DWORD, - pub AMD64_Dr0: DWORD64, - pub AMD64_Dr1: DWORD64, - pub AMD64_Dr2: DWORD64, - pub AMD64_Dr3: DWORD64, - pub AMD64_Dr6: DWORD64, - pub AMD64_Dr7: DWORD64, - pub X8: DWORD64, - pub X0: DWORD64, - pub X1: DWORD64, - pub X27: DWORD64, - pub Sp: DWORD64, - pub Fp: DWORD64, - pub X25: DWORD64, - pub X26: DWORD64, - pub X2: DWORD64, - pub X3: DWORD64, - pub X4: DWORD64, - pub X5: DWORD64, - pub X19: DWORD64, - pub X20: DWORD64, - pub X21: DWORD64, - pub X22: DWORD64, - pub Pc: DWORD64, - pub __bindgen_anon_1: _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - pub AMD64_VectorRegister: [ARM64_NT_NEON128; 26usize], - pub AMD64_VectorControl: DWORD64, - pub AMD64_DebugControl: DWORD64, - pub AMD64_LastBranchToRip: DWORD64, - pub AMD64_LastBranchFromRip: DWORD64, - pub AMD64_LastExceptionToRip: DWORD64, - pub AMD64_LastExceptionFromRip: DWORD64, +pub union _DISPATCHER_CONTEXT_NONVOLREG_ARM64 { + pub Buffer: [BYTE; 152usize], + pub __bindgen_anon_1: _DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1, } #[repr(C)] -#[derive(Copy, Clone)] -pub struct _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 { - pub AMD64_ControlWord: WORD, - pub AMD64_StatusWord: WORD, - pub AMD64_TagWord: BYTE, - pub AMD64_Reserved1: BYTE, - pub AMD64_ErrorOpcode: WORD, - pub AMD64_ErrorOffset: DWORD, - pub AMD64_ErrorSelector: WORD, - pub AMD64_Reserved2: WORD, - pub AMD64_DataOffset: DWORD, - pub AMD64_DataSelector: WORD, - pub AMD64_Reserved3: WORD, - pub AMD64_MxCsr: DWORD, - pub AMD64_MxCsr_Mask: DWORD, - pub Lr: DWORD64, - pub X16_0: WORD, - pub AMD64_St0_Reserved1: WORD, - pub AMD64_St0_Reserved2: DWORD, - pub X6: DWORD64, - pub X16_1: WORD, - pub AMD64_St1_Reserved1: WORD, - pub AMD64_St1_Reserved2: DWORD, - pub X7: DWORD64, - pub X16_2: WORD, - pub AMD64_St2_Reserved1: WORD, - pub AMD64_St2_Reserved2: DWORD, - pub X9: DWORD64, - pub X16_3: WORD, - pub AMD64_St3_Reserved1: WORD, - pub AMD64_St3_Reserved2: DWORD, - pub X10: DWORD64, - pub X17_0: WORD, - pub AMD64_St4_Reserved1: WORD, - pub AMD64_St4_Reserved2: DWORD, - pub X11: DWORD64, - pub X17_1: WORD, - pub AMD64_St5_Reserved1: WORD, - pub AMD64_St5_Reserved2: DWORD, - pub X12: DWORD64, - pub X17_2: WORD, - pub AMD64_St6_Reserved1: WORD, - pub AMD64_St6_Reserved2: DWORD, - pub X15: DWORD64, - pub X17_3: WORD, - pub AMD64_St7_Reserved1: WORD, - pub AMD64_St7_Reserved2: DWORD, - pub V: [ARM64_NT_NEON128; 16usize], - pub AMD64_XSAVE_FORMAT_Reserved4: [BYTE; 96usize], +#[derive(Debug, Copy, Clone)] +pub struct _DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1 { + pub GpNvRegs: [DWORD64; 11usize], + pub FpNvRegs: [f64; 8usize], } #[test] -fn bindgen_test_layout__ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1() { +fn bindgen_test_layout__DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1>(), - 512usize, + ::std::mem::size_of::<_DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1>(), + 152usize, concat!( "Size of: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1) + stringify!(_DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1) ) ); assert_eq!( - ::std::mem::align_of::<_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1>(), + ::std::mem::align_of::<_DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1>(), 8usize, concat!( "Alignment of ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1) + stringify!(_DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1) ) ); - fn test_field_AMD64_ControlWord() { + fn test_field_GpNvRegs() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + _DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_ControlWord) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).GpNvRegs) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1), "::", - stringify!(AMD64_ControlWord) + stringify!(GpNvRegs) ) ); } - test_field_AMD64_ControlWord(); - fn test_field_AMD64_StatusWord() { + test_field_GpNvRegs(); + fn test_field_FpNvRegs() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + _DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_StatusWord) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).FpNvRegs) as usize - ptr as usize }, - 2usize, + 88usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1), "::", - stringify!(AMD64_StatusWord) + stringify!(FpNvRegs) ) ); } - test_field_AMD64_StatusWord(); - fn test_field_AMD64_TagWord() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_TagWord) as usize - ptr as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), - "::", - stringify!(AMD64_TagWord) - ) - ); - } - test_field_AMD64_TagWord(); - fn test_field_AMD64_Reserved1() { + test_field_FpNvRegs(); +} +#[test] +fn bindgen_test_layout__DISPATCHER_CONTEXT_NONVOLREG_ARM64() { + assert_eq!( + ::std::mem::size_of::<_DISPATCHER_CONTEXT_NONVOLREG_ARM64>(), + 152usize, + concat!("Size of: ", stringify!(_DISPATCHER_CONTEXT_NONVOLREG_ARM64)) + ); + assert_eq!( + ::std::mem::align_of::<_DISPATCHER_CONTEXT_NONVOLREG_ARM64>(), + 8usize, + concat!( + "Alignment of ", + stringify!(_DISPATCHER_CONTEXT_NONVOLREG_ARM64) + ) + ); + fn test_field_Buffer() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_NONVOLREG_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_Reserved1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Buffer) as usize - ptr as usize }, - 5usize, + 0usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_DISPATCHER_CONTEXT_NONVOLREG_ARM64), "::", - stringify!(AMD64_Reserved1) + stringify!(Buffer) ) ); } - test_field_AMD64_Reserved1(); - fn test_field_AMD64_ErrorOpcode() { + test_field_Buffer(); +} +pub type DISPATCHER_CONTEXT_NONVOLREG_ARM64 = _DISPATCHER_CONTEXT_NONVOLREG_ARM64; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _DISPATCHER_CONTEXT_ARM64 { + pub ControlPc: ULONG_PTR, + pub ImageBase: ULONG_PTR, + pub FunctionEntry: PARM64_RUNTIME_FUNCTION, + pub EstablisherFrame: ULONG_PTR, + pub TargetPc: ULONG_PTR, + pub ContextRecord: PARM64_NT_CONTEXT, + pub LanguageHandler: PEXCEPTION_ROUTINE, + pub HandlerData: PVOID, + pub HistoryTable: *mut _UNWIND_HISTORY_TABLE, + pub ScopeIndex: DWORD, + pub ControlPcIsUnwound: BOOLEAN, + pub NonVolatileRegisters: PBYTE, +} +#[test] +fn bindgen_test_layout__DISPATCHER_CONTEXT_ARM64() { + assert_eq!( + ::std::mem::size_of::<_DISPATCHER_CONTEXT_ARM64>(), + 88usize, + concat!("Size of: ", stringify!(_DISPATCHER_CONTEXT_ARM64)) + ); + assert_eq!( + ::std::mem::align_of::<_DISPATCHER_CONTEXT_ARM64>(), + 8usize, + concat!("Alignment of ", stringify!(_DISPATCHER_CONTEXT_ARM64)) + ); + fn test_field_ControlPc() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_ErrorOpcode) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ControlPc) as usize - ptr as usize }, - 6usize, + 0usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_DISPATCHER_CONTEXT_ARM64), "::", - stringify!(AMD64_ErrorOpcode) + stringify!(ControlPc) ) ); } - test_field_AMD64_ErrorOpcode(); - fn test_field_AMD64_ErrorOffset() { + test_field_ControlPc(); + fn test_field_ImageBase() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_ErrorOffset) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ImageBase) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_DISPATCHER_CONTEXT_ARM64), "::", - stringify!(AMD64_ErrorOffset) + stringify!(ImageBase) ) ); } - test_field_AMD64_ErrorOffset(); - fn test_field_AMD64_ErrorSelector() { + test_field_ImageBase(); + fn test_field_FunctionEntry() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_ErrorSelector) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).FunctionEntry) as usize - ptr as usize }, - 12usize, + 16usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_DISPATCHER_CONTEXT_ARM64), "::", - stringify!(AMD64_ErrorSelector) + stringify!(FunctionEntry) ) ); } - test_field_AMD64_ErrorSelector(); - fn test_field_AMD64_Reserved2() { + test_field_FunctionEntry(); + fn test_field_EstablisherFrame() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_Reserved2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).EstablisherFrame) as usize - ptr as usize }, - 14usize, + 24usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_DISPATCHER_CONTEXT_ARM64), "::", - stringify!(AMD64_Reserved2) + stringify!(EstablisherFrame) ) ); } - test_field_AMD64_Reserved2(); - fn test_field_AMD64_DataOffset() { + test_field_EstablisherFrame(); + fn test_field_TargetPc() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_DataOffset) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).TargetPc) as usize - ptr as usize }, - 16usize, + 32usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_DISPATCHER_CONTEXT_ARM64), "::", - stringify!(AMD64_DataOffset) + stringify!(TargetPc) ) ); } - test_field_AMD64_DataOffset(); - fn test_field_AMD64_DataSelector() { + test_field_TargetPc(); + fn test_field_ContextRecord() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_DataSelector) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ContextRecord) as usize - ptr as usize }, - 20usize, + 40usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_DISPATCHER_CONTEXT_ARM64), "::", - stringify!(AMD64_DataSelector) + stringify!(ContextRecord) ) ); } - test_field_AMD64_DataSelector(); - fn test_field_AMD64_Reserved3() { + test_field_ContextRecord(); + fn test_field_LanguageHandler() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_Reserved3) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).LanguageHandler) as usize - ptr as usize }, - 22usize, + 48usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_DISPATCHER_CONTEXT_ARM64), "::", - stringify!(AMD64_Reserved3) + stringify!(LanguageHandler) ) ); } - test_field_AMD64_Reserved3(); - fn test_field_AMD64_MxCsr() { + test_field_LanguageHandler(); + fn test_field_HandlerData() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_MxCsr) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).HandlerData) as usize - ptr as usize }, - 24usize, + 56usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_DISPATCHER_CONTEXT_ARM64), "::", - stringify!(AMD64_MxCsr) + stringify!(HandlerData) ) ); } - test_field_AMD64_MxCsr(); - fn test_field_AMD64_MxCsr_Mask() { + test_field_HandlerData(); + fn test_field_HistoryTable() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_MxCsr_Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).HistoryTable) as usize - ptr as usize }, - 28usize, + 64usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_DISPATCHER_CONTEXT_ARM64), "::", - stringify!(AMD64_MxCsr_Mask) + stringify!(HistoryTable) ) ); } - test_field_AMD64_MxCsr_Mask(); - fn test_field_Lr() { + test_field_HistoryTable(); + fn test_field_ScopeIndex() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Lr) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ScopeIndex) as usize - ptr as usize }, - 32usize, + 72usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_DISPATCHER_CONTEXT_ARM64), "::", - stringify!(Lr) + stringify!(ScopeIndex) ) ); } - test_field_Lr(); - fn test_field_X16_0() { + test_field_ScopeIndex(); + fn test_field_ControlPcIsUnwound() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X16_0) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ControlPcIsUnwound) as usize - ptr as usize }, - 40usize, + 76usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_DISPATCHER_CONTEXT_ARM64), "::", - stringify!(X16_0) + stringify!(ControlPcIsUnwound) ) ); } - test_field_X16_0(); - fn test_field_AMD64_St0_Reserved1() { + test_field_ControlPcIsUnwound(); + fn test_field_NonVolatileRegisters() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_St0_Reserved1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).NonVolatileRegisters) as usize - ptr as usize }, - 42usize, + 80usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_DISPATCHER_CONTEXT_ARM64), "::", - stringify!(AMD64_St0_Reserved1) + stringify!(NonVolatileRegisters) ) ); } - test_field_AMD64_St0_Reserved1(); - fn test_field_AMD64_St0_Reserved2() { + test_field_NonVolatileRegisters(); +} +pub type DISPATCHER_CONTEXT_ARM64 = _DISPATCHER_CONTEXT_ARM64; +pub type PDISPATCHER_CONTEXT_ARM64 = *mut _DISPATCHER_CONTEXT_ARM64; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _KNONVOLATILE_CONTEXT_POINTERS_ARM64 { + pub X19: PDWORD64, + pub X20: PDWORD64, + pub X21: PDWORD64, + pub X22: PDWORD64, + pub X23: PDWORD64, + pub X24: PDWORD64, + pub X25: PDWORD64, + pub X26: PDWORD64, + pub X27: PDWORD64, + pub X28: PDWORD64, + pub Fp: PDWORD64, + pub Lr: PDWORD64, + pub D8: PDWORD64, + pub D9: PDWORD64, + pub D10: PDWORD64, + pub D11: PDWORD64, + pub D12: PDWORD64, + pub D13: PDWORD64, + pub D14: PDWORD64, + pub D15: PDWORD64, +} +#[test] +fn bindgen_test_layout__KNONVOLATILE_CONTEXT_POINTERS_ARM64() { + assert_eq!( + ::std::mem::size_of::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>(), + 160usize, + concat!( + "Size of: ", + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64) + ) + ); + assert_eq!( + ::std::mem::align_of::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>(), + 8usize, + concat!( + "Alignment of ", + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64) + ) + ); + fn test_field_X19() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_St0_Reserved2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X19) as usize - ptr as usize }, - 44usize, + 0usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), "::", - stringify!(AMD64_St0_Reserved2) + stringify!(X19) ) ); } - test_field_AMD64_St0_Reserved2(); - fn test_field_X6() { + test_field_X19(); + fn test_field_X20() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X6) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X20) as usize - ptr as usize }, - 48usize, + 8usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), "::", - stringify!(X6) + stringify!(X20) ) ); } - test_field_X6(); - fn test_field_X16_1() { + test_field_X20(); + fn test_field_X21() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X16_1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X21) as usize - ptr as usize }, - 56usize, + 16usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), "::", - stringify!(X16_1) + stringify!(X21) ) ); } - test_field_X16_1(); - fn test_field_AMD64_St1_Reserved1() { + test_field_X21(); + fn test_field_X22() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_St1_Reserved1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X22) as usize - ptr as usize }, - 58usize, + 24usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), "::", - stringify!(AMD64_St1_Reserved1) + stringify!(X22) ) ); } - test_field_AMD64_St1_Reserved1(); - fn test_field_AMD64_St1_Reserved2() { + test_field_X22(); + fn test_field_X23() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_St1_Reserved2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X23) as usize - ptr as usize }, - 60usize, + 32usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), "::", - stringify!(AMD64_St1_Reserved2) + stringify!(X23) ) ); } - test_field_AMD64_St1_Reserved2(); - fn test_field_X7() { + test_field_X23(); + fn test_field_X24() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X7) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X24) as usize - ptr as usize }, - 64usize, + 40usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), "::", - stringify!(X7) + stringify!(X24) ) ); } - test_field_X7(); - fn test_field_X16_2() { + test_field_X24(); + fn test_field_X25() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X16_2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X25) as usize - ptr as usize }, - 72usize, + 48usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), "::", - stringify!(X16_2) + stringify!(X25) ) ); } - test_field_X16_2(); - fn test_field_AMD64_St2_Reserved1() { + test_field_X25(); + fn test_field_X26() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_St2_Reserved1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X26) as usize - ptr as usize }, - 74usize, + 56usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), "::", - stringify!(AMD64_St2_Reserved1) + stringify!(X26) ) ); } - test_field_AMD64_St2_Reserved1(); - fn test_field_AMD64_St2_Reserved2() { + test_field_X26(); + fn test_field_X27() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_St2_Reserved2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X27) as usize - ptr as usize }, - 76usize, + 64usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), "::", - stringify!(AMD64_St2_Reserved2) + stringify!(X27) ) ); } - test_field_AMD64_St2_Reserved2(); - fn test_field_X9() { + test_field_X27(); + fn test_field_X28() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X9) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).X28) as usize - ptr as usize }, - 80usize, + 72usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), "::", - stringify!(X9) + stringify!(X28) ) ); } - test_field_X9(); - fn test_field_X16_3() { + test_field_X28(); + fn test_field_Fp() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X16_3) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Fp) as usize - ptr as usize }, - 88usize, + 80usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), "::", - stringify!(X16_3) + stringify!(Fp) ) ); } - test_field_X16_3(); - fn test_field_AMD64_St3_Reserved1() { + test_field_Fp(); + fn test_field_Lr() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_St3_Reserved1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Lr) as usize - ptr as usize }, - 90usize, + 88usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), "::", - stringify!(AMD64_St3_Reserved1) + stringify!(Lr) ) ); } - test_field_AMD64_St3_Reserved1(); - fn test_field_AMD64_St3_Reserved2() { + test_field_Lr(); + fn test_field_D8() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_St3_Reserved2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).D8) as usize - ptr as usize }, - 92usize, + 96usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), "::", - stringify!(AMD64_St3_Reserved2) + stringify!(D8) ) ); } - test_field_AMD64_St3_Reserved2(); - fn test_field_X10() { + test_field_D8(); + fn test_field_D9() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X10) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).D9) as usize - ptr as usize }, - 96usize, + 104usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), "::", - stringify!(X10) + stringify!(D9) ) ); } - test_field_X10(); - fn test_field_X17_0() { + test_field_D9(); + fn test_field_D10() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X17_0) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).D10) as usize - ptr as usize }, - 104usize, + 112usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), "::", - stringify!(X17_0) + stringify!(D10) ) ); } - test_field_X17_0(); - fn test_field_AMD64_St4_Reserved1() { + test_field_D10(); + fn test_field_D11() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_St4_Reserved1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).D11) as usize - ptr as usize }, - 106usize, + 120usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), "::", - stringify!(AMD64_St4_Reserved1) + stringify!(D11) ) ); } - test_field_AMD64_St4_Reserved1(); - fn test_field_AMD64_St4_Reserved2() { + test_field_D11(); + fn test_field_D12() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_St4_Reserved2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).D12) as usize - ptr as usize }, - 108usize, + 128usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), "::", - stringify!(AMD64_St4_Reserved2) + stringify!(D12) ) ); } - test_field_AMD64_St4_Reserved2(); - fn test_field_X11() { + test_field_D12(); + fn test_field_D13() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X11) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).D13) as usize - ptr as usize }, - 112usize, + 136usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), "::", - stringify!(X11) + stringify!(D13) ) ); } - test_field_X11(); - fn test_field_X17_1() { + test_field_D13(); + fn test_field_D14() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X17_1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).D14) as usize - ptr as usize }, - 120usize, + 144usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), "::", - stringify!(X17_1) + stringify!(D14) ) ); } - test_field_X17_1(); - fn test_field_AMD64_St5_Reserved1() { + test_field_D14(); + fn test_field_D15() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_St5_Reserved1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).D15) as usize - ptr as usize }, - 122usize, + 152usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), "::", - stringify!(AMD64_St5_Reserved1) + stringify!(D15) ) ); } - test_field_AMD64_St5_Reserved1(); - fn test_field_AMD64_St5_Reserved2() { + test_field_D15(); +} +pub type KNONVOLATILE_CONTEXT_POINTERS_ARM64 = _KNONVOLATILE_CONTEXT_POINTERS_ARM64; +pub type PKNONVOLATILE_CONTEXT_POINTERS_ARM64 = *mut _KNONVOLATILE_CONTEXT_POINTERS_ARM64; +extern "C" { + pub fn __int2c(); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _LDT_ENTRY { + pub LimitLow: WORD, + pub BaseLow: WORD, + pub HighWord: _LDT_ENTRY__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _LDT_ENTRY__bindgen_ty_1 { + pub Bytes: _LDT_ENTRY__bindgen_ty_1__bindgen_ty_1, + pub Bits: _LDT_ENTRY__bindgen_ty_1__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _LDT_ENTRY__bindgen_ty_1__bindgen_ty_1 { + pub BaseMid: BYTE, + pub Flags1: BYTE, + pub Flags2: BYTE, + pub BaseHi: BYTE, +} +#[test] +fn bindgen_test_layout__LDT_ENTRY__bindgen_ty_1__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>(), + 4usize, + concat!( + "Size of: ", + stringify!(_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1) + ) + ); + assert_eq!( + ::std::mem::align_of::<_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>(), + 1usize, + concat!( + "Alignment of ", + stringify!(_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1) + ) + ); + fn test_field_BaseMid() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_St5_Reserved2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).BaseMid) as usize - ptr as usize }, - 124usize, + 0usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(AMD64_St5_Reserved2) + stringify!(BaseMid) ) ); } - test_field_AMD64_St5_Reserved2(); - fn test_field_X12() { + test_field_BaseMid(); + fn test_field_Flags1() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X12) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags1) as usize - ptr as usize }, - 128usize, + 1usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X12) + stringify!(Flags1) ) ); } - test_field_X12(); - fn test_field_X17_2() { + test_field_Flags1(); + fn test_field_Flags2() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X17_2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags2) as usize - ptr as usize }, - 136usize, + 2usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(X17_2) + stringify!(Flags2) ) ); } - test_field_X17_2(); - fn test_field_AMD64_St6_Reserved1() { + test_field_Flags2(); + fn test_field_BaseHi() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_St6_Reserved1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).BaseHi) as usize - ptr as usize }, - 138usize, + 3usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(AMD64_St6_Reserved1) + stringify!(BaseHi) ) ); } - test_field_AMD64_St6_Reserved1(); - fn test_field_AMD64_St6_Reserved2() { + test_field_BaseHi(); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct _LDT_ENTRY__bindgen_ty_1__bindgen_ty_2 { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +#[test] +fn bindgen_test_layout__LDT_ENTRY__bindgen_ty_1__bindgen_ty_2() { + assert_eq!( + ::std::mem::size_of::<_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2>(), + 4usize, + concat!( + "Size of: ", + stringify!(_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2) + ) + ); + assert_eq!( + ::std::mem::align_of::<_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2>(), + 4usize, + concat!( + "Alignment of ", + stringify!(_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2) + ) + ); +} +impl _LDT_ENTRY__bindgen_ty_1__bindgen_ty_2 { + #[inline] + pub fn BaseMid(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) } + } + #[inline] + pub fn set_BaseMid(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 8u8, val as u64) + } + } + #[inline] + pub fn Type(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 5u8) as u32) } + } + #[inline] + pub fn set_Type(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 5u8, val as u64) + } + } + #[inline] + pub fn Dpl(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 2u8) as u32) } + } + #[inline] + pub fn set_Dpl(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 2u8, val as u64) + } + } + #[inline] + pub fn Pres(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } + } + #[inline] + pub fn set_Pres(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 1u8, val as u64) + } + } + #[inline] + pub fn LimitHi(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 4u8) as u32) } + } + #[inline] + pub fn set_LimitHi(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 4u8, val as u64) + } + } + #[inline] + pub fn Sys(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) } + } + #[inline] + pub fn set_Sys(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 1u8, val as u64) + } + } + #[inline] + pub fn Reserved_0(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) } + } + #[inline] + pub fn set_Reserved_0(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 1u8, val as u64) + } + } + #[inline] + pub fn Default_Big(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) } + } + #[inline] + pub fn set_Default_Big(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 1u8, val as u64) + } + } + #[inline] + pub fn Granularity(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } + } + #[inline] + pub fn set_Granularity(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub fn BaseHi(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } + } + #[inline] + pub fn set_BaseHi(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 8u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + BaseMid: DWORD, + Type: DWORD, + Dpl: DWORD, + Pres: DWORD, + LimitHi: DWORD, + Sys: DWORD, + Reserved_0: DWORD, + Default_Big: DWORD, + Granularity: DWORD, + BaseHi: DWORD, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 8u8, { + let BaseMid: u32 = unsafe { ::std::mem::transmute(BaseMid) }; + BaseMid as u64 + }); + __bindgen_bitfield_unit.set(8usize, 5u8, { + let Type: u32 = unsafe { ::std::mem::transmute(Type) }; + Type as u64 + }); + __bindgen_bitfield_unit.set(13usize, 2u8, { + let Dpl: u32 = unsafe { ::std::mem::transmute(Dpl) }; + Dpl as u64 + }); + __bindgen_bitfield_unit.set(15usize, 1u8, { + let Pres: u32 = unsafe { ::std::mem::transmute(Pres) }; + Pres as u64 + }); + __bindgen_bitfield_unit.set(16usize, 4u8, { + let LimitHi: u32 = unsafe { ::std::mem::transmute(LimitHi) }; + LimitHi as u64 + }); + __bindgen_bitfield_unit.set(20usize, 1u8, { + let Sys: u32 = unsafe { ::std::mem::transmute(Sys) }; + Sys as u64 + }); + __bindgen_bitfield_unit.set(21usize, 1u8, { + let Reserved_0: u32 = unsafe { ::std::mem::transmute(Reserved_0) }; + Reserved_0 as u64 + }); + __bindgen_bitfield_unit.set(22usize, 1u8, { + let Default_Big: u32 = unsafe { ::std::mem::transmute(Default_Big) }; + Default_Big as u64 + }); + __bindgen_bitfield_unit.set(23usize, 1u8, { + let Granularity: u32 = unsafe { ::std::mem::transmute(Granularity) }; + Granularity as u64 + }); + __bindgen_bitfield_unit.set(24usize, 8u8, { + let BaseHi: u32 = unsafe { ::std::mem::transmute(BaseHi) }; + BaseHi as u64 + }); + __bindgen_bitfield_unit + } +} +#[test] +fn bindgen_test_layout__LDT_ENTRY__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<_LDT_ENTRY__bindgen_ty_1>(), + 4usize, + concat!("Size of: ", stringify!(_LDT_ENTRY__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::<_LDT_ENTRY__bindgen_ty_1>(), + 4usize, + concat!("Alignment of ", stringify!(_LDT_ENTRY__bindgen_ty_1)) + ); + fn test_field_Bytes() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_LDT_ENTRY__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_St6_Reserved2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Bytes) as usize - ptr as usize }, - 140usize, + 0usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_LDT_ENTRY__bindgen_ty_1), "::", - stringify!(AMD64_St6_Reserved2) + stringify!(Bytes) ) ); } - test_field_AMD64_St6_Reserved2(); - fn test_field_X15() { + test_field_Bytes(); + fn test_field_Bits() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_LDT_ENTRY__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X15) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Bits) as usize - ptr as usize }, - 144usize, + 0usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_LDT_ENTRY__bindgen_ty_1), "::", - stringify!(X15) + stringify!(Bits) ) ); } - test_field_X15(); - fn test_field_X17_3() { + test_field_Bits(); +} +#[test] +fn bindgen_test_layout__LDT_ENTRY() { + assert_eq!( + ::std::mem::size_of::<_LDT_ENTRY>(), + 8usize, + concat!("Size of: ", stringify!(_LDT_ENTRY)) + ); + assert_eq!( + ::std::mem::align_of::<_LDT_ENTRY>(), + 4usize, + concat!("Alignment of ", stringify!(_LDT_ENTRY)) + ); + fn test_field_LimitLow() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_LDT_ENTRY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X17_3) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).LimitLow) as usize - ptr as usize }, - 152usize, + 0usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_LDT_ENTRY), "::", - stringify!(X17_3) + stringify!(LimitLow) ) ); } - test_field_X17_3(); - fn test_field_AMD64_St7_Reserved1() { + test_field_LimitLow(); + fn test_field_BaseLow() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_St7_Reserved1) as usize - ptr as usize - }, - 154usize, - concat!( - "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), - "::", - stringify!(AMD64_St7_Reserved1) - ) - ); - } - test_field_AMD64_St7_Reserved1(); - fn test_field_AMD64_St7_Reserved2() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_St7_Reserved2) as usize - ptr as usize - }, - 156usize, - concat!( - "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), - "::", - stringify!(AMD64_St7_Reserved2) - ) - ); - } - test_field_AMD64_St7_Reserved2(); - fn test_field_V() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_LDT_ENTRY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).V) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).BaseLow) as usize - ptr as usize }, - 160usize, + 2usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_LDT_ENTRY), "::", - stringify!(V) + stringify!(BaseLow) ) ); } - test_field_V(); - fn test_field_AMD64_XSAVE_FORMAT_Reserved4() { + test_field_BaseLow(); + fn test_field_HighWord() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_LDT_ENTRY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_XSAVE_FORMAT_Reserved4) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).HighWord) as usize - ptr as usize }, - 416usize, + 4usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1), + stringify!(_LDT_ENTRY), "::", - stringify!(AMD64_XSAVE_FORMAT_Reserved4) + stringify!(HighWord) ) ); } - test_field_AMD64_XSAVE_FORMAT_Reserved4(); + test_field_HighWord(); +} +pub type LDT_ENTRY = _LDT_ENTRY; +pub type PLDT_ENTRY = *mut _LDT_ENTRY; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _WOW64_FLOATING_SAVE_AREA { + pub ControlWord: DWORD, + pub StatusWord: DWORD, + pub TagWord: DWORD, + pub ErrorOffset: DWORD, + pub ErrorSelector: DWORD, + pub DataOffset: DWORD, + pub DataSelector: DWORD, + pub RegisterArea: [BYTE; 80usize], + pub Cr0NpxState: DWORD, } #[test] -fn bindgen_test_layout__ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1() { +fn bindgen_test_layout__WOW64_FLOATING_SAVE_AREA() { assert_eq!( - ::std::mem::size_of::<_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1>(), - 1232usize, - concat!( - "Size of: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1) - ) + ::std::mem::size_of::<_WOW64_FLOATING_SAVE_AREA>(), + 112usize, + concat!("Size of: ", stringify!(_WOW64_FLOATING_SAVE_AREA)) ); assert_eq!( - ::std::mem::align_of::<_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - concat!( - "Alignment of ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1) - ) + ::std::mem::align_of::<_WOW64_FLOATING_SAVE_AREA>(), + 4usize, + concat!("Alignment of ", stringify!(_WOW64_FLOATING_SAVE_AREA)) ); - fn test_field_AMD64_P1Home() { + fn test_field_ControlWord() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_FLOATING_SAVE_AREA>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_P1Home) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ControlWord) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), - "::", - stringify!(AMD64_P1Home) - ) - ); - } - test_field_AMD64_P1Home(); - fn test_field_AMD64_P2Home() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_P2Home) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), - "::", - stringify!(AMD64_P2Home) - ) - ); - } - test_field_AMD64_P2Home(); - fn test_field_AMD64_P3Home() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_P3Home) as usize - ptr as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), - "::", - stringify!(AMD64_P3Home) - ) - ); - } - test_field_AMD64_P3Home(); - fn test_field_AMD64_P4Home() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_P4Home) as usize - ptr as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), - "::", - stringify!(AMD64_P4Home) - ) - ); - } - test_field_AMD64_P4Home(); - fn test_field_AMD64_P5Home() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_P5Home) as usize - ptr as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), - "::", - stringify!(AMD64_P5Home) - ) - ); - } - test_field_AMD64_P5Home(); - fn test_field_AMD64_P6Home() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_P6Home) as usize - ptr as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), - "::", - stringify!(AMD64_P6Home) - ) - ); - } - test_field_AMD64_P6Home(); - fn test_field_ContextFlags() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ContextFlags) as usize - ptr as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_FLOATING_SAVE_AREA), "::", - stringify!(ContextFlags) + stringify!(ControlWord) ) ); } - test_field_ContextFlags(); - fn test_field_AMD64_MxCsr_copy() { + test_field_ControlWord(); + fn test_field_StatusWord() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_FLOATING_SAVE_AREA>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_MxCsr_copy) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).StatusWord) as usize - ptr as usize }, - 52usize, + 4usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_FLOATING_SAVE_AREA), "::", - stringify!(AMD64_MxCsr_copy) + stringify!(StatusWord) ) ); } - test_field_AMD64_MxCsr_copy(); - fn test_field_AMD64_SegCs() { + test_field_StatusWord(); + fn test_field_TagWord() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_FLOATING_SAVE_AREA>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_SegCs) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).TagWord) as usize - ptr as usize }, - 56usize, + 8usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_FLOATING_SAVE_AREA), "::", - stringify!(AMD64_SegCs) + stringify!(TagWord) ) ); } - test_field_AMD64_SegCs(); - fn test_field_AMD64_SegDs() { + test_field_TagWord(); + fn test_field_ErrorOffset() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_FLOATING_SAVE_AREA>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_SegDs) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ErrorOffset) as usize - ptr as usize }, - 58usize, + 12usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_FLOATING_SAVE_AREA), "::", - stringify!(AMD64_SegDs) + stringify!(ErrorOffset) ) ); } - test_field_AMD64_SegDs(); - fn test_field_AMD64_SegEs() { + test_field_ErrorOffset(); + fn test_field_ErrorSelector() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_FLOATING_SAVE_AREA>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_SegEs) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ErrorSelector) as usize - ptr as usize }, - 60usize, + 16usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_FLOATING_SAVE_AREA), "::", - stringify!(AMD64_SegEs) + stringify!(ErrorSelector) ) ); } - test_field_AMD64_SegEs(); - fn test_field_AMD64_SegFs() { + test_field_ErrorSelector(); + fn test_field_DataOffset() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_FLOATING_SAVE_AREA>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_SegFs) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).DataOffset) as usize - ptr as usize }, - 62usize, + 20usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_FLOATING_SAVE_AREA), "::", - stringify!(AMD64_SegFs) + stringify!(DataOffset) ) ); } - test_field_AMD64_SegFs(); - fn test_field_AMD64_SegGs() { + test_field_DataOffset(); + fn test_field_DataSelector() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_FLOATING_SAVE_AREA>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_SegGs) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).DataSelector) as usize - ptr as usize }, - 64usize, + 24usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_FLOATING_SAVE_AREA), "::", - stringify!(AMD64_SegGs) + stringify!(DataSelector) ) ); } - test_field_AMD64_SegGs(); - fn test_field_AMD64_SegSs() { + test_field_DataSelector(); + fn test_field_RegisterArea() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_FLOATING_SAVE_AREA>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_SegSs) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).RegisterArea) as usize - ptr as usize }, - 66usize, + 28usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_FLOATING_SAVE_AREA), "::", - stringify!(AMD64_SegSs) + stringify!(RegisterArea) ) ); } - test_field_AMD64_SegSs(); - fn test_field_AMD64_EFlags() { + test_field_RegisterArea(); + fn test_field_Cr0NpxState() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_FLOATING_SAVE_AREA>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_EFlags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Cr0NpxState) as usize - ptr as usize }, - 68usize, + 108usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_FLOATING_SAVE_AREA), "::", - stringify!(AMD64_EFlags) + stringify!(Cr0NpxState) ) ); } - test_field_AMD64_EFlags(); - fn test_field_AMD64_Dr0() { + test_field_Cr0NpxState(); +} +pub type WOW64_FLOATING_SAVE_AREA = _WOW64_FLOATING_SAVE_AREA; +pub type PWOW64_FLOATING_SAVE_AREA = *mut WOW64_FLOATING_SAVE_AREA; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _WOW64_CONTEXT { + pub ContextFlags: DWORD, + pub Dr0: DWORD, + pub Dr1: DWORD, + pub Dr2: DWORD, + pub Dr3: DWORD, + pub Dr6: DWORD, + pub Dr7: DWORD, + pub FloatSave: WOW64_FLOATING_SAVE_AREA, + pub SegGs: DWORD, + pub SegFs: DWORD, + pub SegEs: DWORD, + pub SegDs: DWORD, + pub Edi: DWORD, + pub Esi: DWORD, + pub Ebx: DWORD, + pub Edx: DWORD, + pub Ecx: DWORD, + pub Eax: DWORD, + pub Ebp: DWORD, + pub Eip: DWORD, + pub SegCs: DWORD, + pub EFlags: DWORD, + pub Esp: DWORD, + pub SegSs: DWORD, + pub ExtendedRegisters: [BYTE; 512usize], +} +#[test] +fn bindgen_test_layout__WOW64_CONTEXT() { + assert_eq!( + ::std::mem::size_of::<_WOW64_CONTEXT>(), + 716usize, + concat!("Size of: ", stringify!(_WOW64_CONTEXT)) + ); + assert_eq!( + ::std::mem::align_of::<_WOW64_CONTEXT>(), + 4usize, + concat!("Alignment of ", stringify!(_WOW64_CONTEXT)) + ); + fn test_field_ContextFlags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_Dr0) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ContextFlags) as usize - ptr as usize }, - 72usize, + 0usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(AMD64_Dr0) + stringify!(ContextFlags) ) ); } - test_field_AMD64_Dr0(); - fn test_field_AMD64_Dr1() { + test_field_ContextFlags(); + fn test_field_Dr0() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_Dr1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Dr0) as usize - ptr as usize }, - 80usize, + 4usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(AMD64_Dr1) + stringify!(Dr0) ) ); } - test_field_AMD64_Dr1(); - fn test_field_AMD64_Dr2() { + test_field_Dr0(); + fn test_field_Dr1() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_Dr2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Dr1) as usize - ptr as usize }, - 88usize, + 8usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(AMD64_Dr2) + stringify!(Dr1) ) ); } - test_field_AMD64_Dr2(); - fn test_field_AMD64_Dr3() { + test_field_Dr1(); + fn test_field_Dr2() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_Dr3) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Dr2) as usize - ptr as usize }, - 96usize, + 12usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(AMD64_Dr3) + stringify!(Dr2) ) ); } - test_field_AMD64_Dr3(); - fn test_field_AMD64_Dr6() { + test_field_Dr2(); + fn test_field_Dr3() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_Dr6) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Dr3) as usize - ptr as usize }, - 104usize, + 16usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(AMD64_Dr6) + stringify!(Dr3) ) ); } - test_field_AMD64_Dr6(); - fn test_field_AMD64_Dr7() { + test_field_Dr3(); + fn test_field_Dr6() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_Dr7) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Dr6) as usize - ptr as usize }, - 112usize, + 20usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(AMD64_Dr7) + stringify!(Dr6) ) ); } - test_field_AMD64_Dr7(); - fn test_field_X8() { + test_field_Dr6(); + fn test_field_Dr7() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X8) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Dr7) as usize - ptr as usize }, - 120usize, + 24usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(X8) + stringify!(Dr7) ) ); } - test_field_X8(); - fn test_field_X0() { + test_field_Dr7(); + fn test_field_FloatSave() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X0) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).FloatSave) as usize - ptr as usize }, - 128usize, + 28usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(X0) + stringify!(FloatSave) ) ); } - test_field_X0(); - fn test_field_X1() { + test_field_FloatSave(); + fn test_field_SegGs() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SegGs) as usize - ptr as usize }, - 136usize, + 140usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(X1) + stringify!(SegGs) ) ); } - test_field_X1(); - fn test_field_X27() { + test_field_SegGs(); + fn test_field_SegFs() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X27) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SegFs) as usize - ptr as usize }, 144usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), - "::", - stringify!(X27) - ) - ); - } - test_field_X27(); - fn test_field_Sp() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Sp) as usize - ptr as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(Sp) + stringify!(SegFs) ) ); } - test_field_Sp(); - fn test_field_Fp() { + test_field_SegFs(); + fn test_field_SegEs() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Fp) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SegEs) as usize - ptr as usize }, - 160usize, + 148usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(Fp) + stringify!(SegEs) ) ); } - test_field_Fp(); - fn test_field_X25() { + test_field_SegEs(); + fn test_field_SegDs() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X25) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SegDs) as usize - ptr as usize }, - 168usize, + 152usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(X25) + stringify!(SegDs) ) ); } - test_field_X25(); - fn test_field_X26() { + test_field_SegDs(); + fn test_field_Edi() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X26) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Edi) as usize - ptr as usize }, - 176usize, + 156usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(X26) + stringify!(Edi) ) ); } - test_field_X26(); - fn test_field_X2() { + test_field_Edi(); + fn test_field_Esi() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Esi) as usize - ptr as usize }, - 184usize, + 160usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(X2) + stringify!(Esi) ) ); } - test_field_X2(); - fn test_field_X3() { + test_field_Esi(); + fn test_field_Ebx() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X3) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Ebx) as usize - ptr as usize }, - 192usize, + 164usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(X3) + stringify!(Ebx) ) ); } - test_field_X3(); - fn test_field_X4() { + test_field_Ebx(); + fn test_field_Edx() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X4) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Edx) as usize - ptr as usize }, - 200usize, + 168usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(X4) + stringify!(Edx) ) ); } - test_field_X4(); - fn test_field_X5() { + test_field_Edx(); + fn test_field_Ecx() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X5) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Ecx) as usize - ptr as usize }, - 208usize, + 172usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(X5) + stringify!(Ecx) ) ); } - test_field_X5(); - fn test_field_X19() { + test_field_Ecx(); + fn test_field_Eax() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X19) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Eax) as usize - ptr as usize }, - 216usize, + 176usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(X19) + stringify!(Eax) ) ); } - test_field_X19(); - fn test_field_X20() { + test_field_Eax(); + fn test_field_Ebp() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X20) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Ebp) as usize - ptr as usize }, - 224usize, + 180usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(X20) + stringify!(Ebp) ) ); } - test_field_X20(); - fn test_field_X21() { + test_field_Ebp(); + fn test_field_Eip() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X21) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Eip) as usize - ptr as usize }, - 232usize, + 184usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(X21) + stringify!(Eip) ) ); } - test_field_X21(); - fn test_field_X22() { + test_field_Eip(); + fn test_field_SegCs() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X22) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SegCs) as usize - ptr as usize }, - 240usize, + 188usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(X22) + stringify!(SegCs) ) ); } - test_field_X22(); - fn test_field_Pc() { + test_field_SegCs(); + fn test_field_EFlags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Pc) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).EFlags) as usize - ptr as usize }, - 248usize, + 192usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(Pc) + stringify!(EFlags) ) ); } - test_field_Pc(); - fn test_field_AMD64_VectorRegister() { + test_field_EFlags(); + fn test_field_Esp() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_VectorRegister) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Esp) as usize - ptr as usize }, - 768usize, + 196usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(AMD64_VectorRegister) + stringify!(Esp) ) ); } - test_field_AMD64_VectorRegister(); - fn test_field_AMD64_VectorControl() { + test_field_Esp(); + fn test_field_SegSs() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_VectorControl) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SegSs) as usize - ptr as usize }, - 1184usize, + 200usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(AMD64_VectorControl) + stringify!(SegSs) ) ); } - test_field_AMD64_VectorControl(); - fn test_field_AMD64_DebugControl() { + test_field_SegSs(); + fn test_field_ExtendedRegisters() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_DebugControl) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ExtendedRegisters) as usize - ptr as usize }, - 1192usize, + 204usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_CONTEXT), "::", - stringify!(AMD64_DebugControl) + stringify!(ExtendedRegisters) ) ); } - test_field_AMD64_DebugControl(); - fn test_field_AMD64_LastBranchToRip() { + test_field_ExtendedRegisters(); +} +pub type WOW64_CONTEXT = _WOW64_CONTEXT; +pub type PWOW64_CONTEXT = *mut WOW64_CONTEXT; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _WOW64_LDT_ENTRY { + pub LimitLow: WORD, + pub BaseLow: WORD, + pub HighWord: _WOW64_LDT_ENTRY__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _WOW64_LDT_ENTRY__bindgen_ty_1 { + pub Bytes: _WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1, + pub Bits: _WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1 { + pub BaseMid: BYTE, + pub Flags1: BYTE, + pub Flags2: BYTE, + pub BaseHi: BYTE, +} +#[test] +fn bindgen_test_layout__WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>(), + 4usize, + concat!( + "Size of: ", + stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1) + ) + ); + assert_eq!( + ::std::mem::align_of::<_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>(), + 1usize, + concat!( + "Alignment of ", + stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1) + ) + ); + fn test_field_BaseMid() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>::uninit( + ); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_LastBranchToRip) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).BaseMid) as usize - ptr as usize }, - 1200usize, + 0usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(AMD64_LastBranchToRip) + stringify!(BaseMid) ) ); } - test_field_AMD64_LastBranchToRip(); - fn test_field_AMD64_LastBranchFromRip() { + test_field_BaseMid(); + fn test_field_Flags1() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>::uninit( + ); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_LastBranchFromRip) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags1) as usize - ptr as usize }, - 1208usize, + 1usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(AMD64_LastBranchFromRip) + stringify!(Flags1) ) ); } - test_field_AMD64_LastBranchFromRip(); - fn test_field_AMD64_LastExceptionToRip() { + test_field_Flags1(); + fn test_field_Flags2() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>::uninit( + ); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_LastExceptionToRip) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags2) as usize - ptr as usize }, - 1216usize, + 2usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(AMD64_LastExceptionToRip) + stringify!(Flags2) ) ); } - test_field_AMD64_LastExceptionToRip(); - fn test_field_AMD64_LastExceptionFromRip() { + test_field_Flags2(); + fn test_field_BaseHi() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::< - _ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1, - >::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>::uninit( + ); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AMD64_LastExceptionFromRip) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).BaseHi) as usize - ptr as usize }, - 1224usize, + 3usize, concat!( "Offset of field: ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1__bindgen_ty_1), + stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1), "::", - stringify!(AMD64_LastExceptionFromRip) + stringify!(BaseHi) ) ); } - test_field_AMD64_LastExceptionFromRip(); -} -#[test] -fn bindgen_test_layout__ARM64EC_NT_CONTEXT__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_ARM64EC_NT_CONTEXT__bindgen_ty_1>(), - 1232usize, - concat!("Size of: ", stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1)) - ); - assert_eq!( - ::std::mem::align_of::<_ARM64EC_NT_CONTEXT__bindgen_ty_1>(), - 8usize, - concat!( - "Alignment of ", - stringify!(_ARM64EC_NT_CONTEXT__bindgen_ty_1) - ) - ); -} -#[test] -fn bindgen_test_layout__ARM64EC_NT_CONTEXT() { - assert_eq!( - ::std::mem::size_of::<_ARM64EC_NT_CONTEXT>(), - 1232usize, - concat!("Size of: ", stringify!(_ARM64EC_NT_CONTEXT)) - ); - assert_eq!( - ::std::mem::align_of::<_ARM64EC_NT_CONTEXT>(), - 16usize, - concat!("Alignment of ", stringify!(_ARM64EC_NT_CONTEXT)) - ); -} -pub type ARM64EC_NT_CONTEXT = _ARM64EC_NT_CONTEXT; -pub type PARM64EC_NT_CONTEXT = *mut _ARM64EC_NT_CONTEXT; -pub type ARM64_RUNTIME_FUNCTION = _IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY; -pub type PARM64_RUNTIME_FUNCTION = *mut _IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY; -#[repr(C)] -#[derive(Copy, Clone)] -pub union _DISPATCHER_CONTEXT_NONVOLREG_ARM64 { - pub Buffer: [BYTE; 152usize], - pub __bindgen_anon_1: _DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1, + test_field_BaseHi(); } #[repr(C)] +#[repr(align(4))] #[derive(Debug, Copy, Clone)] -pub struct _DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1 { - pub GpNvRegs: [DWORD64; 11usize], - pub FpNvRegs: [f64; 8usize], +pub struct _WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2 { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } #[test] -fn bindgen_test_layout__DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1() { +fn bindgen_test_layout__WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2() { assert_eq!( - ::std::mem::size_of::<_DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1>(), - 152usize, + ::std::mem::size_of::<_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2>(), + 4usize, concat!( "Size of: ", - stringify!(_DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1) + stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2) ) ); assert_eq!( - ::std::mem::align_of::<_DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1>(), - 8usize, + ::std::mem::align_of::<_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2>(), + 4usize, concat!( "Alignment of ", - stringify!(_DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1) + stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2) ) ); - fn test_field_GpNvRegs() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).GpNvRegs) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1), - "::", - stringify!(GpNvRegs) - ) - ); +} +impl _WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2 { + #[inline] + pub fn BaseMid(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) } } - test_field_GpNvRegs(); - fn test_field_FpNvRegs() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).FpNvRegs) as usize - ptr as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT_NONVOLREG_ARM64__bindgen_ty_1), - "::", - stringify!(FpNvRegs) - ) - ); + #[inline] + pub fn set_BaseMid(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 8u8, val as u64) + } + } + #[inline] + pub fn Type(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 5u8) as u32) } + } + #[inline] + pub fn set_Type(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 5u8, val as u64) + } + } + #[inline] + pub fn Dpl(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 2u8) as u32) } + } + #[inline] + pub fn set_Dpl(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 2u8, val as u64) + } + } + #[inline] + pub fn Pres(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } + } + #[inline] + pub fn set_Pres(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 1u8, val as u64) + } + } + #[inline] + pub fn LimitHi(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 4u8) as u32) } + } + #[inline] + pub fn set_LimitHi(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 4u8, val as u64) + } + } + #[inline] + pub fn Sys(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) } + } + #[inline] + pub fn set_Sys(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 1u8, val as u64) + } + } + #[inline] + pub fn Reserved_0(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) } + } + #[inline] + pub fn set_Reserved_0(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 1u8, val as u64) + } + } + #[inline] + pub fn Default_Big(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) } + } + #[inline] + pub fn set_Default_Big(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 1u8, val as u64) + } + } + #[inline] + pub fn Granularity(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } + } + #[inline] + pub fn set_Granularity(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub fn BaseHi(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } + } + #[inline] + pub fn set_BaseHi(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 8u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + BaseMid: DWORD, + Type: DWORD, + Dpl: DWORD, + Pres: DWORD, + LimitHi: DWORD, + Sys: DWORD, + Reserved_0: DWORD, + Default_Big: DWORD, + Granularity: DWORD, + BaseHi: DWORD, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 8u8, { + let BaseMid: u32 = unsafe { ::std::mem::transmute(BaseMid) }; + BaseMid as u64 + }); + __bindgen_bitfield_unit.set(8usize, 5u8, { + let Type: u32 = unsafe { ::std::mem::transmute(Type) }; + Type as u64 + }); + __bindgen_bitfield_unit.set(13usize, 2u8, { + let Dpl: u32 = unsafe { ::std::mem::transmute(Dpl) }; + Dpl as u64 + }); + __bindgen_bitfield_unit.set(15usize, 1u8, { + let Pres: u32 = unsafe { ::std::mem::transmute(Pres) }; + Pres as u64 + }); + __bindgen_bitfield_unit.set(16usize, 4u8, { + let LimitHi: u32 = unsafe { ::std::mem::transmute(LimitHi) }; + LimitHi as u64 + }); + __bindgen_bitfield_unit.set(20usize, 1u8, { + let Sys: u32 = unsafe { ::std::mem::transmute(Sys) }; + Sys as u64 + }); + __bindgen_bitfield_unit.set(21usize, 1u8, { + let Reserved_0: u32 = unsafe { ::std::mem::transmute(Reserved_0) }; + Reserved_0 as u64 + }); + __bindgen_bitfield_unit.set(22usize, 1u8, { + let Default_Big: u32 = unsafe { ::std::mem::transmute(Default_Big) }; + Default_Big as u64 + }); + __bindgen_bitfield_unit.set(23usize, 1u8, { + let Granularity: u32 = unsafe { ::std::mem::transmute(Granularity) }; + Granularity as u64 + }); + __bindgen_bitfield_unit.set(24usize, 8u8, { + let BaseHi: u32 = unsafe { ::std::mem::transmute(BaseHi) }; + BaseHi as u64 + }); + __bindgen_bitfield_unit } - test_field_FpNvRegs(); } #[test] -fn bindgen_test_layout__DISPATCHER_CONTEXT_NONVOLREG_ARM64() { +fn bindgen_test_layout__WOW64_LDT_ENTRY__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_DISPATCHER_CONTEXT_NONVOLREG_ARM64>(), - 152usize, - concat!("Size of: ", stringify!(_DISPATCHER_CONTEXT_NONVOLREG_ARM64)) + ::std::mem::size_of::<_WOW64_LDT_ENTRY__bindgen_ty_1>(), + 4usize, + concat!("Size of: ", stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1)) ); assert_eq!( - ::std::mem::align_of::<_DISPATCHER_CONTEXT_NONVOLREG_ARM64>(), - 8usize, - concat!( - "Alignment of ", - stringify!(_DISPATCHER_CONTEXT_NONVOLREG_ARM64) - ) + ::std::mem::align_of::<_WOW64_LDT_ENTRY__bindgen_ty_1>(), + 4usize, + concat!("Alignment of ", stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1)) ); - fn test_field_Buffer() { + fn test_field_Bytes() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_NONVOLREG_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_LDT_ENTRY__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Buffer) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Bytes) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT_NONVOLREG_ARM64), + stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1), "::", - stringify!(Buffer) + stringify!(Bytes) ) ); } - test_field_Buffer(); -} -pub type DISPATCHER_CONTEXT_NONVOLREG_ARM64 = _DISPATCHER_CONTEXT_NONVOLREG_ARM64; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _DISPATCHER_CONTEXT_ARM64 { - pub ControlPc: ULONG_PTR, - pub ImageBase: ULONG_PTR, - pub FunctionEntry: PARM64_RUNTIME_FUNCTION, - pub EstablisherFrame: ULONG_PTR, - pub TargetPc: ULONG_PTR, - pub ContextRecord: PARM64_NT_CONTEXT, - pub LanguageHandler: PEXCEPTION_ROUTINE, - pub HandlerData: PVOID, - pub HistoryTable: *mut _UNWIND_HISTORY_TABLE, - pub ScopeIndex: DWORD, - pub ControlPcIsUnwound: BOOLEAN, - pub NonVolatileRegisters: PBYTE, -} -#[test] -fn bindgen_test_layout__DISPATCHER_CONTEXT_ARM64() { - assert_eq!( - ::std::mem::size_of::<_DISPATCHER_CONTEXT_ARM64>(), - 88usize, - concat!("Size of: ", stringify!(_DISPATCHER_CONTEXT_ARM64)) - ); - assert_eq!( - ::std::mem::align_of::<_DISPATCHER_CONTEXT_ARM64>(), - 8usize, - concat!("Alignment of ", stringify!(_DISPATCHER_CONTEXT_ARM64)) - ); - fn test_field_ControlPc() { + test_field_Bytes(); + fn test_field_Bits() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_LDT_ENTRY__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ControlPc) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Bits) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT_ARM64), + stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1), "::", - stringify!(ControlPc) + stringify!(Bits) ) ); } - test_field_ControlPc(); - fn test_field_ImageBase() { + test_field_Bits(); +} +#[test] +fn bindgen_test_layout__WOW64_LDT_ENTRY() { + assert_eq!( + ::std::mem::size_of::<_WOW64_LDT_ENTRY>(), + 8usize, + concat!("Size of: ", stringify!(_WOW64_LDT_ENTRY)) + ); + assert_eq!( + ::std::mem::align_of::<_WOW64_LDT_ENTRY>(), + 4usize, + concat!("Alignment of ", stringify!(_WOW64_LDT_ENTRY)) + ); + fn test_field_LimitLow() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_LDT_ENTRY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ImageBase) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).LimitLow) as usize - ptr as usize }, - 8usize, + 0usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT_ARM64), + stringify!(_WOW64_LDT_ENTRY), "::", - stringify!(ImageBase) + stringify!(LimitLow) ) ); } - test_field_ImageBase(); - fn test_field_FunctionEntry() { + test_field_LimitLow(); + fn test_field_BaseLow() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_LDT_ENTRY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).FunctionEntry) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).BaseLow) as usize - ptr as usize }, - 16usize, + 2usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT_ARM64), + stringify!(_WOW64_LDT_ENTRY), "::", - stringify!(FunctionEntry) + stringify!(BaseLow) ) ); } - test_field_FunctionEntry(); - fn test_field_EstablisherFrame() { + test_field_BaseLow(); + fn test_field_HighWord() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_LDT_ENTRY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).EstablisherFrame) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).HighWord) as usize - ptr as usize }, - 24usize, + 4usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT_ARM64), + stringify!(_WOW64_LDT_ENTRY), "::", - stringify!(EstablisherFrame) + stringify!(HighWord) ) ); } - test_field_EstablisherFrame(); - fn test_field_TargetPc() { + test_field_HighWord(); +} +pub type WOW64_LDT_ENTRY = _WOW64_LDT_ENTRY; +pub type PWOW64_LDT_ENTRY = *mut _WOW64_LDT_ENTRY; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _WOW64_DESCRIPTOR_TABLE_ENTRY { + pub Selector: DWORD, + pub Descriptor: WOW64_LDT_ENTRY, +} +#[test] +fn bindgen_test_layout__WOW64_DESCRIPTOR_TABLE_ENTRY() { + assert_eq!( + ::std::mem::size_of::<_WOW64_DESCRIPTOR_TABLE_ENTRY>(), + 12usize, + concat!("Size of: ", stringify!(_WOW64_DESCRIPTOR_TABLE_ENTRY)) + ); + assert_eq!( + ::std::mem::align_of::<_WOW64_DESCRIPTOR_TABLE_ENTRY>(), + 4usize, + concat!("Alignment of ", stringify!(_WOW64_DESCRIPTOR_TABLE_ENTRY)) + ); + fn test_field_Selector() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_DESCRIPTOR_TABLE_ENTRY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).TargetPc) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Selector) as usize - ptr as usize }, - 32usize, + 0usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT_ARM64), + stringify!(_WOW64_DESCRIPTOR_TABLE_ENTRY), "::", - stringify!(TargetPc) + stringify!(Selector) ) ); } - test_field_TargetPc(); - fn test_field_ContextRecord() { + test_field_Selector(); + fn test_field_Descriptor() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_WOW64_DESCRIPTOR_TABLE_ENTRY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ContextRecord) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Descriptor) as usize - ptr as usize }, - 40usize, + 4usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT_ARM64), + stringify!(_WOW64_DESCRIPTOR_TABLE_ENTRY), "::", - stringify!(ContextRecord) + stringify!(Descriptor) ) ); } - test_field_ContextRecord(); - fn test_field_LanguageHandler() { + test_field_Descriptor(); +} +pub type WOW64_DESCRIPTOR_TABLE_ENTRY = _WOW64_DESCRIPTOR_TABLE_ENTRY; +pub type PWOW64_DESCRIPTOR_TABLE_ENTRY = *mut _WOW64_DESCRIPTOR_TABLE_ENTRY; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _EXCEPTION_RECORD { + pub ExceptionCode: DWORD, + pub ExceptionFlags: DWORD, + pub ExceptionRecord: *mut _EXCEPTION_RECORD, + pub ExceptionAddress: PVOID, + pub NumberParameters: DWORD, + pub ExceptionInformation: [ULONG_PTR; 15usize], +} +#[test] +fn bindgen_test_layout__EXCEPTION_RECORD() { + assert_eq!( + ::std::mem::size_of::<_EXCEPTION_RECORD>(), + 152usize, + concat!("Size of: ", stringify!(_EXCEPTION_RECORD)) + ); + assert_eq!( + ::std::mem::align_of::<_EXCEPTION_RECORD>(), + 8usize, + concat!("Alignment of ", stringify!(_EXCEPTION_RECORD)) + ); + fn test_field_ExceptionCode() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).LanguageHandler) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ExceptionCode) as usize - ptr as usize }, - 48usize, + 0usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT_ARM64), + stringify!(_EXCEPTION_RECORD), "::", - stringify!(LanguageHandler) + stringify!(ExceptionCode) ) ); } - test_field_LanguageHandler(); - fn test_field_HandlerData() { + test_field_ExceptionCode(); + fn test_field_ExceptionFlags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).HandlerData) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ExceptionFlags) as usize - ptr as usize }, - 56usize, + 4usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT_ARM64), + stringify!(_EXCEPTION_RECORD), "::", - stringify!(HandlerData) + stringify!(ExceptionFlags) ) ); } - test_field_HandlerData(); - fn test_field_HistoryTable() { + test_field_ExceptionFlags(); + fn test_field_ExceptionRecord() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).HistoryTable) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ExceptionRecord) as usize - ptr as usize }, - 64usize, + 8usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT_ARM64), + stringify!(_EXCEPTION_RECORD), "::", - stringify!(HistoryTable) + stringify!(ExceptionRecord) ) ); } - test_field_HistoryTable(); - fn test_field_ScopeIndex() { + test_field_ExceptionRecord(); + fn test_field_ExceptionAddress() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ScopeIndex) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ExceptionAddress) as usize - ptr as usize }, - 72usize, + 16usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT_ARM64), + stringify!(_EXCEPTION_RECORD), "::", - stringify!(ScopeIndex) + stringify!(ExceptionAddress) ) ); } - test_field_ScopeIndex(); - fn test_field_ControlPcIsUnwound() { + test_field_ExceptionAddress(); + fn test_field_NumberParameters() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ControlPcIsUnwound) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).NumberParameters) as usize - ptr as usize }, - 76usize, + 24usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT_ARM64), + stringify!(_EXCEPTION_RECORD), "::", - stringify!(ControlPcIsUnwound) + stringify!(NumberParameters) ) ); } - test_field_ControlPcIsUnwound(); - fn test_field_NonVolatileRegisters() { + test_field_NumberParameters(); + fn test_field_ExceptionInformation() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_DISPATCHER_CONTEXT_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).NonVolatileRegisters) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ExceptionInformation) as usize - ptr as usize }, - 80usize, + 32usize, concat!( "Offset of field: ", - stringify!(_DISPATCHER_CONTEXT_ARM64), + stringify!(_EXCEPTION_RECORD), "::", - stringify!(NonVolatileRegisters) + stringify!(ExceptionInformation) ) ); } - test_field_NonVolatileRegisters(); + test_field_ExceptionInformation(); } -pub type DISPATCHER_CONTEXT_ARM64 = _DISPATCHER_CONTEXT_ARM64; -pub type PDISPATCHER_CONTEXT_ARM64 = *mut _DISPATCHER_CONTEXT_ARM64; +pub type EXCEPTION_RECORD = _EXCEPTION_RECORD; +pub type PEXCEPTION_RECORD = *mut EXCEPTION_RECORD; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _KNONVOLATILE_CONTEXT_POINTERS_ARM64 { - pub X19: PDWORD64, - pub X20: PDWORD64, - pub X21: PDWORD64, - pub X22: PDWORD64, - pub X23: PDWORD64, - pub X24: PDWORD64, - pub X25: PDWORD64, - pub X26: PDWORD64, - pub X27: PDWORD64, - pub X28: PDWORD64, - pub Fp: PDWORD64, - pub Lr: PDWORD64, - pub D8: PDWORD64, - pub D9: PDWORD64, - pub D10: PDWORD64, - pub D11: PDWORD64, - pub D12: PDWORD64, - pub D13: PDWORD64, - pub D14: PDWORD64, - pub D15: PDWORD64, +pub struct _EXCEPTION_RECORD32 { + pub ExceptionCode: DWORD, + pub ExceptionFlags: DWORD, + pub ExceptionRecord: DWORD, + pub ExceptionAddress: DWORD, + pub NumberParameters: DWORD, + pub ExceptionInformation: [DWORD; 15usize], } #[test] -fn bindgen_test_layout__KNONVOLATILE_CONTEXT_POINTERS_ARM64() { +fn bindgen_test_layout__EXCEPTION_RECORD32() { assert_eq!( - ::std::mem::size_of::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>(), - 160usize, - concat!( - "Size of: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64) - ) + ::std::mem::size_of::<_EXCEPTION_RECORD32>(), + 80usize, + concat!("Size of: ", stringify!(_EXCEPTION_RECORD32)) ); assert_eq!( - ::std::mem::align_of::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>(), - 8usize, - concat!( - "Alignment of ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64) - ) + ::std::mem::align_of::<_EXCEPTION_RECORD32>(), + 4usize, + concat!("Alignment of ", stringify!(_EXCEPTION_RECORD32)) ); - fn test_field_X19() { + fn test_field_ExceptionCode() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD32>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X19) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ExceptionCode) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), + stringify!(_EXCEPTION_RECORD32), "::", - stringify!(X19) + stringify!(ExceptionCode) ) ); } - test_field_X19(); - fn test_field_X20() { + test_field_ExceptionCode(); + fn test_field_ExceptionFlags() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD32>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X20) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ExceptionFlags) as usize - ptr as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(_EXCEPTION_RECORD32), + "::", + stringify!(ExceptionFlags) + ) + ); + } + test_field_ExceptionFlags(); + fn test_field_ExceptionRecord() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD32>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).ExceptionRecord) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), + stringify!(_EXCEPTION_RECORD32), "::", - stringify!(X20) + stringify!(ExceptionRecord) ) ); } - test_field_X20(); - fn test_field_X21() { + test_field_ExceptionRecord(); + fn test_field_ExceptionAddress() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD32>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X21) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ExceptionAddress) as usize - ptr as usize }, - 16usize, + 12usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), + stringify!(_EXCEPTION_RECORD32), "::", - stringify!(X21) + stringify!(ExceptionAddress) ) ); } - test_field_X21(); - fn test_field_X22() { + test_field_ExceptionAddress(); + fn test_field_NumberParameters() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD32>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X22) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).NumberParameters) as usize - ptr as usize }, - 24usize, + 16usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), + stringify!(_EXCEPTION_RECORD32), "::", - stringify!(X22) + stringify!(NumberParameters) ) ); } - test_field_X22(); - fn test_field_X23() { + test_field_NumberParameters(); + fn test_field_ExceptionInformation() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD32>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X23) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ExceptionInformation) as usize - ptr as usize }, - 32usize, + 20usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), + stringify!(_EXCEPTION_RECORD32), "::", - stringify!(X23) + stringify!(ExceptionInformation) ) ); } - test_field_X23(); - fn test_field_X24() { + test_field_ExceptionInformation(); +} +pub type EXCEPTION_RECORD32 = _EXCEPTION_RECORD32; +pub type PEXCEPTION_RECORD32 = *mut _EXCEPTION_RECORD32; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _EXCEPTION_RECORD64 { + pub ExceptionCode: DWORD, + pub ExceptionFlags: DWORD, + pub ExceptionRecord: DWORD64, + pub ExceptionAddress: DWORD64, + pub NumberParameters: DWORD, + pub __unusedAlignment: DWORD, + pub ExceptionInformation: [DWORD64; 15usize], +} +#[test] +fn bindgen_test_layout__EXCEPTION_RECORD64() { + assert_eq!( + ::std::mem::size_of::<_EXCEPTION_RECORD64>(), + 152usize, + concat!("Size of: ", stringify!(_EXCEPTION_RECORD64)) + ); + assert_eq!( + ::std::mem::align_of::<_EXCEPTION_RECORD64>(), + 8usize, + concat!("Alignment of ", stringify!(_EXCEPTION_RECORD64)) + ); + fn test_field_ExceptionCode() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X24) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ExceptionCode) as usize - ptr as usize }, - 40usize, + 0usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), + stringify!(_EXCEPTION_RECORD64), "::", - stringify!(X24) + stringify!(ExceptionCode) ) ); } - test_field_X24(); - fn test_field_X25() { + test_field_ExceptionCode(); + fn test_field_ExceptionFlags() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X25) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ExceptionFlags) as usize - ptr as usize }, - 48usize, + 4usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), + stringify!(_EXCEPTION_RECORD64), "::", - stringify!(X25) + stringify!(ExceptionFlags) ) ); } - test_field_X25(); - fn test_field_X26() { + test_field_ExceptionFlags(); + fn test_field_ExceptionRecord() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X26) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ExceptionRecord) as usize - ptr as usize }, - 56usize, + 8usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), + stringify!(_EXCEPTION_RECORD64), "::", - stringify!(X26) + stringify!(ExceptionRecord) ) ); } - test_field_X26(); - fn test_field_X27() { + test_field_ExceptionRecord(); + fn test_field_ExceptionAddress() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X27) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ExceptionAddress) as usize - ptr as usize }, - 64usize, + 16usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), + stringify!(_EXCEPTION_RECORD64), "::", - stringify!(X27) + stringify!(ExceptionAddress) ) ); } - test_field_X27(); - fn test_field_X28() { + test_field_ExceptionAddress(); + fn test_field_NumberParameters() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).X28) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).NumberParameters) as usize - ptr as usize }, - 72usize, + 24usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), + stringify!(_EXCEPTION_RECORD64), "::", - stringify!(X28) + stringify!(NumberParameters) ) ); } - test_field_X28(); - fn test_field_Fp() { + test_field_NumberParameters(); + fn test_field___unusedAlignment() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Fp) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).__unusedAlignment) as usize - ptr as usize }, - 80usize, + 28usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), + stringify!(_EXCEPTION_RECORD64), "::", - stringify!(Fp) + stringify!(__unusedAlignment) ) ); } - test_field_Fp(); - fn test_field_Lr() { + test_field___unusedAlignment(); + fn test_field_ExceptionInformation() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Lr) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ExceptionInformation) as usize - ptr as usize }, - 88usize, + 32usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), + stringify!(_EXCEPTION_RECORD64), "::", - stringify!(Lr) + stringify!(ExceptionInformation) ) ); } - test_field_Lr(); - fn test_field_D8() { + test_field_ExceptionInformation(); +} +pub type EXCEPTION_RECORD64 = _EXCEPTION_RECORD64; +pub type PEXCEPTION_RECORD64 = *mut _EXCEPTION_RECORD64; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _EXCEPTION_POINTERS { + pub ExceptionRecord: PEXCEPTION_RECORD, + pub ContextRecord: PCONTEXT, +} +#[test] +fn bindgen_test_layout__EXCEPTION_POINTERS() { + assert_eq!( + ::std::mem::size_of::<_EXCEPTION_POINTERS>(), + 16usize, + concat!("Size of: ", stringify!(_EXCEPTION_POINTERS)) + ); + assert_eq!( + ::std::mem::align_of::<_EXCEPTION_POINTERS>(), + 8usize, + concat!("Alignment of ", stringify!(_EXCEPTION_POINTERS)) + ); + fn test_field_ExceptionRecord() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_POINTERS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).D8) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ExceptionRecord) as usize - ptr as usize }, - 96usize, + 0usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), + stringify!(_EXCEPTION_POINTERS), "::", - stringify!(D8) + stringify!(ExceptionRecord) ) ); } - test_field_D8(); - fn test_field_D9() { + test_field_ExceptionRecord(); + fn test_field_ContextRecord() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_POINTERS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).D9) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ContextRecord) as usize - ptr as usize }, - 104usize, + 8usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), + stringify!(_EXCEPTION_POINTERS), "::", - stringify!(D9) + stringify!(ContextRecord) ) ); } - test_field_D9(); - fn test_field_D10() { + test_field_ContextRecord(); +} +pub type EXCEPTION_POINTERS = _EXCEPTION_POINTERS; +pub type PEXCEPTION_POINTERS = *mut _EXCEPTION_POINTERS; +pub type PACCESS_TOKEN = PVOID; +pub type PSECURITY_DESCRIPTOR = PVOID; +pub type PSID = PVOID; +pub type PCLAIMS_BLOB = PVOID; +pub type ACCESS_MASK = DWORD; +pub type PACCESS_MASK = *mut ACCESS_MASK; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _GENERIC_MAPPING { + pub GenericRead: ACCESS_MASK, + pub GenericWrite: ACCESS_MASK, + pub GenericExecute: ACCESS_MASK, + pub GenericAll: ACCESS_MASK, +} +#[test] +fn bindgen_test_layout__GENERIC_MAPPING() { + assert_eq!( + ::std::mem::size_of::<_GENERIC_MAPPING>(), + 16usize, + concat!("Size of: ", stringify!(_GENERIC_MAPPING)) + ); + assert_eq!( + ::std::mem::align_of::<_GENERIC_MAPPING>(), + 4usize, + concat!("Alignment of ", stringify!(_GENERIC_MAPPING)) + ); + fn test_field_GenericRead() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_GENERIC_MAPPING>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).D10) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).GenericRead) as usize - ptr as usize }, - 112usize, + 0usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), + stringify!(_GENERIC_MAPPING), "::", - stringify!(D10) + stringify!(GenericRead) ) ); } - test_field_D10(); - fn test_field_D11() { + test_field_GenericRead(); + fn test_field_GenericWrite() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_GENERIC_MAPPING>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).D11) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).GenericWrite) as usize - ptr as usize }, - 120usize, + 4usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), + stringify!(_GENERIC_MAPPING), "::", - stringify!(D11) + stringify!(GenericWrite) ) ); } - test_field_D11(); - fn test_field_D12() { + test_field_GenericWrite(); + fn test_field_GenericExecute() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_GENERIC_MAPPING>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).D12) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).GenericExecute) as usize - ptr as usize }, - 128usize, + 8usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), + stringify!(_GENERIC_MAPPING), "::", - stringify!(D12) + stringify!(GenericExecute) ) ); } - test_field_D12(); - fn test_field_D13() { + test_field_GenericExecute(); + fn test_field_GenericAll() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_GENERIC_MAPPING>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).D13) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).GenericAll) as usize - ptr as usize }, - 136usize, + 12usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), + stringify!(_GENERIC_MAPPING), "::", - stringify!(D13) + stringify!(GenericAll) ) ); } - test_field_D13(); - fn test_field_D14() { + test_field_GenericAll(); +} +pub type GENERIC_MAPPING = _GENERIC_MAPPING; +pub type PGENERIC_MAPPING = *mut GENERIC_MAPPING; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _LUID_AND_ATTRIBUTES { + pub Luid: LUID, + pub Attributes: DWORD, +} +#[test] +fn bindgen_test_layout__LUID_AND_ATTRIBUTES() { + assert_eq!( + ::std::mem::size_of::<_LUID_AND_ATTRIBUTES>(), + 12usize, + concat!("Size of: ", stringify!(_LUID_AND_ATTRIBUTES)) + ); + assert_eq!( + ::std::mem::align_of::<_LUID_AND_ATTRIBUTES>(), + 4usize, + concat!("Alignment of ", stringify!(_LUID_AND_ATTRIBUTES)) + ); + fn test_field_Luid() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_LUID_AND_ATTRIBUTES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).D14) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Luid) as usize - ptr as usize }, - 144usize, + 0usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), + stringify!(_LUID_AND_ATTRIBUTES), "::", - stringify!(D14) + stringify!(Luid) ) ); } - test_field_D14(); - fn test_field_D15() { + test_field_Luid(); + fn test_field_Attributes() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_KNONVOLATILE_CONTEXT_POINTERS_ARM64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_LUID_AND_ATTRIBUTES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).D15) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Attributes) as usize - ptr as usize }, - 152usize, + 8usize, concat!( "Offset of field: ", - stringify!(_KNONVOLATILE_CONTEXT_POINTERS_ARM64), + stringify!(_LUID_AND_ATTRIBUTES), "::", - stringify!(D15) + stringify!(Attributes) ) ); } - test_field_D15(); -} -pub type KNONVOLATILE_CONTEXT_POINTERS_ARM64 = _KNONVOLATILE_CONTEXT_POINTERS_ARM64; -pub type PKNONVOLATILE_CONTEXT_POINTERS_ARM64 = *mut _KNONVOLATILE_CONTEXT_POINTERS_ARM64; -extern "C" { - pub fn __int2c(); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _LDT_ENTRY { - pub LimitLow: WORD, - pub BaseLow: WORD, - pub HighWord: _LDT_ENTRY__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _LDT_ENTRY__bindgen_ty_1 { - pub Bytes: _LDT_ENTRY__bindgen_ty_1__bindgen_ty_1, - pub Bits: _LDT_ENTRY__bindgen_ty_1__bindgen_ty_2, + test_field_Attributes(); } +pub type LUID_AND_ATTRIBUTES = _LUID_AND_ATTRIBUTES; +pub type PLUID_AND_ATTRIBUTES = *mut _LUID_AND_ATTRIBUTES; +pub type LUID_AND_ATTRIBUTES_ARRAY = [LUID_AND_ATTRIBUTES; 1usize]; +pub type PLUID_AND_ATTRIBUTES_ARRAY = *mut LUID_AND_ATTRIBUTES_ARRAY; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _LDT_ENTRY__bindgen_ty_1__bindgen_ty_1 { - pub BaseMid: BYTE, - pub Flags1: BYTE, - pub Flags2: BYTE, - pub BaseHi: BYTE, +pub struct _SID_IDENTIFIER_AUTHORITY { + pub Value: [BYTE; 6usize], } #[test] -fn bindgen_test_layout__LDT_ENTRY__bindgen_ty_1__bindgen_ty_1() { +fn bindgen_test_layout__SID_IDENTIFIER_AUTHORITY() { assert_eq!( - ::std::mem::size_of::<_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - concat!( - "Size of: ", - stringify!(_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1) - ) + ::std::mem::size_of::<_SID_IDENTIFIER_AUTHORITY>(), + 6usize, + concat!("Size of: ", stringify!(_SID_IDENTIFIER_AUTHORITY)) ); assert_eq!( - ::std::mem::align_of::<_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>(), + ::std::mem::align_of::<_SID_IDENTIFIER_AUTHORITY>(), 1usize, - concat!( - "Alignment of ", - stringify!(_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1) - ) + concat!("Alignment of ", stringify!(_SID_IDENTIFIER_AUTHORITY)) ); - fn test_field_BaseMid() { + fn test_field_Value() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SID_IDENTIFIER_AUTHORITY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).BaseMid) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Value) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1), + stringify!(_SID_IDENTIFIER_AUTHORITY), "::", - stringify!(BaseMid) + stringify!(Value) ) ); } - test_field_BaseMid(); - fn test_field_Flags1() { + test_field_Value(); +} +pub type SID_IDENTIFIER_AUTHORITY = _SID_IDENTIFIER_AUTHORITY; +pub type PSID_IDENTIFIER_AUTHORITY = *mut _SID_IDENTIFIER_AUTHORITY; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SID { + pub Revision: BYTE, + pub SubAuthorityCount: BYTE, + pub IdentifierAuthority: SID_IDENTIFIER_AUTHORITY, + pub SubAuthority: [DWORD; 1usize], +} +#[test] +fn bindgen_test_layout__SID() { + assert_eq!( + ::std::mem::size_of::<_SID>(), + 12usize, + concat!("Size of: ", stringify!(_SID)) + ); + assert_eq!( + ::std::mem::align_of::<_SID>(), + 4usize, + concat!("Alignment of ", stringify!(_SID)) + ); + fn test_field_Revision() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SID>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Revision) as usize - ptr as usize }, - 1usize, + 0usize, concat!( "Offset of field: ", - stringify!(_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1), + stringify!(_SID), "::", - stringify!(Flags1) + stringify!(Revision) ) ); } - test_field_Flags1(); - fn test_field_Flags2() { + test_field_Revision(); + fn test_field_SubAuthorityCount() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SID>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SubAuthorityCount) as usize - ptr as usize + }, + 1usize, + concat!( + "Offset of field: ", + stringify!(_SID), + "::", + stringify!(SubAuthorityCount) + ) + ); + } + test_field_SubAuthorityCount(); + fn test_field_IdentifierAuthority() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_SID>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).IdentifierAuthority) as usize - ptr as usize }, 2usize, concat!( "Offset of field: ", - stringify!(_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1), + stringify!(_SID), "::", - stringify!(Flags2) + stringify!(IdentifierAuthority) ) ); } - test_field_Flags2(); - fn test_field_BaseHi() { + test_field_IdentifierAuthority(); + fn test_field_SubAuthority() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SID>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).BaseHi) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SubAuthority) as usize - ptr as usize }, - 3usize, + 8usize, concat!( "Offset of field: ", - stringify!(_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1), + stringify!(_SID), "::", - stringify!(BaseHi) + stringify!(SubAuthority) ) ); } - test_field_BaseHi(); + test_field_SubAuthority(); } +pub type SID = _SID; +pub type PISID = *mut _SID; #[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct _LDT_ENTRY__bindgen_ty_1__bindgen_ty_2 { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +#[derive(Copy, Clone)] +pub union _SE_SID { + pub Sid: SID, + pub Buffer: [BYTE; 68usize], } #[test] -fn bindgen_test_layout__LDT_ENTRY__bindgen_ty_1__bindgen_ty_2() { +fn bindgen_test_layout__SE_SID() { assert_eq!( - ::std::mem::size_of::<_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2>(), - 4usize, - concat!( - "Size of: ", - stringify!(_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2) - ) + ::std::mem::size_of::<_SE_SID>(), + 68usize, + concat!("Size of: ", stringify!(_SE_SID)) ); assert_eq!( - ::std::mem::align_of::<_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2>(), + ::std::mem::align_of::<_SE_SID>(), 4usize, - concat!( - "Alignment of ", - stringify!(_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2) - ) + concat!("Alignment of ", stringify!(_SE_SID)) ); -} -impl _LDT_ENTRY__bindgen_ty_1__bindgen_ty_2 { - #[inline] - pub fn BaseMid(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) } - } - #[inline] - pub fn set_BaseMid(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 8u8, val as u64) - } - } - #[inline] - pub fn Type(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 5u8) as u32) } - } - #[inline] - pub fn set_Type(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 5u8, val as u64) - } - } - #[inline] - pub fn Dpl(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 2u8) as u32) } - } - #[inline] - pub fn set_Dpl(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(13usize, 2u8, val as u64) - } - } - #[inline] - pub fn Pres(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } - } - #[inline] - pub fn set_Pres(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(15usize, 1u8, val as u64) - } - } - #[inline] - pub fn LimitHi(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 4u8) as u32) } - } - #[inline] - pub fn set_LimitHi(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(16usize, 4u8, val as u64) - } - } - #[inline] - pub fn Sys(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) } - } - #[inline] - pub fn set_Sys(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(20usize, 1u8, val as u64) - } - } - #[inline] - pub fn Reserved_0(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) } - } - #[inline] - pub fn set_Reserved_0(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(21usize, 1u8, val as u64) - } - } - #[inline] - pub fn Default_Big(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) } - } - #[inline] - pub fn set_Default_Big(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(22usize, 1u8, val as u64) - } - } - #[inline] - pub fn Granularity(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } - } - #[inline] - pub fn set_Granularity(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(23usize, 1u8, val as u64) - } - } - #[inline] - pub fn BaseHi(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } - } - #[inline] - pub fn set_BaseHi(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(24usize, 8u8, val as u64) - } + fn test_field_Sid() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_SE_SID>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Sid) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_SE_SID), + "::", + stringify!(Sid) + ) + ); } - #[inline] - pub fn new_bitfield_1( - BaseMid: DWORD, - Type: DWORD, - Dpl: DWORD, - Pres: DWORD, - LimitHi: DWORD, - Sys: DWORD, - Reserved_0: DWORD, - Default_Big: DWORD, - Granularity: DWORD, - BaseHi: DWORD, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 8u8, { - let BaseMid: u32 = unsafe { ::std::mem::transmute(BaseMid) }; - BaseMid as u64 - }); - __bindgen_bitfield_unit.set(8usize, 5u8, { - let Type: u32 = unsafe { ::std::mem::transmute(Type) }; - Type as u64 - }); - __bindgen_bitfield_unit.set(13usize, 2u8, { - let Dpl: u32 = unsafe { ::std::mem::transmute(Dpl) }; - Dpl as u64 - }); - __bindgen_bitfield_unit.set(15usize, 1u8, { - let Pres: u32 = unsafe { ::std::mem::transmute(Pres) }; - Pres as u64 - }); - __bindgen_bitfield_unit.set(16usize, 4u8, { - let LimitHi: u32 = unsafe { ::std::mem::transmute(LimitHi) }; - LimitHi as u64 - }); - __bindgen_bitfield_unit.set(20usize, 1u8, { - let Sys: u32 = unsafe { ::std::mem::transmute(Sys) }; - Sys as u64 - }); - __bindgen_bitfield_unit.set(21usize, 1u8, { - let Reserved_0: u32 = unsafe { ::std::mem::transmute(Reserved_0) }; - Reserved_0 as u64 - }); - __bindgen_bitfield_unit.set(22usize, 1u8, { - let Default_Big: u32 = unsafe { ::std::mem::transmute(Default_Big) }; - Default_Big as u64 - }); - __bindgen_bitfield_unit.set(23usize, 1u8, { - let Granularity: u32 = unsafe { ::std::mem::transmute(Granularity) }; - Granularity as u64 - }); - __bindgen_bitfield_unit.set(24usize, 8u8, { - let BaseHi: u32 = unsafe { ::std::mem::transmute(BaseHi) }; - BaseHi as u64 - }); - __bindgen_bitfield_unit + test_field_Sid(); + fn test_field_Buffer() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_SE_SID>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Buffer) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_SE_SID), + "::", + stringify!(Buffer) + ) + ); } + test_field_Buffer(); +} +pub type SE_SID = _SE_SID; +pub type PSE_SID = *mut _SE_SID; +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _SID_NAME_USE { + SidTypeUser = 1, + SidTypeGroup = 2, + SidTypeDomain = 3, + SidTypeAlias = 4, + SidTypeWellKnownGroup = 5, + SidTypeDeletedAccount = 6, + SidTypeInvalid = 7, + SidTypeUnknown = 8, + SidTypeComputer = 9, + SidTypeLabel = 10, + SidTypeLogonSession = 11, +} +pub use self::_SID_NAME_USE as SID_NAME_USE; +pub type PSID_NAME_USE = *mut _SID_NAME_USE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SID_AND_ATTRIBUTES { + pub Sid: PSID, + pub Attributes: DWORD, } #[test] -fn bindgen_test_layout__LDT_ENTRY__bindgen_ty_1() { +fn bindgen_test_layout__SID_AND_ATTRIBUTES() { assert_eq!( - ::std::mem::size_of::<_LDT_ENTRY__bindgen_ty_1>(), - 4usize, - concat!("Size of: ", stringify!(_LDT_ENTRY__bindgen_ty_1)) + ::std::mem::size_of::<_SID_AND_ATTRIBUTES>(), + 16usize, + concat!("Size of: ", stringify!(_SID_AND_ATTRIBUTES)) ); assert_eq!( - ::std::mem::align_of::<_LDT_ENTRY__bindgen_ty_1>(), - 4usize, - concat!("Alignment of ", stringify!(_LDT_ENTRY__bindgen_ty_1)) + ::std::mem::align_of::<_SID_AND_ATTRIBUTES>(), + 8usize, + concat!("Alignment of ", stringify!(_SID_AND_ATTRIBUTES)) ); - fn test_field_Bytes() { + fn test_field_Sid() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_LDT_ENTRY__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SID_AND_ATTRIBUTES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Bytes) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Sid) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_LDT_ENTRY__bindgen_ty_1), + stringify!(_SID_AND_ATTRIBUTES), "::", - stringify!(Bytes) + stringify!(Sid) ) ); } - test_field_Bytes(); - fn test_field_Bits() { + test_field_Sid(); + fn test_field_Attributes() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_LDT_ENTRY__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SID_AND_ATTRIBUTES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Bits) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Attributes) as usize - ptr as usize }, - 0usize, + 8usize, concat!( "Offset of field: ", - stringify!(_LDT_ENTRY__bindgen_ty_1), + stringify!(_SID_AND_ATTRIBUTES), "::", - stringify!(Bits) + stringify!(Attributes) ) ); } - test_field_Bits(); + test_field_Attributes(); +} +pub type SID_AND_ATTRIBUTES = _SID_AND_ATTRIBUTES; +pub type PSID_AND_ATTRIBUTES = *mut _SID_AND_ATTRIBUTES; +pub type SID_AND_ATTRIBUTES_ARRAY = [SID_AND_ATTRIBUTES; 1usize]; +pub type PSID_AND_ATTRIBUTES_ARRAY = *mut SID_AND_ATTRIBUTES_ARRAY; +pub type SID_HASH_ENTRY = ULONG_PTR; +pub type PSID_HASH_ENTRY = *mut ULONG_PTR; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SID_AND_ATTRIBUTES_HASH { + pub SidCount: DWORD, + pub SidAttr: PSID_AND_ATTRIBUTES, + pub Hash: [SID_HASH_ENTRY; 32usize], } #[test] -fn bindgen_test_layout__LDT_ENTRY() { +fn bindgen_test_layout__SID_AND_ATTRIBUTES_HASH() { assert_eq!( - ::std::mem::size_of::<_LDT_ENTRY>(), - 8usize, - concat!("Size of: ", stringify!(_LDT_ENTRY)) + ::std::mem::size_of::<_SID_AND_ATTRIBUTES_HASH>(), + 272usize, + concat!("Size of: ", stringify!(_SID_AND_ATTRIBUTES_HASH)) ); assert_eq!( - ::std::mem::align_of::<_LDT_ENTRY>(), - 4usize, - concat!("Alignment of ", stringify!(_LDT_ENTRY)) + ::std::mem::align_of::<_SID_AND_ATTRIBUTES_HASH>(), + 8usize, + concat!("Alignment of ", stringify!(_SID_AND_ATTRIBUTES_HASH)) ); - fn test_field_LimitLow() { + fn test_field_SidCount() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_LDT_ENTRY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SID_AND_ATTRIBUTES_HASH>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).LimitLow) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidCount) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_LDT_ENTRY), + stringify!(_SID_AND_ATTRIBUTES_HASH), "::", - stringify!(LimitLow) + stringify!(SidCount) ) ); } - test_field_LimitLow(); - fn test_field_BaseLow() { + test_field_SidCount(); + fn test_field_SidAttr() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_LDT_ENTRY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SID_AND_ATTRIBUTES_HASH>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).BaseLow) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidAttr) as usize - ptr as usize }, - 2usize, + 8usize, concat!( "Offset of field: ", - stringify!(_LDT_ENTRY), + stringify!(_SID_AND_ATTRIBUTES_HASH), "::", - stringify!(BaseLow) + stringify!(SidAttr) ) ); } - test_field_BaseLow(); - fn test_field_HighWord() { + test_field_SidAttr(); + fn test_field_Hash() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_LDT_ENTRY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SID_AND_ATTRIBUTES_HASH>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).HighWord) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Hash) as usize - ptr as usize }, - 4usize, + 16usize, concat!( "Offset of field: ", - stringify!(_LDT_ENTRY), + stringify!(_SID_AND_ATTRIBUTES_HASH), "::", - stringify!(HighWord) + stringify!(Hash) ) ); } - test_field_HighWord(); + test_field_Hash(); +} +pub type SID_AND_ATTRIBUTES_HASH = _SID_AND_ATTRIBUTES_HASH; +pub type PSID_AND_ATTRIBUTES_HASH = *mut _SID_AND_ATTRIBUTES_HASH; +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum WELL_KNOWN_SID_TYPE { + WinNullSid = 0, + WinWorldSid = 1, + WinLocalSid = 2, + WinCreatorOwnerSid = 3, + WinCreatorGroupSid = 4, + WinCreatorOwnerServerSid = 5, + WinCreatorGroupServerSid = 6, + WinNtAuthoritySid = 7, + WinDialupSid = 8, + WinNetworkSid = 9, + WinBatchSid = 10, + WinInteractiveSid = 11, + WinServiceSid = 12, + WinAnonymousSid = 13, + WinProxySid = 14, + WinEnterpriseControllersSid = 15, + WinSelfSid = 16, + WinAuthenticatedUserSid = 17, + WinRestrictedCodeSid = 18, + WinTerminalServerSid = 19, + WinRemoteLogonIdSid = 20, + WinLogonIdsSid = 21, + WinLocalSystemSid = 22, + WinLocalServiceSid = 23, + WinNetworkServiceSid = 24, + WinBuiltinDomainSid = 25, + WinBuiltinAdministratorsSid = 26, + WinBuiltinUsersSid = 27, + WinBuiltinGuestsSid = 28, + WinBuiltinPowerUsersSid = 29, + WinBuiltinAccountOperatorsSid = 30, + WinBuiltinSystemOperatorsSid = 31, + WinBuiltinPrintOperatorsSid = 32, + WinBuiltinBackupOperatorsSid = 33, + WinBuiltinReplicatorSid = 34, + WinBuiltinPreWindows2000CompatibleAccessSid = 35, + WinBuiltinRemoteDesktopUsersSid = 36, + WinBuiltinNetworkConfigurationOperatorsSid = 37, + WinAccountAdministratorSid = 38, + WinAccountGuestSid = 39, + WinAccountKrbtgtSid = 40, + WinAccountDomainAdminsSid = 41, + WinAccountDomainUsersSid = 42, + WinAccountDomainGuestsSid = 43, + WinAccountComputersSid = 44, + WinAccountControllersSid = 45, + WinAccountCertAdminsSid = 46, + WinAccountSchemaAdminsSid = 47, + WinAccountEnterpriseAdminsSid = 48, + WinAccountPolicyAdminsSid = 49, + WinAccountRasAndIasServersSid = 50, + WinNTLMAuthenticationSid = 51, + WinDigestAuthenticationSid = 52, + WinSChannelAuthenticationSid = 53, + WinThisOrganizationSid = 54, + WinOtherOrganizationSid = 55, + WinBuiltinIncomingForestTrustBuildersSid = 56, + WinBuiltinPerfMonitoringUsersSid = 57, + WinBuiltinPerfLoggingUsersSid = 58, + WinBuiltinAuthorizationAccessSid = 59, + WinBuiltinTerminalServerLicenseServersSid = 60, + WinBuiltinDCOMUsersSid = 61, + WinBuiltinIUsersSid = 62, + WinIUserSid = 63, + WinBuiltinCryptoOperatorsSid = 64, + WinUntrustedLabelSid = 65, + WinLowLabelSid = 66, + WinMediumLabelSid = 67, + WinHighLabelSid = 68, + WinSystemLabelSid = 69, + WinWriteRestrictedCodeSid = 70, + WinCreatorOwnerRightsSid = 71, + WinCacheablePrincipalsGroupSid = 72, + WinNonCacheablePrincipalsGroupSid = 73, + WinEnterpriseReadonlyControllersSid = 74, + WinAccountReadonlyControllersSid = 75, + WinBuiltinEventLogReadersGroup = 76, + WinNewEnterpriseReadonlyControllersSid = 77, + WinBuiltinCertSvcDComAccessGroup = 78, + WinMediumPlusLabelSid = 79, + WinLocalLogonSid = 80, + WinConsoleLogonSid = 81, + WinThisOrganizationCertificateSid = 82, + WinApplicationPackageAuthoritySid = 83, + WinBuiltinAnyPackageSid = 84, + WinCapabilityInternetClientSid = 85, + WinCapabilityInternetClientServerSid = 86, + WinCapabilityPrivateNetworkClientServerSid = 87, + WinCapabilityPicturesLibrarySid = 88, + WinCapabilityVideosLibrarySid = 89, + WinCapabilityMusicLibrarySid = 90, + WinCapabilityDocumentsLibrarySid = 91, + WinCapabilitySharedUserCertificatesSid = 92, + WinCapabilityEnterpriseAuthenticationSid = 93, + WinCapabilityRemovableStorageSid = 94, + WinBuiltinRDSRemoteAccessServersSid = 95, + WinBuiltinRDSEndpointServersSid = 96, + WinBuiltinRDSManagementServersSid = 97, + WinUserModeDriversSid = 98, + WinBuiltinHyperVAdminsSid = 99, + WinAccountCloneableControllersSid = 100, + WinBuiltinAccessControlAssistanceOperatorsSid = 101, + WinBuiltinRemoteManagementUsersSid = 102, + WinAuthenticationAuthorityAssertedSid = 103, + WinAuthenticationServiceAssertedSid = 104, + WinLocalAccountSid = 105, + WinLocalAccountAndAdministratorSid = 106, + WinAccountProtectedUsersSid = 107, + WinCapabilityAppointmentsSid = 108, + WinCapabilityContactsSid = 109, + WinAccountDefaultSystemManagedSid = 110, + WinBuiltinDefaultSystemManagedGroupSid = 111, + WinBuiltinStorageReplicaAdminsSid = 112, + WinAccountKeyAdminsSid = 113, + WinAccountEnterpriseKeyAdminsSid = 114, + WinAuthenticationKeyTrustSid = 115, + WinAuthenticationKeyPropertyMFASid = 116, + WinAuthenticationKeyPropertyAttestationSid = 117, + WinAuthenticationFreshKeyAuthSid = 118, + WinBuiltinDeviceOwnersSid = 119, } -pub type LDT_ENTRY = _LDT_ENTRY; -pub type PLDT_ENTRY = *mut _LDT_ENTRY; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _WOW64_FLOATING_SAVE_AREA { - pub ControlWord: DWORD, - pub StatusWord: DWORD, - pub TagWord: DWORD, - pub ErrorOffset: DWORD, - pub ErrorSelector: DWORD, - pub DataOffset: DWORD, - pub DataSelector: DWORD, - pub RegisterArea: [BYTE; 80usize], - pub Cr0NpxState: DWORD, +pub struct _ACL { + pub AclRevision: BYTE, + pub Sbz1: BYTE, + pub AclSize: WORD, + pub AceCount: WORD, + pub Sbz2: WORD, } #[test] -fn bindgen_test_layout__WOW64_FLOATING_SAVE_AREA() { +fn bindgen_test_layout__ACL() { assert_eq!( - ::std::mem::size_of::<_WOW64_FLOATING_SAVE_AREA>(), - 112usize, - concat!("Size of: ", stringify!(_WOW64_FLOATING_SAVE_AREA)) + ::std::mem::size_of::<_ACL>(), + 8usize, + concat!("Size of: ", stringify!(_ACL)) ); assert_eq!( - ::std::mem::align_of::<_WOW64_FLOATING_SAVE_AREA>(), - 4usize, - concat!("Alignment of ", stringify!(_WOW64_FLOATING_SAVE_AREA)) + ::std::mem::align_of::<_ACL>(), + 2usize, + concat!("Alignment of ", stringify!(_ACL)) ); - fn test_field_ControlWord() { + fn test_field_AclRevision() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_FLOATING_SAVE_AREA>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACL>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ControlWord) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AclRevision) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_WOW64_FLOATING_SAVE_AREA), - "::", - stringify!(ControlWord) - ) - ); - } - test_field_ControlWord(); - fn test_field_StatusWord() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_FLOATING_SAVE_AREA>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).StatusWord) as usize - ptr as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(_WOW64_FLOATING_SAVE_AREA), + stringify!(_ACL), "::", - stringify!(StatusWord) + stringify!(AclRevision) ) ); } - test_field_StatusWord(); - fn test_field_TagWord() { + test_field_AclRevision(); + fn test_field_Sbz1() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_FLOATING_SAVE_AREA>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACL>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).TagWord) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Sbz1) as usize - ptr as usize }, - 8usize, + 1usize, concat!( "Offset of field: ", - stringify!(_WOW64_FLOATING_SAVE_AREA), + stringify!(_ACL), "::", - stringify!(TagWord) + stringify!(Sbz1) ) ); } - test_field_TagWord(); - fn test_field_ErrorOffset() { + test_field_Sbz1(); + fn test_field_AclSize() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_FLOATING_SAVE_AREA>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACL>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ErrorOffset) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AclSize) as usize - ptr as usize }, - 12usize, + 2usize, concat!( "Offset of field: ", - stringify!(_WOW64_FLOATING_SAVE_AREA), + stringify!(_ACL), "::", - stringify!(ErrorOffset) + stringify!(AclSize) ) ); } - test_field_ErrorOffset(); - fn test_field_ErrorSelector() { + test_field_AclSize(); + fn test_field_AceCount() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_FLOATING_SAVE_AREA>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACL>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ErrorSelector) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AceCount) as usize - ptr as usize }, - 16usize, + 4usize, concat!( "Offset of field: ", - stringify!(_WOW64_FLOATING_SAVE_AREA), + stringify!(_ACL), "::", - stringify!(ErrorSelector) + stringify!(AceCount) ) ); } - test_field_ErrorSelector(); - fn test_field_DataOffset() { + test_field_AceCount(); + fn test_field_Sbz2() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_FLOATING_SAVE_AREA>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACL>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).DataOffset) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Sbz2) as usize - ptr as usize }, - 20usize, + 6usize, concat!( "Offset of field: ", - stringify!(_WOW64_FLOATING_SAVE_AREA), + stringify!(_ACL), "::", - stringify!(DataOffset) + stringify!(Sbz2) ) ); } - test_field_DataOffset(); - fn test_field_DataSelector() { + test_field_Sbz2(); +} +pub type ACL = _ACL; +pub type PACL = *mut ACL; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _ACE_HEADER { + pub AceType: BYTE, + pub AceFlags: BYTE, + pub AceSize: WORD, +} +#[test] +fn bindgen_test_layout__ACE_HEADER() { + assert_eq!( + ::std::mem::size_of::<_ACE_HEADER>(), + 4usize, + concat!("Size of: ", stringify!(_ACE_HEADER)) + ); + assert_eq!( + ::std::mem::align_of::<_ACE_HEADER>(), + 2usize, + concat!("Alignment of ", stringify!(_ACE_HEADER)) + ); + fn test_field_AceType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_FLOATING_SAVE_AREA>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACE_HEADER>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).DataSelector) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AceType) as usize - ptr as usize }, - 24usize, + 0usize, concat!( "Offset of field: ", - stringify!(_WOW64_FLOATING_SAVE_AREA), + stringify!(_ACE_HEADER), "::", - stringify!(DataSelector) + stringify!(AceType) ) ); } - test_field_DataSelector(); - fn test_field_RegisterArea() { + test_field_AceType(); + fn test_field_AceFlags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_FLOATING_SAVE_AREA>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACE_HEADER>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).RegisterArea) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AceFlags) as usize - ptr as usize }, - 28usize, + 1usize, concat!( "Offset of field: ", - stringify!(_WOW64_FLOATING_SAVE_AREA), + stringify!(_ACE_HEADER), "::", - stringify!(RegisterArea) + stringify!(AceFlags) ) ); } - test_field_RegisterArea(); - fn test_field_Cr0NpxState() { + test_field_AceFlags(); + fn test_field_AceSize() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_FLOATING_SAVE_AREA>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACE_HEADER>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Cr0NpxState) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AceSize) as usize - ptr as usize }, - 108usize, + 2usize, concat!( "Offset of field: ", - stringify!(_WOW64_FLOATING_SAVE_AREA), + stringify!(_ACE_HEADER), "::", - stringify!(Cr0NpxState) + stringify!(AceSize) ) ); } - test_field_Cr0NpxState(); + test_field_AceSize(); } -pub type WOW64_FLOATING_SAVE_AREA = _WOW64_FLOATING_SAVE_AREA; -pub type PWOW64_FLOATING_SAVE_AREA = *mut WOW64_FLOATING_SAVE_AREA; +pub type ACE_HEADER = _ACE_HEADER; +pub type PACE_HEADER = *mut ACE_HEADER; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _WOW64_CONTEXT { - pub ContextFlags: DWORD, - pub Dr0: DWORD, - pub Dr1: DWORD, - pub Dr2: DWORD, - pub Dr3: DWORD, - pub Dr6: DWORD, - pub Dr7: DWORD, - pub FloatSave: WOW64_FLOATING_SAVE_AREA, - pub SegGs: DWORD, - pub SegFs: DWORD, - pub SegEs: DWORD, - pub SegDs: DWORD, - pub Edi: DWORD, - pub Esi: DWORD, - pub Ebx: DWORD, - pub Edx: DWORD, - pub Ecx: DWORD, - pub Eax: DWORD, - pub Ebp: DWORD, - pub Eip: DWORD, - pub SegCs: DWORD, - pub EFlags: DWORD, - pub Esp: DWORD, - pub SegSs: DWORD, - pub ExtendedRegisters: [BYTE; 512usize], +pub struct _ACCESS_ALLOWED_ACE { + pub Header: ACE_HEADER, + pub Mask: ACCESS_MASK, + pub SidStart: DWORD, } #[test] -fn bindgen_test_layout__WOW64_CONTEXT() { +fn bindgen_test_layout__ACCESS_ALLOWED_ACE() { assert_eq!( - ::std::mem::size_of::<_WOW64_CONTEXT>(), - 716usize, - concat!("Size of: ", stringify!(_WOW64_CONTEXT)) + ::std::mem::size_of::<_ACCESS_ALLOWED_ACE>(), + 12usize, + concat!("Size of: ", stringify!(_ACCESS_ALLOWED_ACE)) ); assert_eq!( - ::std::mem::align_of::<_WOW64_CONTEXT>(), + ::std::mem::align_of::<_ACCESS_ALLOWED_ACE>(), 4usize, - concat!("Alignment of ", stringify!(_WOW64_CONTEXT)) + concat!("Alignment of ", stringify!(_ACCESS_ALLOWED_ACE)) ); - fn test_field_ContextFlags() { + fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ContextFlags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_ACCESS_ALLOWED_ACE), "::", - stringify!(ContextFlags) + stringify!(Header) ) ); } - test_field_ContextFlags(); - fn test_field_Dr0() { + test_field_Header(); + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Dr0) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_ACCESS_ALLOWED_ACE), "::", - stringify!(Dr0) + stringify!(Mask) ) ); } - test_field_Dr0(); - fn test_field_Dr1() { + test_field_Mask(); + fn test_field_SidStart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Dr1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_ACCESS_ALLOWED_ACE), "::", - stringify!(Dr1) + stringify!(SidStart) ) ); } - test_field_Dr1(); - fn test_field_Dr2() { + test_field_SidStart(); +} +pub type ACCESS_ALLOWED_ACE = _ACCESS_ALLOWED_ACE; +pub type PACCESS_ALLOWED_ACE = *mut ACCESS_ALLOWED_ACE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _ACCESS_DENIED_ACE { + pub Header: ACE_HEADER, + pub Mask: ACCESS_MASK, + pub SidStart: DWORD, +} +#[test] +fn bindgen_test_layout__ACCESS_DENIED_ACE() { + assert_eq!( + ::std::mem::size_of::<_ACCESS_DENIED_ACE>(), + 12usize, + concat!("Size of: ", stringify!(_ACCESS_DENIED_ACE)) + ); + assert_eq!( + ::std::mem::align_of::<_ACCESS_DENIED_ACE>(), + 4usize, + concat!("Alignment of ", stringify!(_ACCESS_DENIED_ACE)) + ); + fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Dr2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, - 12usize, + 0usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_ACCESS_DENIED_ACE), "::", - stringify!(Dr2) + stringify!(Header) ) ); } - test_field_Dr2(); - fn test_field_Dr3() { + test_field_Header(); + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Dr3) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, - 16usize, + 4usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_ACCESS_DENIED_ACE), "::", - stringify!(Dr3) + stringify!(Mask) ) ); } - test_field_Dr3(); - fn test_field_Dr6() { + test_field_Mask(); + fn test_field_SidStart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Dr6) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, - 20usize, + 8usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_ACCESS_DENIED_ACE), "::", - stringify!(Dr6) + stringify!(SidStart) ) ); } - test_field_Dr6(); - fn test_field_Dr7() { + test_field_SidStart(); +} +pub type ACCESS_DENIED_ACE = _ACCESS_DENIED_ACE; +pub type PACCESS_DENIED_ACE = *mut ACCESS_DENIED_ACE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SYSTEM_AUDIT_ACE { + pub Header: ACE_HEADER, + pub Mask: ACCESS_MASK, + pub SidStart: DWORD, +} +#[test] +fn bindgen_test_layout__SYSTEM_AUDIT_ACE() { + assert_eq!( + ::std::mem::size_of::<_SYSTEM_AUDIT_ACE>(), + 12usize, + concat!("Size of: ", stringify!(_SYSTEM_AUDIT_ACE)) + ); + assert_eq!( + ::std::mem::align_of::<_SYSTEM_AUDIT_ACE>(), + 4usize, + concat!("Alignment of ", stringify!(_SYSTEM_AUDIT_ACE)) + ); + fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Dr7) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, - 24usize, + 0usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_SYSTEM_AUDIT_ACE), "::", - stringify!(Dr7) + stringify!(Header) ) ); } - test_field_Dr7(); - fn test_field_FloatSave() { + test_field_Header(); + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).FloatSave) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, - 28usize, + 4usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_SYSTEM_AUDIT_ACE), "::", - stringify!(FloatSave) + stringify!(Mask) ) ); } - test_field_FloatSave(); - fn test_field_SegGs() { + test_field_Mask(); + fn test_field_SidStart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SegGs) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, - 140usize, + 8usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_SYSTEM_AUDIT_ACE), "::", - stringify!(SegGs) + stringify!(SidStart) ) ); } - test_field_SegGs(); - fn test_field_SegFs() { + test_field_SidStart(); +} +pub type SYSTEM_AUDIT_ACE = _SYSTEM_AUDIT_ACE; +pub type PSYSTEM_AUDIT_ACE = *mut SYSTEM_AUDIT_ACE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SYSTEM_ALARM_ACE { + pub Header: ACE_HEADER, + pub Mask: ACCESS_MASK, + pub SidStart: DWORD, +} +#[test] +fn bindgen_test_layout__SYSTEM_ALARM_ACE() { + assert_eq!( + ::std::mem::size_of::<_SYSTEM_ALARM_ACE>(), + 12usize, + concat!("Size of: ", stringify!(_SYSTEM_ALARM_ACE)) + ); + assert_eq!( + ::std::mem::align_of::<_SYSTEM_ALARM_ACE>(), + 4usize, + concat!("Alignment of ", stringify!(_SYSTEM_ALARM_ACE)) + ); + fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SegFs) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, - 144usize, + 0usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_SYSTEM_ALARM_ACE), "::", - stringify!(SegFs) + stringify!(Header) ) ); } - test_field_SegFs(); - fn test_field_SegEs() { + test_field_Header(); + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SegEs) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, - 148usize, + 4usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_SYSTEM_ALARM_ACE), "::", - stringify!(SegEs) + stringify!(Mask) ) ); } - test_field_SegEs(); - fn test_field_SegDs() { + test_field_Mask(); + fn test_field_SidStart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SegDs) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, - 152usize, + 8usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_SYSTEM_ALARM_ACE), "::", - stringify!(SegDs) + stringify!(SidStart) ) ); } - test_field_SegDs(); - fn test_field_Edi() { + test_field_SidStart(); +} +pub type SYSTEM_ALARM_ACE = _SYSTEM_ALARM_ACE; +pub type PSYSTEM_ALARM_ACE = *mut SYSTEM_ALARM_ACE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SYSTEM_RESOURCE_ATTRIBUTE_ACE { + pub Header: ACE_HEADER, + pub Mask: ACCESS_MASK, + pub SidStart: DWORD, +} +#[test] +fn bindgen_test_layout__SYSTEM_RESOURCE_ATTRIBUTE_ACE() { + assert_eq!( + ::std::mem::size_of::<_SYSTEM_RESOURCE_ATTRIBUTE_ACE>(), + 12usize, + concat!("Size of: ", stringify!(_SYSTEM_RESOURCE_ATTRIBUTE_ACE)) + ); + assert_eq!( + ::std::mem::align_of::<_SYSTEM_RESOURCE_ATTRIBUTE_ACE>(), + 4usize, + concat!("Alignment of ", stringify!(_SYSTEM_RESOURCE_ATTRIBUTE_ACE)) + ); + fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_RESOURCE_ATTRIBUTE_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Edi) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, - 156usize, + 0usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_SYSTEM_RESOURCE_ATTRIBUTE_ACE), "::", - stringify!(Edi) + stringify!(Header) ) ); } - test_field_Edi(); - fn test_field_Esi() { + test_field_Header(); + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_RESOURCE_ATTRIBUTE_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Esi) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, - 160usize, + 4usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_SYSTEM_RESOURCE_ATTRIBUTE_ACE), "::", - stringify!(Esi) - ) - ); - } - test_field_Esi(); - fn test_field_Ebx() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Ebx) as usize - ptr as usize - }, - 164usize, - concat!( - "Offset of field: ", - stringify!(_WOW64_CONTEXT), - "::", - stringify!(Ebx) + stringify!(Mask) ) ); } - test_field_Ebx(); - fn test_field_Edx() { + test_field_Mask(); + fn test_field_SidStart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_RESOURCE_ATTRIBUTE_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Edx) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, - 168usize, + 8usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_SYSTEM_RESOURCE_ATTRIBUTE_ACE), "::", - stringify!(Edx) + stringify!(SidStart) ) ); } - test_field_Edx(); - fn test_field_Ecx() { + test_field_SidStart(); +} +pub type SYSTEM_RESOURCE_ATTRIBUTE_ACE = _SYSTEM_RESOURCE_ATTRIBUTE_ACE; +pub type PSYSTEM_RESOURCE_ATTRIBUTE_ACE = *mut _SYSTEM_RESOURCE_ATTRIBUTE_ACE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SYSTEM_SCOPED_POLICY_ID_ACE { + pub Header: ACE_HEADER, + pub Mask: ACCESS_MASK, + pub SidStart: DWORD, +} +#[test] +fn bindgen_test_layout__SYSTEM_SCOPED_POLICY_ID_ACE() { + assert_eq!( + ::std::mem::size_of::<_SYSTEM_SCOPED_POLICY_ID_ACE>(), + 12usize, + concat!("Size of: ", stringify!(_SYSTEM_SCOPED_POLICY_ID_ACE)) + ); + assert_eq!( + ::std::mem::align_of::<_SYSTEM_SCOPED_POLICY_ID_ACE>(), + 4usize, + concat!("Alignment of ", stringify!(_SYSTEM_SCOPED_POLICY_ID_ACE)) + ); + fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_SCOPED_POLICY_ID_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Ecx) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, - 172usize, + 0usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_SYSTEM_SCOPED_POLICY_ID_ACE), "::", - stringify!(Ecx) + stringify!(Header) ) ); } - test_field_Ecx(); - fn test_field_Eax() { + test_field_Header(); + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_SCOPED_POLICY_ID_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Eax) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, - 176usize, + 4usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_SYSTEM_SCOPED_POLICY_ID_ACE), "::", - stringify!(Eax) + stringify!(Mask) ) ); } - test_field_Eax(); - fn test_field_Ebp() { + test_field_Mask(); + fn test_field_SidStart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_SCOPED_POLICY_ID_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Ebp) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, - 180usize, + 8usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_SYSTEM_SCOPED_POLICY_ID_ACE), "::", - stringify!(Ebp) + stringify!(SidStart) ) ); } - test_field_Ebp(); - fn test_field_Eip() { + test_field_SidStart(); +} +pub type SYSTEM_SCOPED_POLICY_ID_ACE = _SYSTEM_SCOPED_POLICY_ID_ACE; +pub type PSYSTEM_SCOPED_POLICY_ID_ACE = *mut _SYSTEM_SCOPED_POLICY_ID_ACE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SYSTEM_MANDATORY_LABEL_ACE { + pub Header: ACE_HEADER, + pub Mask: ACCESS_MASK, + pub SidStart: DWORD, +} +#[test] +fn bindgen_test_layout__SYSTEM_MANDATORY_LABEL_ACE() { + assert_eq!( + ::std::mem::size_of::<_SYSTEM_MANDATORY_LABEL_ACE>(), + 12usize, + concat!("Size of: ", stringify!(_SYSTEM_MANDATORY_LABEL_ACE)) + ); + assert_eq!( + ::std::mem::align_of::<_SYSTEM_MANDATORY_LABEL_ACE>(), + 4usize, + concat!("Alignment of ", stringify!(_SYSTEM_MANDATORY_LABEL_ACE)) + ); + fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_MANDATORY_LABEL_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Eip) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, - 184usize, + 0usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_SYSTEM_MANDATORY_LABEL_ACE), "::", - stringify!(Eip) + stringify!(Header) ) ); } - test_field_Eip(); - fn test_field_SegCs() { + test_field_Header(); + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_MANDATORY_LABEL_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SegCs) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, - 188usize, + 4usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_SYSTEM_MANDATORY_LABEL_ACE), "::", - stringify!(SegCs) + stringify!(Mask) ) ); } - test_field_SegCs(); - fn test_field_EFlags() { + test_field_Mask(); + fn test_field_SidStart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_MANDATORY_LABEL_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).EFlags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, - 192usize, + 8usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_SYSTEM_MANDATORY_LABEL_ACE), "::", - stringify!(EFlags) + stringify!(SidStart) ) ); } - test_field_EFlags(); - fn test_field_Esp() { + test_field_SidStart(); +} +pub type SYSTEM_MANDATORY_LABEL_ACE = _SYSTEM_MANDATORY_LABEL_ACE; +pub type PSYSTEM_MANDATORY_LABEL_ACE = *mut _SYSTEM_MANDATORY_LABEL_ACE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SYSTEM_PROCESS_TRUST_LABEL_ACE { + pub Header: ACE_HEADER, + pub Mask: ACCESS_MASK, + pub SidStart: DWORD, +} +#[test] +fn bindgen_test_layout__SYSTEM_PROCESS_TRUST_LABEL_ACE() { + assert_eq!( + ::std::mem::size_of::<_SYSTEM_PROCESS_TRUST_LABEL_ACE>(), + 12usize, + concat!("Size of: ", stringify!(_SYSTEM_PROCESS_TRUST_LABEL_ACE)) + ); + assert_eq!( + ::std::mem::align_of::<_SYSTEM_PROCESS_TRUST_LABEL_ACE>(), + 4usize, + concat!("Alignment of ", stringify!(_SYSTEM_PROCESS_TRUST_LABEL_ACE)) + ); + fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_PROCESS_TRUST_LABEL_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Esp) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, - 196usize, + 0usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_SYSTEM_PROCESS_TRUST_LABEL_ACE), "::", - stringify!(Esp) + stringify!(Header) ) ); } - test_field_Esp(); - fn test_field_SegSs() { + test_field_Header(); + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_PROCESS_TRUST_LABEL_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SegSs) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, - 200usize, + 4usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_SYSTEM_PROCESS_TRUST_LABEL_ACE), "::", - stringify!(SegSs) + stringify!(Mask) ) ); } - test_field_SegSs(); - fn test_field_ExtendedRegisters() { + test_field_Mask(); + fn test_field_SidStart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_CONTEXT>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_PROCESS_TRUST_LABEL_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExtendedRegisters) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, - 204usize, + 8usize, concat!( "Offset of field: ", - stringify!(_WOW64_CONTEXT), + stringify!(_SYSTEM_PROCESS_TRUST_LABEL_ACE), "::", - stringify!(ExtendedRegisters) + stringify!(SidStart) ) ); } - test_field_ExtendedRegisters(); -} -pub type WOW64_CONTEXT = _WOW64_CONTEXT; -pub type PWOW64_CONTEXT = *mut WOW64_CONTEXT; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _WOW64_LDT_ENTRY { - pub LimitLow: WORD, - pub BaseLow: WORD, - pub HighWord: _WOW64_LDT_ENTRY__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _WOW64_LDT_ENTRY__bindgen_ty_1 { - pub Bytes: _WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1, - pub Bits: _WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2, + test_field_SidStart(); } +pub type SYSTEM_PROCESS_TRUST_LABEL_ACE = _SYSTEM_PROCESS_TRUST_LABEL_ACE; +pub type PSYSTEM_PROCESS_TRUST_LABEL_ACE = *mut _SYSTEM_PROCESS_TRUST_LABEL_ACE; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1 { - pub BaseMid: BYTE, - pub Flags1: BYTE, - pub Flags2: BYTE, - pub BaseHi: BYTE, +pub struct _SYSTEM_ACCESS_FILTER_ACE { + pub Header: ACE_HEADER, + pub Mask: ACCESS_MASK, + pub SidStart: DWORD, } #[test] -fn bindgen_test_layout__WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1() { +fn bindgen_test_layout__SYSTEM_ACCESS_FILTER_ACE() { assert_eq!( - ::std::mem::size_of::<_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - concat!( - "Size of: ", - stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1) - ) + ::std::mem::size_of::<_SYSTEM_ACCESS_FILTER_ACE>(), + 12usize, + concat!("Size of: ", stringify!(_SYSTEM_ACCESS_FILTER_ACE)) ); assert_eq!( - ::std::mem::align_of::<_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>(), - 1usize, - concat!( - "Alignment of ", - stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1) - ) + ::std::mem::align_of::<_SYSTEM_ACCESS_FILTER_ACE>(), + 4usize, + concat!("Alignment of ", stringify!(_SYSTEM_ACCESS_FILTER_ACE)) ); - fn test_field_BaseMid() { + fn test_field_Header() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>::uninit( - ); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ACCESS_FILTER_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).BaseMid) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1), - "::", - stringify!(BaseMid) - ) - ); - } - test_field_BaseMid(); - fn test_field_Flags1() { - assert_eq!( - unsafe { - let uninit = - ::std::mem::MaybeUninit::<_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>::uninit( - ); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags1) as usize - ptr as usize - }, - 1usize, - concat!( - "Offset of field: ", - stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1), + stringify!(_SYSTEM_ACCESS_FILTER_ACE), "::", - stringify!(Flags1) + stringify!(Header) ) ); } - test_field_Flags1(); - fn test_field_Flags2() { + test_field_Header(); + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>::uninit( - ); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ACCESS_FILTER_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, - 2usize, + 4usize, concat!( "Offset of field: ", - stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1), + stringify!(_SYSTEM_ACCESS_FILTER_ACE), "::", - stringify!(Flags2) + stringify!(Mask) ) ); } - test_field_Flags2(); - fn test_field_BaseHi() { + test_field_Mask(); + fn test_field_SidStart() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1>::uninit( - ); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ACCESS_FILTER_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).BaseHi) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, - 3usize, + 8usize, concat!( "Offset of field: ", - stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_1), + stringify!(_SYSTEM_ACCESS_FILTER_ACE), "::", - stringify!(BaseHi) + stringify!(SidStart) ) ); } - test_field_BaseHi(); + test_field_SidStart(); } +pub type SYSTEM_ACCESS_FILTER_ACE = _SYSTEM_ACCESS_FILTER_ACE; +pub type PSYSTEM_ACCESS_FILTER_ACE = *mut _SYSTEM_ACCESS_FILTER_ACE; #[repr(C)] -#[repr(align(4))] #[derive(Debug, Copy, Clone)] -pub struct _WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2 { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -#[test] -fn bindgen_test_layout__WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2() { - assert_eq!( - ::std::mem::size_of::<_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2>(), - 4usize, - concat!( - "Size of: ", - stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2) - ) - ); - assert_eq!( - ::std::mem::align_of::<_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2>(), - 4usize, - concat!( - "Alignment of ", - stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2) - ) - ); -} -impl _WOW64_LDT_ENTRY__bindgen_ty_1__bindgen_ty_2 { - #[inline] - pub fn BaseMid(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) } - } - #[inline] - pub fn set_BaseMid(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 8u8, val as u64) - } - } - #[inline] - pub fn Type(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 5u8) as u32) } - } - #[inline] - pub fn set_Type(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 5u8, val as u64) - } - } - #[inline] - pub fn Dpl(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 2u8) as u32) } - } - #[inline] - pub fn set_Dpl(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(13usize, 2u8, val as u64) - } - } - #[inline] - pub fn Pres(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } - } - #[inline] - pub fn set_Pres(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(15usize, 1u8, val as u64) - } - } - #[inline] - pub fn LimitHi(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 4u8) as u32) } - } - #[inline] - pub fn set_LimitHi(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(16usize, 4u8, val as u64) - } - } - #[inline] - pub fn Sys(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) } - } - #[inline] - pub fn set_Sys(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(20usize, 1u8, val as u64) - } - } - #[inline] - pub fn Reserved_0(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) } - } - #[inline] - pub fn set_Reserved_0(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(21usize, 1u8, val as u64) - } - } - #[inline] - pub fn Default_Big(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) } - } - #[inline] - pub fn set_Default_Big(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(22usize, 1u8, val as u64) - } - } - #[inline] - pub fn Granularity(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } - } - #[inline] - pub fn set_Granularity(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(23usize, 1u8, val as u64) - } - } - #[inline] - pub fn BaseHi(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } - } - #[inline] - pub fn set_BaseHi(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(24usize, 8u8, val as u64) - } - } - #[inline] - pub fn new_bitfield_1( - BaseMid: DWORD, - Type: DWORD, - Dpl: DWORD, - Pres: DWORD, - LimitHi: DWORD, - Sys: DWORD, - Reserved_0: DWORD, - Default_Big: DWORD, - Granularity: DWORD, - BaseHi: DWORD, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 8u8, { - let BaseMid: u32 = unsafe { ::std::mem::transmute(BaseMid) }; - BaseMid as u64 - }); - __bindgen_bitfield_unit.set(8usize, 5u8, { - let Type: u32 = unsafe { ::std::mem::transmute(Type) }; - Type as u64 - }); - __bindgen_bitfield_unit.set(13usize, 2u8, { - let Dpl: u32 = unsafe { ::std::mem::transmute(Dpl) }; - Dpl as u64 - }); - __bindgen_bitfield_unit.set(15usize, 1u8, { - let Pres: u32 = unsafe { ::std::mem::transmute(Pres) }; - Pres as u64 - }); - __bindgen_bitfield_unit.set(16usize, 4u8, { - let LimitHi: u32 = unsafe { ::std::mem::transmute(LimitHi) }; - LimitHi as u64 - }); - __bindgen_bitfield_unit.set(20usize, 1u8, { - let Sys: u32 = unsafe { ::std::mem::transmute(Sys) }; - Sys as u64 - }); - __bindgen_bitfield_unit.set(21usize, 1u8, { - let Reserved_0: u32 = unsafe { ::std::mem::transmute(Reserved_0) }; - Reserved_0 as u64 - }); - __bindgen_bitfield_unit.set(22usize, 1u8, { - let Default_Big: u32 = unsafe { ::std::mem::transmute(Default_Big) }; - Default_Big as u64 - }); - __bindgen_bitfield_unit.set(23usize, 1u8, { - let Granularity: u32 = unsafe { ::std::mem::transmute(Granularity) }; - Granularity as u64 - }); - __bindgen_bitfield_unit.set(24usize, 8u8, { - let BaseHi: u32 = unsafe { ::std::mem::transmute(BaseHi) }; - BaseHi as u64 - }); - __bindgen_bitfield_unit - } +pub struct _ACCESS_ALLOWED_OBJECT_ACE { + pub Header: ACE_HEADER, + pub Mask: ACCESS_MASK, + pub Flags: DWORD, + pub ObjectType: GUID, + pub InheritedObjectType: GUID, + pub SidStart: DWORD, } #[test] -fn bindgen_test_layout__WOW64_LDT_ENTRY__bindgen_ty_1() { +fn bindgen_test_layout__ACCESS_ALLOWED_OBJECT_ACE() { assert_eq!( - ::std::mem::size_of::<_WOW64_LDT_ENTRY__bindgen_ty_1>(), - 4usize, - concat!("Size of: ", stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1)) + ::std::mem::size_of::<_ACCESS_ALLOWED_OBJECT_ACE>(), + 48usize, + concat!("Size of: ", stringify!(_ACCESS_ALLOWED_OBJECT_ACE)) ); assert_eq!( - ::std::mem::align_of::<_WOW64_LDT_ENTRY__bindgen_ty_1>(), + ::std::mem::align_of::<_ACCESS_ALLOWED_OBJECT_ACE>(), 4usize, - concat!("Alignment of ", stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1)) + concat!("Alignment of ", stringify!(_ACCESS_ALLOWED_OBJECT_ACE)) ); - fn test_field_Bytes() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_LDT_ENTRY__bindgen_ty_1>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Bytes) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1), - "::", - stringify!(Bytes) - ) - ); - } - test_field_Bytes(); - fn test_field_Bits() { + fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_LDT_ENTRY__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Bits) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_WOW64_LDT_ENTRY__bindgen_ty_1), + stringify!(_ACCESS_ALLOWED_OBJECT_ACE), "::", - stringify!(Bits) + stringify!(Header) ) ); } - test_field_Bits(); -} -#[test] -fn bindgen_test_layout__WOW64_LDT_ENTRY() { - assert_eq!( - ::std::mem::size_of::<_WOW64_LDT_ENTRY>(), - 8usize, - concat!("Size of: ", stringify!(_WOW64_LDT_ENTRY)) - ); - assert_eq!( - ::std::mem::align_of::<_WOW64_LDT_ENTRY>(), - 4usize, - concat!("Alignment of ", stringify!(_WOW64_LDT_ENTRY)) - ); - fn test_field_LimitLow() { + test_field_Header(); + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_LDT_ENTRY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).LimitLow) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, - 0usize, + 4usize, concat!( "Offset of field: ", - stringify!(_WOW64_LDT_ENTRY), + stringify!(_ACCESS_ALLOWED_OBJECT_ACE), "::", - stringify!(LimitLow) + stringify!(Mask) ) ); } - test_field_LimitLow(); - fn test_field_BaseLow() { + test_field_Mask(); + fn test_field_Flags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_LDT_ENTRY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).BaseLow) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, - 2usize, + 8usize, concat!( "Offset of field: ", - stringify!(_WOW64_LDT_ENTRY), + stringify!(_ACCESS_ALLOWED_OBJECT_ACE), "::", - stringify!(BaseLow) + stringify!(Flags) ) ); } - test_field_BaseLow(); - fn test_field_HighWord() { + test_field_Flags(); + fn test_field_ObjectType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_LDT_ENTRY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).HighWord) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ObjectType) as usize - ptr as usize }, - 4usize, + 12usize, concat!( "Offset of field: ", - stringify!(_WOW64_LDT_ENTRY), + stringify!(_ACCESS_ALLOWED_OBJECT_ACE), "::", - stringify!(HighWord) + stringify!(ObjectType) ) ); } - test_field_HighWord(); -} -pub type WOW64_LDT_ENTRY = _WOW64_LDT_ENTRY; -pub type PWOW64_LDT_ENTRY = *mut _WOW64_LDT_ENTRY; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _WOW64_DESCRIPTOR_TABLE_ENTRY { - pub Selector: DWORD, - pub Descriptor: WOW64_LDT_ENTRY, -} -#[test] -fn bindgen_test_layout__WOW64_DESCRIPTOR_TABLE_ENTRY() { - assert_eq!( - ::std::mem::size_of::<_WOW64_DESCRIPTOR_TABLE_ENTRY>(), - 12usize, - concat!("Size of: ", stringify!(_WOW64_DESCRIPTOR_TABLE_ENTRY)) - ); - assert_eq!( - ::std::mem::align_of::<_WOW64_DESCRIPTOR_TABLE_ENTRY>(), - 4usize, - concat!("Alignment of ", stringify!(_WOW64_DESCRIPTOR_TABLE_ENTRY)) - ); - fn test_field_Selector() { + test_field_ObjectType(); + fn test_field_InheritedObjectType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_DESCRIPTOR_TABLE_ENTRY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Selector) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).InheritedObjectType) as usize - ptr as usize }, - 0usize, + 28usize, concat!( "Offset of field: ", - stringify!(_WOW64_DESCRIPTOR_TABLE_ENTRY), + stringify!(_ACCESS_ALLOWED_OBJECT_ACE), "::", - stringify!(Selector) + stringify!(InheritedObjectType) ) ); } - test_field_Selector(); - fn test_field_Descriptor() { + test_field_InheritedObjectType(); + fn test_field_SidStart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_WOW64_DESCRIPTOR_TABLE_ENTRY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Descriptor) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, - 4usize, + 44usize, concat!( "Offset of field: ", - stringify!(_WOW64_DESCRIPTOR_TABLE_ENTRY), + stringify!(_ACCESS_ALLOWED_OBJECT_ACE), "::", - stringify!(Descriptor) + stringify!(SidStart) ) ); } - test_field_Descriptor(); + test_field_SidStart(); } -pub type WOW64_DESCRIPTOR_TABLE_ENTRY = _WOW64_DESCRIPTOR_TABLE_ENTRY; -pub type PWOW64_DESCRIPTOR_TABLE_ENTRY = *mut _WOW64_DESCRIPTOR_TABLE_ENTRY; +pub type ACCESS_ALLOWED_OBJECT_ACE = _ACCESS_ALLOWED_OBJECT_ACE; +pub type PACCESS_ALLOWED_OBJECT_ACE = *mut _ACCESS_ALLOWED_OBJECT_ACE; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _EXCEPTION_RECORD { - pub ExceptionCode: DWORD, - pub ExceptionFlags: DWORD, - pub ExceptionRecord: *mut _EXCEPTION_RECORD, - pub ExceptionAddress: PVOID, - pub NumberParameters: DWORD, - pub ExceptionInformation: [ULONG_PTR; 15usize], +pub struct _ACCESS_DENIED_OBJECT_ACE { + pub Header: ACE_HEADER, + pub Mask: ACCESS_MASK, + pub Flags: DWORD, + pub ObjectType: GUID, + pub InheritedObjectType: GUID, + pub SidStart: DWORD, } #[test] -fn bindgen_test_layout__EXCEPTION_RECORD() { +fn bindgen_test_layout__ACCESS_DENIED_OBJECT_ACE() { assert_eq!( - ::std::mem::size_of::<_EXCEPTION_RECORD>(), - 152usize, - concat!("Size of: ", stringify!(_EXCEPTION_RECORD)) + ::std::mem::size_of::<_ACCESS_DENIED_OBJECT_ACE>(), + 48usize, + concat!("Size of: ", stringify!(_ACCESS_DENIED_OBJECT_ACE)) ); assert_eq!( - ::std::mem::align_of::<_EXCEPTION_RECORD>(), - 8usize, - concat!("Alignment of ", stringify!(_EXCEPTION_RECORD)) + ::std::mem::align_of::<_ACCESS_DENIED_OBJECT_ACE>(), + 4usize, + concat!("Alignment of ", stringify!(_ACCESS_DENIED_OBJECT_ACE)) ); - fn test_field_ExceptionCode() { + fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExceptionCode) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_EXCEPTION_RECORD), + stringify!(_ACCESS_DENIED_OBJECT_ACE), "::", - stringify!(ExceptionCode) + stringify!(Header) ) ); } - test_field_ExceptionCode(); - fn test_field_ExceptionFlags() { + test_field_Header(); + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExceptionFlags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", - stringify!(_EXCEPTION_RECORD), + stringify!(_ACCESS_DENIED_OBJECT_ACE), "::", - stringify!(ExceptionFlags) + stringify!(Mask) ) ); } - test_field_ExceptionFlags(); - fn test_field_ExceptionRecord() { + test_field_Mask(); + fn test_field_Flags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExceptionRecord) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_EXCEPTION_RECORD), + stringify!(_ACCESS_DENIED_OBJECT_ACE), "::", - stringify!(ExceptionRecord) + stringify!(Flags) ) ); } - test_field_ExceptionRecord(); - fn test_field_ExceptionAddress() { + test_field_Flags(); + fn test_field_ObjectType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExceptionAddress) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ObjectType) as usize - ptr as usize }, - 16usize, + 12usize, concat!( "Offset of field: ", - stringify!(_EXCEPTION_RECORD), + stringify!(_ACCESS_DENIED_OBJECT_ACE), "::", - stringify!(ExceptionAddress) + stringify!(ObjectType) ) ); } - test_field_ExceptionAddress(); - fn test_field_NumberParameters() { + test_field_ObjectType(); + fn test_field_InheritedObjectType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).NumberParameters) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).InheritedObjectType) as usize - ptr as usize }, - 24usize, + 28usize, concat!( "Offset of field: ", - stringify!(_EXCEPTION_RECORD), + stringify!(_ACCESS_DENIED_OBJECT_ACE), "::", - stringify!(NumberParameters) + stringify!(InheritedObjectType) ) ); } - test_field_NumberParameters(); - fn test_field_ExceptionInformation() { + test_field_InheritedObjectType(); + fn test_field_SidStart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExceptionInformation) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, - 32usize, + 44usize, concat!( "Offset of field: ", - stringify!(_EXCEPTION_RECORD), + stringify!(_ACCESS_DENIED_OBJECT_ACE), "::", - stringify!(ExceptionInformation) + stringify!(SidStart) ) ); } - test_field_ExceptionInformation(); + test_field_SidStart(); } -pub type EXCEPTION_RECORD = _EXCEPTION_RECORD; -pub type PEXCEPTION_RECORD = *mut EXCEPTION_RECORD; +pub type ACCESS_DENIED_OBJECT_ACE = _ACCESS_DENIED_OBJECT_ACE; +pub type PACCESS_DENIED_OBJECT_ACE = *mut _ACCESS_DENIED_OBJECT_ACE; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _EXCEPTION_RECORD32 { - pub ExceptionCode: DWORD, - pub ExceptionFlags: DWORD, - pub ExceptionRecord: DWORD, - pub ExceptionAddress: DWORD, - pub NumberParameters: DWORD, - pub ExceptionInformation: [DWORD; 15usize], +pub struct _SYSTEM_AUDIT_OBJECT_ACE { + pub Header: ACE_HEADER, + pub Mask: ACCESS_MASK, + pub Flags: DWORD, + pub ObjectType: GUID, + pub InheritedObjectType: GUID, + pub SidStart: DWORD, } #[test] -fn bindgen_test_layout__EXCEPTION_RECORD32() { +fn bindgen_test_layout__SYSTEM_AUDIT_OBJECT_ACE() { assert_eq!( - ::std::mem::size_of::<_EXCEPTION_RECORD32>(), - 80usize, - concat!("Size of: ", stringify!(_EXCEPTION_RECORD32)) + ::std::mem::size_of::<_SYSTEM_AUDIT_OBJECT_ACE>(), + 48usize, + concat!("Size of: ", stringify!(_SYSTEM_AUDIT_OBJECT_ACE)) ); assert_eq!( - ::std::mem::align_of::<_EXCEPTION_RECORD32>(), + ::std::mem::align_of::<_SYSTEM_AUDIT_OBJECT_ACE>(), 4usize, - concat!("Alignment of ", stringify!(_EXCEPTION_RECORD32)) + concat!("Alignment of ", stringify!(_SYSTEM_AUDIT_OBJECT_ACE)) ); - fn test_field_ExceptionCode() { + fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD32>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExceptionCode) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_EXCEPTION_RECORD32), + stringify!(_SYSTEM_AUDIT_OBJECT_ACE), "::", - stringify!(ExceptionCode) + stringify!(Header) ) ); } - test_field_ExceptionCode(); - fn test_field_ExceptionFlags() { + test_field_Header(); + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD32>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExceptionFlags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", - stringify!(_EXCEPTION_RECORD32), + stringify!(_SYSTEM_AUDIT_OBJECT_ACE), "::", - stringify!(ExceptionFlags) + stringify!(Mask) ) ); } - test_field_ExceptionFlags(); - fn test_field_ExceptionRecord() { + test_field_Mask(); + fn test_field_Flags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD32>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExceptionRecord) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_EXCEPTION_RECORD32), + stringify!(_SYSTEM_AUDIT_OBJECT_ACE), "::", - stringify!(ExceptionRecord) + stringify!(Flags) ) ); } - test_field_ExceptionRecord(); - fn test_field_ExceptionAddress() { + test_field_Flags(); + fn test_field_ObjectType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD32>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExceptionAddress) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ObjectType) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", - stringify!(_EXCEPTION_RECORD32), + stringify!(_SYSTEM_AUDIT_OBJECT_ACE), "::", - stringify!(ExceptionAddress) + stringify!(ObjectType) ) ); } - test_field_ExceptionAddress(); - fn test_field_NumberParameters() { + test_field_ObjectType(); + fn test_field_InheritedObjectType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD32>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).NumberParameters) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).InheritedObjectType) as usize - ptr as usize }, - 16usize, + 28usize, concat!( "Offset of field: ", - stringify!(_EXCEPTION_RECORD32), + stringify!(_SYSTEM_AUDIT_OBJECT_ACE), "::", - stringify!(NumberParameters) + stringify!(InheritedObjectType) ) ); } - test_field_NumberParameters(); - fn test_field_ExceptionInformation() { + test_field_InheritedObjectType(); + fn test_field_SidStart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD32>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExceptionInformation) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, - 20usize, + 44usize, concat!( "Offset of field: ", - stringify!(_EXCEPTION_RECORD32), + stringify!(_SYSTEM_AUDIT_OBJECT_ACE), "::", - stringify!(ExceptionInformation) + stringify!(SidStart) ) ); } - test_field_ExceptionInformation(); + test_field_SidStart(); } -pub type EXCEPTION_RECORD32 = _EXCEPTION_RECORD32; -pub type PEXCEPTION_RECORD32 = *mut _EXCEPTION_RECORD32; +pub type SYSTEM_AUDIT_OBJECT_ACE = _SYSTEM_AUDIT_OBJECT_ACE; +pub type PSYSTEM_AUDIT_OBJECT_ACE = *mut _SYSTEM_AUDIT_OBJECT_ACE; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _EXCEPTION_RECORD64 { - pub ExceptionCode: DWORD, - pub ExceptionFlags: DWORD, - pub ExceptionRecord: DWORD64, - pub ExceptionAddress: DWORD64, - pub NumberParameters: DWORD, - pub __unusedAlignment: DWORD, - pub ExceptionInformation: [DWORD64; 15usize], +pub struct _SYSTEM_ALARM_OBJECT_ACE { + pub Header: ACE_HEADER, + pub Mask: ACCESS_MASK, + pub Flags: DWORD, + pub ObjectType: GUID, + pub InheritedObjectType: GUID, + pub SidStart: DWORD, } #[test] -fn bindgen_test_layout__EXCEPTION_RECORD64() { +fn bindgen_test_layout__SYSTEM_ALARM_OBJECT_ACE() { assert_eq!( - ::std::mem::size_of::<_EXCEPTION_RECORD64>(), - 152usize, - concat!("Size of: ", stringify!(_EXCEPTION_RECORD64)) + ::std::mem::size_of::<_SYSTEM_ALARM_OBJECT_ACE>(), + 48usize, + concat!("Size of: ", stringify!(_SYSTEM_ALARM_OBJECT_ACE)) ); assert_eq!( - ::std::mem::align_of::<_EXCEPTION_RECORD64>(), - 8usize, - concat!("Alignment of ", stringify!(_EXCEPTION_RECORD64)) + ::std::mem::align_of::<_SYSTEM_ALARM_OBJECT_ACE>(), + 4usize, + concat!("Alignment of ", stringify!(_SYSTEM_ALARM_OBJECT_ACE)) ); - fn test_field_ExceptionCode() { + fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExceptionCode) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_EXCEPTION_RECORD64), + stringify!(_SYSTEM_ALARM_OBJECT_ACE), "::", - stringify!(ExceptionCode) + stringify!(Header) ) ); } - test_field_ExceptionCode(); - fn test_field_ExceptionFlags() { + test_field_Header(); + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExceptionFlags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", - stringify!(_EXCEPTION_RECORD64), + stringify!(_SYSTEM_ALARM_OBJECT_ACE), "::", - stringify!(ExceptionFlags) + stringify!(Mask) ) ); } - test_field_ExceptionFlags(); - fn test_field_ExceptionRecord() { + test_field_Mask(); + fn test_field_Flags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExceptionRecord) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_EXCEPTION_RECORD64), - "::", - stringify!(ExceptionRecord) - ) - ); - } - test_field_ExceptionRecord(); - fn test_field_ExceptionAddress() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD64>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExceptionAddress) as usize - ptr as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(_EXCEPTION_RECORD64), + stringify!(_SYSTEM_ALARM_OBJECT_ACE), "::", - stringify!(ExceptionAddress) + stringify!(Flags) ) ); } - test_field_ExceptionAddress(); - fn test_field_NumberParameters() { + test_field_Flags(); + fn test_field_ObjectType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).NumberParameters) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ObjectType) as usize - ptr as usize }, - 24usize, + 12usize, concat!( "Offset of field: ", - stringify!(_EXCEPTION_RECORD64), + stringify!(_SYSTEM_ALARM_OBJECT_ACE), "::", - stringify!(NumberParameters) + stringify!(ObjectType) ) ); } - test_field_NumberParameters(); - fn test_field___unusedAlignment() { + test_field_ObjectType(); + fn test_field_InheritedObjectType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).__unusedAlignment) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).InheritedObjectType) as usize - ptr as usize }, 28usize, concat!( "Offset of field: ", - stringify!(_EXCEPTION_RECORD64), + stringify!(_SYSTEM_ALARM_OBJECT_ACE), "::", - stringify!(__unusedAlignment) + stringify!(InheritedObjectType) ) ); } - test_field___unusedAlignment(); - fn test_field_ExceptionInformation() { + test_field_InheritedObjectType(); + fn test_field_SidStart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_RECORD64>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExceptionInformation) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, - 32usize, + 44usize, concat!( "Offset of field: ", - stringify!(_EXCEPTION_RECORD64), + stringify!(_SYSTEM_ALARM_OBJECT_ACE), "::", - stringify!(ExceptionInformation) + stringify!(SidStart) ) ); } - test_field_ExceptionInformation(); + test_field_SidStart(); } -pub type EXCEPTION_RECORD64 = _EXCEPTION_RECORD64; -pub type PEXCEPTION_RECORD64 = *mut _EXCEPTION_RECORD64; +pub type SYSTEM_ALARM_OBJECT_ACE = _SYSTEM_ALARM_OBJECT_ACE; +pub type PSYSTEM_ALARM_OBJECT_ACE = *mut _SYSTEM_ALARM_OBJECT_ACE; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _EXCEPTION_POINTERS { - pub ExceptionRecord: PEXCEPTION_RECORD, - pub ContextRecord: PCONTEXT, +pub struct _ACCESS_ALLOWED_CALLBACK_ACE { + pub Header: ACE_HEADER, + pub Mask: ACCESS_MASK, + pub SidStart: DWORD, } #[test] -fn bindgen_test_layout__EXCEPTION_POINTERS() { +fn bindgen_test_layout__ACCESS_ALLOWED_CALLBACK_ACE() { assert_eq!( - ::std::mem::size_of::<_EXCEPTION_POINTERS>(), - 16usize, - concat!("Size of: ", stringify!(_EXCEPTION_POINTERS)) + ::std::mem::size_of::<_ACCESS_ALLOWED_CALLBACK_ACE>(), + 12usize, + concat!("Size of: ", stringify!(_ACCESS_ALLOWED_CALLBACK_ACE)) ); assert_eq!( - ::std::mem::align_of::<_EXCEPTION_POINTERS>(), - 8usize, - concat!("Alignment of ", stringify!(_EXCEPTION_POINTERS)) + ::std::mem::align_of::<_ACCESS_ALLOWED_CALLBACK_ACE>(), + 4usize, + concat!("Alignment of ", stringify!(_ACCESS_ALLOWED_CALLBACK_ACE)) ); - fn test_field_ExceptionRecord() { + fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_POINTERS>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_CALLBACK_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExceptionRecord) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_EXCEPTION_POINTERS), + stringify!(_ACCESS_ALLOWED_CALLBACK_ACE), "::", - stringify!(ExceptionRecord) + stringify!(Header) ) ); } - test_field_ExceptionRecord(); - fn test_field_ContextRecord() { + test_field_Header(); + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_POINTERS>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_CALLBACK_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ContextRecord) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(_ACCESS_ALLOWED_CALLBACK_ACE), + "::", + stringify!(Mask) + ) + ); + } + test_field_Mask(); + fn test_field_SidStart() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_CALLBACK_ACE>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_EXCEPTION_POINTERS), + stringify!(_ACCESS_ALLOWED_CALLBACK_ACE), "::", - stringify!(ContextRecord) + stringify!(SidStart) ) ); } - test_field_ContextRecord(); + test_field_SidStart(); } -pub type EXCEPTION_POINTERS = _EXCEPTION_POINTERS; -pub type PEXCEPTION_POINTERS = *mut _EXCEPTION_POINTERS; -pub type PACCESS_TOKEN = PVOID; -pub type PSECURITY_DESCRIPTOR = PVOID; -pub type PSID = PVOID; -pub type PCLAIMS_BLOB = PVOID; -pub type ACCESS_MASK = DWORD; -pub type PACCESS_MASK = *mut ACCESS_MASK; +pub type ACCESS_ALLOWED_CALLBACK_ACE = _ACCESS_ALLOWED_CALLBACK_ACE; +pub type PACCESS_ALLOWED_CALLBACK_ACE = *mut _ACCESS_ALLOWED_CALLBACK_ACE; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _GENERIC_MAPPING { - pub GenericRead: ACCESS_MASK, - pub GenericWrite: ACCESS_MASK, - pub GenericExecute: ACCESS_MASK, - pub GenericAll: ACCESS_MASK, +pub struct _ACCESS_DENIED_CALLBACK_ACE { + pub Header: ACE_HEADER, + pub Mask: ACCESS_MASK, + pub SidStart: DWORD, } #[test] -fn bindgen_test_layout__GENERIC_MAPPING() { +fn bindgen_test_layout__ACCESS_DENIED_CALLBACK_ACE() { assert_eq!( - ::std::mem::size_of::<_GENERIC_MAPPING>(), - 16usize, - concat!("Size of: ", stringify!(_GENERIC_MAPPING)) + ::std::mem::size_of::<_ACCESS_DENIED_CALLBACK_ACE>(), + 12usize, + concat!("Size of: ", stringify!(_ACCESS_DENIED_CALLBACK_ACE)) ); assert_eq!( - ::std::mem::align_of::<_GENERIC_MAPPING>(), + ::std::mem::align_of::<_ACCESS_DENIED_CALLBACK_ACE>(), 4usize, - concat!("Alignment of ", stringify!(_GENERIC_MAPPING)) + concat!("Alignment of ", stringify!(_ACCESS_DENIED_CALLBACK_ACE)) ); - fn test_field_GenericRead() { + fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_GENERIC_MAPPING>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_CALLBACK_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).GenericRead) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_GENERIC_MAPPING), + stringify!(_ACCESS_DENIED_CALLBACK_ACE), "::", - stringify!(GenericRead) + stringify!(Header) ) ); } - test_field_GenericRead(); - fn test_field_GenericWrite() { + test_field_Header(); + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_GENERIC_MAPPING>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_CALLBACK_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).GenericWrite) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", - stringify!(_GENERIC_MAPPING), + stringify!(_ACCESS_DENIED_CALLBACK_ACE), "::", - stringify!(GenericWrite) + stringify!(Mask) ) ); } - test_field_GenericWrite(); - fn test_field_GenericExecute() { + test_field_Mask(); + fn test_field_SidStart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_GENERIC_MAPPING>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_CALLBACK_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).GenericExecute) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_GENERIC_MAPPING), - "::", - stringify!(GenericExecute) - ) - ); - } - test_field_GenericExecute(); - fn test_field_GenericAll() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_GENERIC_MAPPING>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).GenericAll) as usize - ptr as usize - }, - 12usize, - concat!( - "Offset of field: ", - stringify!(_GENERIC_MAPPING), + stringify!(_ACCESS_DENIED_CALLBACK_ACE), "::", - stringify!(GenericAll) + stringify!(SidStart) ) ); } - test_field_GenericAll(); + test_field_SidStart(); } -pub type GENERIC_MAPPING = _GENERIC_MAPPING; -pub type PGENERIC_MAPPING = *mut GENERIC_MAPPING; +pub type ACCESS_DENIED_CALLBACK_ACE = _ACCESS_DENIED_CALLBACK_ACE; +pub type PACCESS_DENIED_CALLBACK_ACE = *mut _ACCESS_DENIED_CALLBACK_ACE; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _LUID_AND_ATTRIBUTES { - pub Luid: LUID, - pub Attributes: DWORD, +pub struct _SYSTEM_AUDIT_CALLBACK_ACE { + pub Header: ACE_HEADER, + pub Mask: ACCESS_MASK, + pub SidStart: DWORD, } #[test] -fn bindgen_test_layout__LUID_AND_ATTRIBUTES() { +fn bindgen_test_layout__SYSTEM_AUDIT_CALLBACK_ACE() { assert_eq!( - ::std::mem::size_of::<_LUID_AND_ATTRIBUTES>(), + ::std::mem::size_of::<_SYSTEM_AUDIT_CALLBACK_ACE>(), 12usize, - concat!("Size of: ", stringify!(_LUID_AND_ATTRIBUTES)) + concat!("Size of: ", stringify!(_SYSTEM_AUDIT_CALLBACK_ACE)) ); assert_eq!( - ::std::mem::align_of::<_LUID_AND_ATTRIBUTES>(), + ::std::mem::align_of::<_SYSTEM_AUDIT_CALLBACK_ACE>(), 4usize, - concat!("Alignment of ", stringify!(_LUID_AND_ATTRIBUTES)) + concat!("Alignment of ", stringify!(_SYSTEM_AUDIT_CALLBACK_ACE)) ); - fn test_field_Luid() { + fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_LUID_AND_ATTRIBUTES>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_CALLBACK_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Luid) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_LUID_AND_ATTRIBUTES), + stringify!(_SYSTEM_AUDIT_CALLBACK_ACE), "::", - stringify!(Luid) + stringify!(Header) ) ); } - test_field_Luid(); - fn test_field_Attributes() { + test_field_Header(); + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_LUID_AND_ATTRIBUTES>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_CALLBACK_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Attributes) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, - 8usize, + 4usize, concat!( "Offset of field: ", - stringify!(_LUID_AND_ATTRIBUTES), + stringify!(_SYSTEM_AUDIT_CALLBACK_ACE), "::", - stringify!(Attributes) + stringify!(Mask) ) ); } - test_field_Attributes(); -} -pub type LUID_AND_ATTRIBUTES = _LUID_AND_ATTRIBUTES; -pub type PLUID_AND_ATTRIBUTES = *mut _LUID_AND_ATTRIBUTES; -pub type LUID_AND_ATTRIBUTES_ARRAY = [LUID_AND_ATTRIBUTES; 1usize]; -pub type PLUID_AND_ATTRIBUTES_ARRAY = *mut LUID_AND_ATTRIBUTES_ARRAY; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SID_IDENTIFIER_AUTHORITY { - pub Value: [BYTE; 6usize], -} -#[test] -fn bindgen_test_layout__SID_IDENTIFIER_AUTHORITY() { - assert_eq!( - ::std::mem::size_of::<_SID_IDENTIFIER_AUTHORITY>(), - 6usize, - concat!("Size of: ", stringify!(_SID_IDENTIFIER_AUTHORITY)) - ); - assert_eq!( - ::std::mem::align_of::<_SID_IDENTIFIER_AUTHORITY>(), - 1usize, - concat!("Alignment of ", stringify!(_SID_IDENTIFIER_AUTHORITY)) - ); - fn test_field_Value() { + test_field_Mask(); + fn test_field_SidStart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SID_IDENTIFIER_AUTHORITY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_CALLBACK_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Value) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, - 0usize, + 8usize, concat!( "Offset of field: ", - stringify!(_SID_IDENTIFIER_AUTHORITY), + stringify!(_SYSTEM_AUDIT_CALLBACK_ACE), "::", - stringify!(Value) + stringify!(SidStart) ) ); } - test_field_Value(); + test_field_SidStart(); } -pub type SID_IDENTIFIER_AUTHORITY = _SID_IDENTIFIER_AUTHORITY; -pub type PSID_IDENTIFIER_AUTHORITY = *mut _SID_IDENTIFIER_AUTHORITY; +pub type SYSTEM_AUDIT_CALLBACK_ACE = _SYSTEM_AUDIT_CALLBACK_ACE; +pub type PSYSTEM_AUDIT_CALLBACK_ACE = *mut _SYSTEM_AUDIT_CALLBACK_ACE; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _SID { - pub Revision: BYTE, - pub SubAuthorityCount: BYTE, - pub IdentifierAuthority: SID_IDENTIFIER_AUTHORITY, - pub SubAuthority: [DWORD; 1usize], +pub struct _SYSTEM_ALARM_CALLBACK_ACE { + pub Header: ACE_HEADER, + pub Mask: ACCESS_MASK, + pub SidStart: DWORD, } #[test] -fn bindgen_test_layout__SID() { +fn bindgen_test_layout__SYSTEM_ALARM_CALLBACK_ACE() { assert_eq!( - ::std::mem::size_of::<_SID>(), + ::std::mem::size_of::<_SYSTEM_ALARM_CALLBACK_ACE>(), 12usize, - concat!("Size of: ", stringify!(_SID)) + concat!("Size of: ", stringify!(_SYSTEM_ALARM_CALLBACK_ACE)) ); assert_eq!( - ::std::mem::align_of::<_SID>(), + ::std::mem::align_of::<_SYSTEM_ALARM_CALLBACK_ACE>(), 4usize, - concat!("Alignment of ", stringify!(_SID)) + concat!("Alignment of ", stringify!(_SYSTEM_ALARM_CALLBACK_ACE)) ); - fn test_field_Revision() { + fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SID>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_CALLBACK_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Revision) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_SID), - "::", - stringify!(Revision) - ) - ); - } - test_field_Revision(); - fn test_field_SubAuthorityCount() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_SID>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SubAuthorityCount) as usize - ptr as usize - }, - 1usize, - concat!( - "Offset of field: ", - stringify!(_SID), + stringify!(_SYSTEM_ALARM_CALLBACK_ACE), "::", - stringify!(SubAuthorityCount) + stringify!(Header) ) ); } - test_field_SubAuthorityCount(); - fn test_field_IdentifierAuthority() { + test_field_Header(); + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SID>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_CALLBACK_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).IdentifierAuthority) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, - 2usize, + 4usize, concat!( "Offset of field: ", - stringify!(_SID), + stringify!(_SYSTEM_ALARM_CALLBACK_ACE), "::", - stringify!(IdentifierAuthority) + stringify!(Mask) ) ); } - test_field_IdentifierAuthority(); - fn test_field_SubAuthority() { + test_field_Mask(); + fn test_field_SidStart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SID>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_CALLBACK_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SubAuthority) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_SID), + stringify!(_SYSTEM_ALARM_CALLBACK_ACE), "::", - stringify!(SubAuthority) + stringify!(SidStart) ) ); } - test_field_SubAuthority(); + test_field_SidStart(); } -pub type SID = _SID; -pub type PISID = *mut _SID; +pub type SYSTEM_ALARM_CALLBACK_ACE = _SYSTEM_ALARM_CALLBACK_ACE; +pub type PSYSTEM_ALARM_CALLBACK_ACE = *mut _SYSTEM_ALARM_CALLBACK_ACE; #[repr(C)] -#[derive(Copy, Clone)] -pub union _SE_SID { - pub Sid: SID, - pub Buffer: [BYTE; 68usize], +#[derive(Debug, Copy, Clone)] +pub struct _ACCESS_ALLOWED_CALLBACK_OBJECT_ACE { + pub Header: ACE_HEADER, + pub Mask: ACCESS_MASK, + pub Flags: DWORD, + pub ObjectType: GUID, + pub InheritedObjectType: GUID, + pub SidStart: DWORD, } #[test] -fn bindgen_test_layout__SE_SID() { +fn bindgen_test_layout__ACCESS_ALLOWED_CALLBACK_OBJECT_ACE() { assert_eq!( - ::std::mem::size_of::<_SE_SID>(), - 68usize, - concat!("Size of: ", stringify!(_SE_SID)) + ::std::mem::size_of::<_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE>(), + 48usize, + concat!("Size of: ", stringify!(_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE)) ); assert_eq!( - ::std::mem::align_of::<_SE_SID>(), + ::std::mem::align_of::<_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE>(), 4usize, - concat!("Alignment of ", stringify!(_SE_SID)) + concat!( + "Alignment of ", + stringify!(_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE) + ) ); - fn test_field_Sid() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_SID>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Sid) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_SE_SID), - "::", - stringify!(Sid) - ) - ); - } - test_field_Sid(); - fn test_field_Buffer() { + fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_SID>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Buffer) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_SE_SID), + stringify!(_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE), "::", - stringify!(Buffer) + stringify!(Header) ) ); } - test_field_Buffer(); -} -pub type SE_SID = _SE_SID; -pub type PSE_SID = *mut _SE_SID; -#[repr(i32)] -#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] -pub enum _SID_NAME_USE { - SidTypeUser = 1, - SidTypeGroup = 2, - SidTypeDomain = 3, - SidTypeAlias = 4, - SidTypeWellKnownGroup = 5, - SidTypeDeletedAccount = 6, - SidTypeInvalid = 7, - SidTypeUnknown = 8, - SidTypeComputer = 9, - SidTypeLabel = 10, - SidTypeLogonSession = 11, -} -pub use self::_SID_NAME_USE as SID_NAME_USE; -pub type PSID_NAME_USE = *mut _SID_NAME_USE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SID_AND_ATTRIBUTES { - pub Sid: PSID, - pub Attributes: DWORD, -} -#[test] -fn bindgen_test_layout__SID_AND_ATTRIBUTES() { - assert_eq!( - ::std::mem::size_of::<_SID_AND_ATTRIBUTES>(), - 16usize, - concat!("Size of: ", stringify!(_SID_AND_ATTRIBUTES)) - ); - assert_eq!( - ::std::mem::align_of::<_SID_AND_ATTRIBUTES>(), - 8usize, - concat!("Alignment of ", stringify!(_SID_AND_ATTRIBUTES)) - ); - fn test_field_Sid() { + test_field_Header(); + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SID_AND_ATTRIBUTES>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Sid) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, - 0usize, + 4usize, concat!( "Offset of field: ", - stringify!(_SID_AND_ATTRIBUTES), + stringify!(_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE), "::", - stringify!(Sid) + stringify!(Mask) ) ); } - test_field_Sid(); - fn test_field_Attributes() { + test_field_Mask(); + fn test_field_Flags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SID_AND_ATTRIBUTES>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Attributes) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_SID_AND_ATTRIBUTES), + stringify!(_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE), "::", - stringify!(Attributes) + stringify!(Flags) ) ); } - test_field_Attributes(); -} -pub type SID_AND_ATTRIBUTES = _SID_AND_ATTRIBUTES; -pub type PSID_AND_ATTRIBUTES = *mut _SID_AND_ATTRIBUTES; -pub type SID_AND_ATTRIBUTES_ARRAY = [SID_AND_ATTRIBUTES; 1usize]; -pub type PSID_AND_ATTRIBUTES_ARRAY = *mut SID_AND_ATTRIBUTES_ARRAY; -pub type SID_HASH_ENTRY = ULONG_PTR; -pub type PSID_HASH_ENTRY = *mut ULONG_PTR; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SID_AND_ATTRIBUTES_HASH { - pub SidCount: DWORD, - pub SidAttr: PSID_AND_ATTRIBUTES, - pub Hash: [SID_HASH_ENTRY; 32usize], -} -#[test] -fn bindgen_test_layout__SID_AND_ATTRIBUTES_HASH() { - assert_eq!( - ::std::mem::size_of::<_SID_AND_ATTRIBUTES_HASH>(), - 272usize, - concat!("Size of: ", stringify!(_SID_AND_ATTRIBUTES_HASH)) - ); - assert_eq!( - ::std::mem::align_of::<_SID_AND_ATTRIBUTES_HASH>(), - 8usize, - concat!("Alignment of ", stringify!(_SID_AND_ATTRIBUTES_HASH)) - ); - fn test_field_SidCount() { + test_field_Flags(); + fn test_field_ObjectType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SID_AND_ATTRIBUTES_HASH>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidCount) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ObjectType) as usize - ptr as usize }, - 0usize, + 12usize, concat!( "Offset of field: ", - stringify!(_SID_AND_ATTRIBUTES_HASH), + stringify!(_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE), "::", - stringify!(SidCount) + stringify!(ObjectType) ) ); } - test_field_SidCount(); - fn test_field_SidAttr() { + test_field_ObjectType(); + fn test_field_InheritedObjectType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SID_AND_ATTRIBUTES_HASH>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidAttr) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).InheritedObjectType) as usize - ptr as usize }, - 8usize, + 28usize, concat!( "Offset of field: ", - stringify!(_SID_AND_ATTRIBUTES_HASH), + stringify!(_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE), "::", - stringify!(SidAttr) + stringify!(InheritedObjectType) ) ); } - test_field_SidAttr(); - fn test_field_Hash() { + test_field_InheritedObjectType(); + fn test_field_SidStart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SID_AND_ATTRIBUTES_HASH>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Hash) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, - 16usize, + 44usize, concat!( "Offset of field: ", - stringify!(_SID_AND_ATTRIBUTES_HASH), + stringify!(_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE), "::", - stringify!(Hash) + stringify!(SidStart) ) ); } - test_field_Hash(); -} -pub type SID_AND_ATTRIBUTES_HASH = _SID_AND_ATTRIBUTES_HASH; -pub type PSID_AND_ATTRIBUTES_HASH = *mut _SID_AND_ATTRIBUTES_HASH; -#[repr(i32)] -#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] -pub enum WELL_KNOWN_SID_TYPE { - WinNullSid = 0, - WinWorldSid = 1, - WinLocalSid = 2, - WinCreatorOwnerSid = 3, - WinCreatorGroupSid = 4, - WinCreatorOwnerServerSid = 5, - WinCreatorGroupServerSid = 6, - WinNtAuthoritySid = 7, - WinDialupSid = 8, - WinNetworkSid = 9, - WinBatchSid = 10, - WinInteractiveSid = 11, - WinServiceSid = 12, - WinAnonymousSid = 13, - WinProxySid = 14, - WinEnterpriseControllersSid = 15, - WinSelfSid = 16, - WinAuthenticatedUserSid = 17, - WinRestrictedCodeSid = 18, - WinTerminalServerSid = 19, - WinRemoteLogonIdSid = 20, - WinLogonIdsSid = 21, - WinLocalSystemSid = 22, - WinLocalServiceSid = 23, - WinNetworkServiceSid = 24, - WinBuiltinDomainSid = 25, - WinBuiltinAdministratorsSid = 26, - WinBuiltinUsersSid = 27, - WinBuiltinGuestsSid = 28, - WinBuiltinPowerUsersSid = 29, - WinBuiltinAccountOperatorsSid = 30, - WinBuiltinSystemOperatorsSid = 31, - WinBuiltinPrintOperatorsSid = 32, - WinBuiltinBackupOperatorsSid = 33, - WinBuiltinReplicatorSid = 34, - WinBuiltinPreWindows2000CompatibleAccessSid = 35, - WinBuiltinRemoteDesktopUsersSid = 36, - WinBuiltinNetworkConfigurationOperatorsSid = 37, - WinAccountAdministratorSid = 38, - WinAccountGuestSid = 39, - WinAccountKrbtgtSid = 40, - WinAccountDomainAdminsSid = 41, - WinAccountDomainUsersSid = 42, - WinAccountDomainGuestsSid = 43, - WinAccountComputersSid = 44, - WinAccountControllersSid = 45, - WinAccountCertAdminsSid = 46, - WinAccountSchemaAdminsSid = 47, - WinAccountEnterpriseAdminsSid = 48, - WinAccountPolicyAdminsSid = 49, - WinAccountRasAndIasServersSid = 50, - WinNTLMAuthenticationSid = 51, - WinDigestAuthenticationSid = 52, - WinSChannelAuthenticationSid = 53, - WinThisOrganizationSid = 54, - WinOtherOrganizationSid = 55, - WinBuiltinIncomingForestTrustBuildersSid = 56, - WinBuiltinPerfMonitoringUsersSid = 57, - WinBuiltinPerfLoggingUsersSid = 58, - WinBuiltinAuthorizationAccessSid = 59, - WinBuiltinTerminalServerLicenseServersSid = 60, - WinBuiltinDCOMUsersSid = 61, - WinBuiltinIUsersSid = 62, - WinIUserSid = 63, - WinBuiltinCryptoOperatorsSid = 64, - WinUntrustedLabelSid = 65, - WinLowLabelSid = 66, - WinMediumLabelSid = 67, - WinHighLabelSid = 68, - WinSystemLabelSid = 69, - WinWriteRestrictedCodeSid = 70, - WinCreatorOwnerRightsSid = 71, - WinCacheablePrincipalsGroupSid = 72, - WinNonCacheablePrincipalsGroupSid = 73, - WinEnterpriseReadonlyControllersSid = 74, - WinAccountReadonlyControllersSid = 75, - WinBuiltinEventLogReadersGroup = 76, - WinNewEnterpriseReadonlyControllersSid = 77, - WinBuiltinCertSvcDComAccessGroup = 78, - WinMediumPlusLabelSid = 79, - WinLocalLogonSid = 80, - WinConsoleLogonSid = 81, - WinThisOrganizationCertificateSid = 82, - WinApplicationPackageAuthoritySid = 83, - WinBuiltinAnyPackageSid = 84, - WinCapabilityInternetClientSid = 85, - WinCapabilityInternetClientServerSid = 86, - WinCapabilityPrivateNetworkClientServerSid = 87, - WinCapabilityPicturesLibrarySid = 88, - WinCapabilityVideosLibrarySid = 89, - WinCapabilityMusicLibrarySid = 90, - WinCapabilityDocumentsLibrarySid = 91, - WinCapabilitySharedUserCertificatesSid = 92, - WinCapabilityEnterpriseAuthenticationSid = 93, - WinCapabilityRemovableStorageSid = 94, - WinBuiltinRDSRemoteAccessServersSid = 95, - WinBuiltinRDSEndpointServersSid = 96, - WinBuiltinRDSManagementServersSid = 97, - WinUserModeDriversSid = 98, - WinBuiltinHyperVAdminsSid = 99, - WinAccountCloneableControllersSid = 100, - WinBuiltinAccessControlAssistanceOperatorsSid = 101, - WinBuiltinRemoteManagementUsersSid = 102, - WinAuthenticationAuthorityAssertedSid = 103, - WinAuthenticationServiceAssertedSid = 104, - WinLocalAccountSid = 105, - WinLocalAccountAndAdministratorSid = 106, - WinAccountProtectedUsersSid = 107, - WinCapabilityAppointmentsSid = 108, - WinCapabilityContactsSid = 109, - WinAccountDefaultSystemManagedSid = 110, - WinBuiltinDefaultSystemManagedGroupSid = 111, - WinBuiltinStorageReplicaAdminsSid = 112, - WinAccountKeyAdminsSid = 113, - WinAccountEnterpriseKeyAdminsSid = 114, - WinAuthenticationKeyTrustSid = 115, - WinAuthenticationKeyPropertyMFASid = 116, - WinAuthenticationKeyPropertyAttestationSid = 117, - WinAuthenticationFreshKeyAuthSid = 118, - WinBuiltinDeviceOwnersSid = 119, + test_field_SidStart(); } +pub type ACCESS_ALLOWED_CALLBACK_OBJECT_ACE = _ACCESS_ALLOWED_CALLBACK_OBJECT_ACE; +pub type PACCESS_ALLOWED_CALLBACK_OBJECT_ACE = *mut _ACCESS_ALLOWED_CALLBACK_OBJECT_ACE; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _ACL { - pub AclRevision: BYTE, - pub Sbz1: BYTE, - pub AclSize: WORD, - pub AceCount: WORD, - pub Sbz2: WORD, +pub struct _ACCESS_DENIED_CALLBACK_OBJECT_ACE { + pub Header: ACE_HEADER, + pub Mask: ACCESS_MASK, + pub Flags: DWORD, + pub ObjectType: GUID, + pub InheritedObjectType: GUID, + pub SidStart: DWORD, } #[test] -fn bindgen_test_layout__ACL() { +fn bindgen_test_layout__ACCESS_DENIED_CALLBACK_OBJECT_ACE() { assert_eq!( - ::std::mem::size_of::<_ACL>(), - 8usize, - concat!("Size of: ", stringify!(_ACL)) + ::std::mem::size_of::<_ACCESS_DENIED_CALLBACK_OBJECT_ACE>(), + 48usize, + concat!("Size of: ", stringify!(_ACCESS_DENIED_CALLBACK_OBJECT_ACE)) ); assert_eq!( - ::std::mem::align_of::<_ACL>(), - 2usize, - concat!("Alignment of ", stringify!(_ACL)) + ::std::mem::align_of::<_ACCESS_DENIED_CALLBACK_OBJECT_ACE>(), + 4usize, + concat!( + "Alignment of ", + stringify!(_ACCESS_DENIED_CALLBACK_OBJECT_ACE) + ) ); - fn test_field_AclRevision() { + fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACL>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_ACCESS_DENIED_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AclRevision) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_ACL), - "::", - stringify!(AclRevision) - ) - ); - } - test_field_AclRevision(); - fn test_field_Sbz1() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACL>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Sbz1) as usize - ptr as usize - }, - 1usize, - concat!( - "Offset of field: ", - stringify!(_ACL), - "::", - stringify!(Sbz1) - ) - ); - } - test_field_Sbz1(); - fn test_field_AclSize() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACL>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AclSize) as usize - ptr as usize - }, - 2usize, - concat!( - "Offset of field: ", - stringify!(_ACL), + stringify!(_ACCESS_DENIED_CALLBACK_OBJECT_ACE), "::", - stringify!(AclSize) + stringify!(Header) ) ); } - test_field_AclSize(); - fn test_field_AceCount() { + test_field_Header(); + fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACL>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_ACCESS_DENIED_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AceCount) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", - stringify!(_ACL), + stringify!(_ACCESS_DENIED_CALLBACK_OBJECT_ACE), "::", - stringify!(AceCount) + stringify!(Mask) ) ); } - test_field_AceCount(); - fn test_field_Sbz2() { + test_field_Mask(); + fn test_field_Flags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACL>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_ACCESS_DENIED_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Sbz2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, - 6usize, + 8usize, concat!( "Offset of field: ", - stringify!(_ACL), + stringify!(_ACCESS_DENIED_CALLBACK_OBJECT_ACE), "::", - stringify!(Sbz2) + stringify!(Flags) ) ); } - test_field_Sbz2(); -} -pub type ACL = _ACL; -pub type PACL = *mut ACL; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _ACE_HEADER { - pub AceType: BYTE, - pub AceFlags: BYTE, - pub AceSize: WORD, -} -#[test] -fn bindgen_test_layout__ACE_HEADER() { - assert_eq!( - ::std::mem::size_of::<_ACE_HEADER>(), - 4usize, - concat!("Size of: ", stringify!(_ACE_HEADER)) - ); - assert_eq!( - ::std::mem::align_of::<_ACE_HEADER>(), - 2usize, - concat!("Alignment of ", stringify!(_ACE_HEADER)) - ); - fn test_field_AceType() { + test_field_Flags(); + fn test_field_ObjectType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACE_HEADER>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_ACCESS_DENIED_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AceType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ObjectType) as usize - ptr as usize }, - 0usize, + 12usize, concat!( "Offset of field: ", - stringify!(_ACE_HEADER), + stringify!(_ACCESS_DENIED_CALLBACK_OBJECT_ACE), "::", - stringify!(AceType) + stringify!(ObjectType) ) ); } - test_field_AceType(); - fn test_field_AceFlags() { + test_field_ObjectType(); + fn test_field_InheritedObjectType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACE_HEADER>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_ACCESS_DENIED_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AceFlags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).InheritedObjectType) as usize - ptr as usize }, - 1usize, + 28usize, concat!( "Offset of field: ", - stringify!(_ACE_HEADER), + stringify!(_ACCESS_DENIED_CALLBACK_OBJECT_ACE), "::", - stringify!(AceFlags) + stringify!(InheritedObjectType) ) ); } - test_field_AceFlags(); - fn test_field_AceSize() { + test_field_InheritedObjectType(); + fn test_field_SidStart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACE_HEADER>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_ACCESS_DENIED_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AceSize) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, - 2usize, + 44usize, concat!( "Offset of field: ", - stringify!(_ACE_HEADER), + stringify!(_ACCESS_DENIED_CALLBACK_OBJECT_ACE), "::", - stringify!(AceSize) + stringify!(SidStart) ) ); } - test_field_AceSize(); + test_field_SidStart(); } -pub type ACE_HEADER = _ACE_HEADER; -pub type PACE_HEADER = *mut ACE_HEADER; +pub type ACCESS_DENIED_CALLBACK_OBJECT_ACE = _ACCESS_DENIED_CALLBACK_OBJECT_ACE; +pub type PACCESS_DENIED_CALLBACK_OBJECT_ACE = *mut _ACCESS_DENIED_CALLBACK_OBJECT_ACE; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _ACCESS_ALLOWED_ACE { +pub struct _SYSTEM_AUDIT_CALLBACK_OBJECT_ACE { pub Header: ACE_HEADER, pub Mask: ACCESS_MASK, + pub Flags: DWORD, + pub ObjectType: GUID, + pub InheritedObjectType: GUID, pub SidStart: DWORD, } #[test] -fn bindgen_test_layout__ACCESS_ALLOWED_ACE() { +fn bindgen_test_layout__SYSTEM_AUDIT_CALLBACK_OBJECT_ACE() { assert_eq!( - ::std::mem::size_of::<_ACCESS_ALLOWED_ACE>(), - 12usize, - concat!("Size of: ", stringify!(_ACCESS_ALLOWED_ACE)) + ::std::mem::size_of::<_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE>(), + 48usize, + concat!("Size of: ", stringify!(_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE)) ); assert_eq!( - ::std::mem::align_of::<_ACCESS_ALLOWED_ACE>(), + ::std::mem::align_of::<_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE>(), 4usize, - concat!("Alignment of ", stringify!(_ACCESS_ALLOWED_ACE)) + concat!( + "Alignment of ", + stringify!(_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE) + ) ); fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_ACCESS_ALLOWED_ACE), + stringify!(_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE), "::", stringify!(Header) ) @@ -36262,104 +36773,82 @@ fn bindgen_test_layout__ACCESS_ALLOWED_ACE() { fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", - stringify!(_ACCESS_ALLOWED_ACE), + stringify!(_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE), "::", stringify!(Mask) ) ); } test_field_Mask(); - fn test_field_SidStart() { + fn test_field_Flags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_ACCESS_ALLOWED_ACE), + stringify!(_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE), "::", - stringify!(SidStart) + stringify!(Flags) ) ); } - test_field_SidStart(); -} -pub type ACCESS_ALLOWED_ACE = _ACCESS_ALLOWED_ACE; -pub type PACCESS_ALLOWED_ACE = *mut ACCESS_ALLOWED_ACE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _ACCESS_DENIED_ACE { - pub Header: ACE_HEADER, - pub Mask: ACCESS_MASK, - pub SidStart: DWORD, -} -#[test] -fn bindgen_test_layout__ACCESS_DENIED_ACE() { - assert_eq!( - ::std::mem::size_of::<_ACCESS_DENIED_ACE>(), - 12usize, - concat!("Size of: ", stringify!(_ACCESS_DENIED_ACE)) - ); - assert_eq!( - ::std::mem::align_of::<_ACCESS_DENIED_ACE>(), - 4usize, - concat!("Alignment of ", stringify!(_ACCESS_DENIED_ACE)) - ); - fn test_field_Header() { + test_field_Flags(); + fn test_field_ObjectType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ObjectType) as usize - ptr as usize }, - 0usize, + 12usize, concat!( "Offset of field: ", - stringify!(_ACCESS_DENIED_ACE), + stringify!(_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE), "::", - stringify!(Header) + stringify!(ObjectType) ) ); } - test_field_Header(); - fn test_field_Mask() { + test_field_ObjectType(); + fn test_field_InheritedObjectType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).InheritedObjectType) as usize - ptr as usize }, - 4usize, + 28usize, concat!( "Offset of field: ", - stringify!(_ACCESS_DENIED_ACE), + stringify!(_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE), "::", - stringify!(Mask) + stringify!(InheritedObjectType) ) ); } - test_field_Mask(); + test_field_InheritedObjectType(); fn test_field_SidStart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, - 8usize, + 44usize, concat!( "Offset of field: ", - stringify!(_ACCESS_DENIED_ACE), + stringify!(_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE), "::", stringify!(SidStart) ) @@ -36367,38 +36856,44 @@ fn bindgen_test_layout__ACCESS_DENIED_ACE() { } test_field_SidStart(); } -pub type ACCESS_DENIED_ACE = _ACCESS_DENIED_ACE; -pub type PACCESS_DENIED_ACE = *mut ACCESS_DENIED_ACE; +pub type SYSTEM_AUDIT_CALLBACK_OBJECT_ACE = _SYSTEM_AUDIT_CALLBACK_OBJECT_ACE; +pub type PSYSTEM_AUDIT_CALLBACK_OBJECT_ACE = *mut _SYSTEM_AUDIT_CALLBACK_OBJECT_ACE; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _SYSTEM_AUDIT_ACE { +pub struct _SYSTEM_ALARM_CALLBACK_OBJECT_ACE { pub Header: ACE_HEADER, pub Mask: ACCESS_MASK, + pub Flags: DWORD, + pub ObjectType: GUID, + pub InheritedObjectType: GUID, pub SidStart: DWORD, } #[test] -fn bindgen_test_layout__SYSTEM_AUDIT_ACE() { +fn bindgen_test_layout__SYSTEM_ALARM_CALLBACK_OBJECT_ACE() { assert_eq!( - ::std::mem::size_of::<_SYSTEM_AUDIT_ACE>(), - 12usize, - concat!("Size of: ", stringify!(_SYSTEM_AUDIT_ACE)) + ::std::mem::size_of::<_SYSTEM_ALARM_CALLBACK_OBJECT_ACE>(), + 48usize, + concat!("Size of: ", stringify!(_SYSTEM_ALARM_CALLBACK_OBJECT_ACE)) ); assert_eq!( - ::std::mem::align_of::<_SYSTEM_AUDIT_ACE>(), + ::std::mem::align_of::<_SYSTEM_ALARM_CALLBACK_OBJECT_ACE>(), 4usize, - concat!("Alignment of ", stringify!(_SYSTEM_AUDIT_ACE)) + concat!( + "Alignment of ", + stringify!(_SYSTEM_ALARM_CALLBACK_OBJECT_ACE) + ) ); fn test_field_Header() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_AUDIT_ACE), + stringify!(_SYSTEM_ALARM_CALLBACK_OBJECT_ACE), "::", stringify!(Header) ) @@ -36408,104 +36903,82 @@ fn bindgen_test_layout__SYSTEM_AUDIT_ACE() { fn test_field_Mask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_AUDIT_ACE), + stringify!(_SYSTEM_ALARM_CALLBACK_OBJECT_ACE), "::", stringify!(Mask) ) ); } test_field_Mask(); - fn test_field_SidStart() { + fn test_field_Flags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_AUDIT_ACE), + stringify!(_SYSTEM_ALARM_CALLBACK_OBJECT_ACE), "::", - stringify!(SidStart) + stringify!(Flags) ) ); } - test_field_SidStart(); -} -pub type SYSTEM_AUDIT_ACE = _SYSTEM_AUDIT_ACE; -pub type PSYSTEM_AUDIT_ACE = *mut SYSTEM_AUDIT_ACE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SYSTEM_ALARM_ACE { - pub Header: ACE_HEADER, - pub Mask: ACCESS_MASK, - pub SidStart: DWORD, -} -#[test] -fn bindgen_test_layout__SYSTEM_ALARM_ACE() { - assert_eq!( - ::std::mem::size_of::<_SYSTEM_ALARM_ACE>(), - 12usize, - concat!("Size of: ", stringify!(_SYSTEM_ALARM_ACE)) - ); - assert_eq!( - ::std::mem::align_of::<_SYSTEM_ALARM_ACE>(), - 4usize, - concat!("Alignment of ", stringify!(_SYSTEM_ALARM_ACE)) - ); - fn test_field_Header() { + test_field_Flags(); + fn test_field_ObjectType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ObjectType) as usize - ptr as usize }, - 0usize, + 12usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ALARM_ACE), + stringify!(_SYSTEM_ALARM_CALLBACK_OBJECT_ACE), "::", - stringify!(Header) + stringify!(ObjectType) ) ); } - test_field_Header(); - fn test_field_Mask() { + test_field_ObjectType(); + fn test_field_InheritedObjectType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).InheritedObjectType) as usize - ptr as usize }, - 4usize, + 28usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ALARM_ACE), + stringify!(_SYSTEM_ALARM_CALLBACK_OBJECT_ACE), "::", - stringify!(Mask) + stringify!(InheritedObjectType) ) ); } - test_field_Mask(); + test_field_InheritedObjectType(); fn test_field_SidStart() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_CALLBACK_OBJECT_ACE>::uninit(); let ptr = uninit.as_ptr(); ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize }, - 8usize, + 44usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ALARM_ACE), + stringify!(_SYSTEM_ALARM_CALLBACK_OBJECT_ACE), "::", stringify!(SidStart) ) @@ -36513,6362 +36986,6200 @@ fn bindgen_test_layout__SYSTEM_ALARM_ACE() { } test_field_SidStart(); } -pub type SYSTEM_ALARM_ACE = _SYSTEM_ALARM_ACE; -pub type PSYSTEM_ALARM_ACE = *mut SYSTEM_ALARM_ACE; +pub type SYSTEM_ALARM_CALLBACK_OBJECT_ACE = _SYSTEM_ALARM_CALLBACK_OBJECT_ACE; +pub type PSYSTEM_ALARM_CALLBACK_OBJECT_ACE = *mut _SYSTEM_ALARM_CALLBACK_OBJECT_ACE; +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _ACL_INFORMATION_CLASS { + AclRevisionInformation = 1, + AclSizeInformation = 2, +} +pub use self::_ACL_INFORMATION_CLASS as ACL_INFORMATION_CLASS; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _SYSTEM_RESOURCE_ATTRIBUTE_ACE { - pub Header: ACE_HEADER, - pub Mask: ACCESS_MASK, - pub SidStart: DWORD, +pub struct _ACL_REVISION_INFORMATION { + pub AclRevision: DWORD, } #[test] -fn bindgen_test_layout__SYSTEM_RESOURCE_ATTRIBUTE_ACE() { +fn bindgen_test_layout__ACL_REVISION_INFORMATION() { assert_eq!( - ::std::mem::size_of::<_SYSTEM_RESOURCE_ATTRIBUTE_ACE>(), - 12usize, - concat!("Size of: ", stringify!(_SYSTEM_RESOURCE_ATTRIBUTE_ACE)) + ::std::mem::size_of::<_ACL_REVISION_INFORMATION>(), + 4usize, + concat!("Size of: ", stringify!(_ACL_REVISION_INFORMATION)) ); assert_eq!( - ::std::mem::align_of::<_SYSTEM_RESOURCE_ATTRIBUTE_ACE>(), + ::std::mem::align_of::<_ACL_REVISION_INFORMATION>(), 4usize, - concat!("Alignment of ", stringify!(_SYSTEM_RESOURCE_ATTRIBUTE_ACE)) + concat!("Alignment of ", stringify!(_ACL_REVISION_INFORMATION)) ); - fn test_field_Header() { + fn test_field_AclRevision() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_RESOURCE_ATTRIBUTE_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACL_REVISION_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AclRevision) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_RESOURCE_ATTRIBUTE_ACE), - "::", - stringify!(Header) - ) - ); - } - test_field_Header(); - fn test_field_Mask() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_RESOURCE_ATTRIBUTE_ACE>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(_SYSTEM_RESOURCE_ATTRIBUTE_ACE), - "::", - stringify!(Mask) - ) - ); - } - test_field_Mask(); - fn test_field_SidStart() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_RESOURCE_ATTRIBUTE_ACE>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(_SYSTEM_RESOURCE_ATTRIBUTE_ACE), + stringify!(_ACL_REVISION_INFORMATION), "::", - stringify!(SidStart) + stringify!(AclRevision) ) ); } - test_field_SidStart(); + test_field_AclRevision(); } -pub type SYSTEM_RESOURCE_ATTRIBUTE_ACE = _SYSTEM_RESOURCE_ATTRIBUTE_ACE; -pub type PSYSTEM_RESOURCE_ATTRIBUTE_ACE = *mut _SYSTEM_RESOURCE_ATTRIBUTE_ACE; +pub type ACL_REVISION_INFORMATION = _ACL_REVISION_INFORMATION; +pub type PACL_REVISION_INFORMATION = *mut ACL_REVISION_INFORMATION; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _SYSTEM_SCOPED_POLICY_ID_ACE { - pub Header: ACE_HEADER, - pub Mask: ACCESS_MASK, - pub SidStart: DWORD, +pub struct _ACL_SIZE_INFORMATION { + pub AceCount: DWORD, + pub AclBytesInUse: DWORD, + pub AclBytesFree: DWORD, } #[test] -fn bindgen_test_layout__SYSTEM_SCOPED_POLICY_ID_ACE() { +fn bindgen_test_layout__ACL_SIZE_INFORMATION() { assert_eq!( - ::std::mem::size_of::<_SYSTEM_SCOPED_POLICY_ID_ACE>(), + ::std::mem::size_of::<_ACL_SIZE_INFORMATION>(), 12usize, - concat!("Size of: ", stringify!(_SYSTEM_SCOPED_POLICY_ID_ACE)) + concat!("Size of: ", stringify!(_ACL_SIZE_INFORMATION)) ); assert_eq!( - ::std::mem::align_of::<_SYSTEM_SCOPED_POLICY_ID_ACE>(), + ::std::mem::align_of::<_ACL_SIZE_INFORMATION>(), 4usize, - concat!("Alignment of ", stringify!(_SYSTEM_SCOPED_POLICY_ID_ACE)) + concat!("Alignment of ", stringify!(_ACL_SIZE_INFORMATION)) ); - fn test_field_Header() { + fn test_field_AceCount() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_SCOPED_POLICY_ID_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACL_SIZE_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AceCount) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_SCOPED_POLICY_ID_ACE), + stringify!(_ACL_SIZE_INFORMATION), "::", - stringify!(Header) + stringify!(AceCount) ) ); } - test_field_Header(); - fn test_field_Mask() { + test_field_AceCount(); + fn test_field_AclBytesInUse() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_SCOPED_POLICY_ID_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACL_SIZE_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AclBytesInUse) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_SCOPED_POLICY_ID_ACE), + stringify!(_ACL_SIZE_INFORMATION), "::", - stringify!(Mask) + stringify!(AclBytesInUse) ) ); } - test_field_Mask(); - fn test_field_SidStart() { + test_field_AclBytesInUse(); + fn test_field_AclBytesFree() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_SCOPED_POLICY_ID_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACL_SIZE_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AclBytesFree) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_SCOPED_POLICY_ID_ACE), + stringify!(_ACL_SIZE_INFORMATION), "::", - stringify!(SidStart) + stringify!(AclBytesFree) ) ); } - test_field_SidStart(); + test_field_AclBytesFree(); } -pub type SYSTEM_SCOPED_POLICY_ID_ACE = _SYSTEM_SCOPED_POLICY_ID_ACE; -pub type PSYSTEM_SCOPED_POLICY_ID_ACE = *mut _SYSTEM_SCOPED_POLICY_ID_ACE; +pub type ACL_SIZE_INFORMATION = _ACL_SIZE_INFORMATION; +pub type PACL_SIZE_INFORMATION = *mut ACL_SIZE_INFORMATION; +pub type SECURITY_DESCRIPTOR_CONTROL = WORD; +pub type PSECURITY_DESCRIPTOR_CONTROL = *mut WORD; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _SYSTEM_MANDATORY_LABEL_ACE { - pub Header: ACE_HEADER, - pub Mask: ACCESS_MASK, - pub SidStart: DWORD, +pub struct _SECURITY_DESCRIPTOR_RELATIVE { + pub Revision: BYTE, + pub Sbz1: BYTE, + pub Control: SECURITY_DESCRIPTOR_CONTROL, + pub Owner: DWORD, + pub Group: DWORD, + pub Sacl: DWORD, + pub Dacl: DWORD, } #[test] -fn bindgen_test_layout__SYSTEM_MANDATORY_LABEL_ACE() { +fn bindgen_test_layout__SECURITY_DESCRIPTOR_RELATIVE() { assert_eq!( - ::std::mem::size_of::<_SYSTEM_MANDATORY_LABEL_ACE>(), - 12usize, - concat!("Size of: ", stringify!(_SYSTEM_MANDATORY_LABEL_ACE)) + ::std::mem::size_of::<_SECURITY_DESCRIPTOR_RELATIVE>(), + 20usize, + concat!("Size of: ", stringify!(_SECURITY_DESCRIPTOR_RELATIVE)) ); assert_eq!( - ::std::mem::align_of::<_SYSTEM_MANDATORY_LABEL_ACE>(), + ::std::mem::align_of::<_SECURITY_DESCRIPTOR_RELATIVE>(), 4usize, - concat!("Alignment of ", stringify!(_SYSTEM_MANDATORY_LABEL_ACE)) + concat!("Alignment of ", stringify!(_SECURITY_DESCRIPTOR_RELATIVE)) ); - fn test_field_Header() { + fn test_field_Revision() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_MANDATORY_LABEL_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR_RELATIVE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Revision) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_MANDATORY_LABEL_ACE), + stringify!(_SECURITY_DESCRIPTOR_RELATIVE), "::", - stringify!(Header) + stringify!(Revision) ) ); } - test_field_Header(); - fn test_field_Mask() { + test_field_Revision(); + fn test_field_Sbz1() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_MANDATORY_LABEL_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR_RELATIVE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Sbz1) as usize - ptr as usize }, - 4usize, + 1usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_MANDATORY_LABEL_ACE), + stringify!(_SECURITY_DESCRIPTOR_RELATIVE), "::", - stringify!(Mask) + stringify!(Sbz1) ) ); } - test_field_Mask(); - fn test_field_SidStart() { + test_field_Sbz1(); + fn test_field_Control() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_MANDATORY_LABEL_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR_RELATIVE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Control) as usize - ptr as usize }, - 8usize, + 2usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_MANDATORY_LABEL_ACE), + stringify!(_SECURITY_DESCRIPTOR_RELATIVE), "::", - stringify!(SidStart) + stringify!(Control) ) ); } - test_field_SidStart(); -} -pub type SYSTEM_MANDATORY_LABEL_ACE = _SYSTEM_MANDATORY_LABEL_ACE; -pub type PSYSTEM_MANDATORY_LABEL_ACE = *mut _SYSTEM_MANDATORY_LABEL_ACE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SYSTEM_PROCESS_TRUST_LABEL_ACE { - pub Header: ACE_HEADER, - pub Mask: ACCESS_MASK, - pub SidStart: DWORD, -} -#[test] -fn bindgen_test_layout__SYSTEM_PROCESS_TRUST_LABEL_ACE() { - assert_eq!( - ::std::mem::size_of::<_SYSTEM_PROCESS_TRUST_LABEL_ACE>(), - 12usize, - concat!("Size of: ", stringify!(_SYSTEM_PROCESS_TRUST_LABEL_ACE)) - ); - assert_eq!( - ::std::mem::align_of::<_SYSTEM_PROCESS_TRUST_LABEL_ACE>(), - 4usize, - concat!("Alignment of ", stringify!(_SYSTEM_PROCESS_TRUST_LABEL_ACE)) - ); - fn test_field_Header() { + test_field_Control(); + fn test_field_Owner() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_PROCESS_TRUST_LABEL_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR_RELATIVE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Owner) as usize - ptr as usize }, - 0usize, + 4usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_PROCESS_TRUST_LABEL_ACE), + stringify!(_SECURITY_DESCRIPTOR_RELATIVE), "::", - stringify!(Header) + stringify!(Owner) ) ); } - test_field_Header(); - fn test_field_Mask() { + test_field_Owner(); + fn test_field_Group() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_PROCESS_TRUST_LABEL_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR_RELATIVE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Group) as usize - ptr as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_PROCESS_TRUST_LABEL_ACE), + stringify!(_SECURITY_DESCRIPTOR_RELATIVE), "::", - stringify!(Mask) + stringify!(Group) ) ); } - test_field_Mask(); - fn test_field_SidStart() { + test_field_Group(); + fn test_field_Sacl() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_PROCESS_TRUST_LABEL_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR_RELATIVE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Sacl) as usize - ptr as usize }, - 8usize, + 12usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_PROCESS_TRUST_LABEL_ACE), + stringify!(_SECURITY_DESCRIPTOR_RELATIVE), "::", - stringify!(SidStart) + stringify!(Sacl) ) ); } - test_field_SidStart(); + test_field_Sacl(); + fn test_field_Dacl() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR_RELATIVE>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Dacl) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_SECURITY_DESCRIPTOR_RELATIVE), + "::", + stringify!(Dacl) + ) + ); + } + test_field_Dacl(); } -pub type SYSTEM_PROCESS_TRUST_LABEL_ACE = _SYSTEM_PROCESS_TRUST_LABEL_ACE; -pub type PSYSTEM_PROCESS_TRUST_LABEL_ACE = *mut _SYSTEM_PROCESS_TRUST_LABEL_ACE; +pub type SECURITY_DESCRIPTOR_RELATIVE = _SECURITY_DESCRIPTOR_RELATIVE; +pub type PISECURITY_DESCRIPTOR_RELATIVE = *mut _SECURITY_DESCRIPTOR_RELATIVE; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _SYSTEM_ACCESS_FILTER_ACE { - pub Header: ACE_HEADER, - pub Mask: ACCESS_MASK, - pub SidStart: DWORD, +pub struct _SECURITY_DESCRIPTOR { + pub Revision: BYTE, + pub Sbz1: BYTE, + pub Control: SECURITY_DESCRIPTOR_CONTROL, + pub Owner: PSID, + pub Group: PSID, + pub Sacl: PACL, + pub Dacl: PACL, } #[test] -fn bindgen_test_layout__SYSTEM_ACCESS_FILTER_ACE() { +fn bindgen_test_layout__SECURITY_DESCRIPTOR() { assert_eq!( - ::std::mem::size_of::<_SYSTEM_ACCESS_FILTER_ACE>(), - 12usize, - concat!("Size of: ", stringify!(_SYSTEM_ACCESS_FILTER_ACE)) + ::std::mem::size_of::<_SECURITY_DESCRIPTOR>(), + 40usize, + concat!("Size of: ", stringify!(_SECURITY_DESCRIPTOR)) ); assert_eq!( - ::std::mem::align_of::<_SYSTEM_ACCESS_FILTER_ACE>(), - 4usize, - concat!("Alignment of ", stringify!(_SYSTEM_ACCESS_FILTER_ACE)) + ::std::mem::align_of::<_SECURITY_DESCRIPTOR>(), + 8usize, + concat!("Alignment of ", stringify!(_SECURITY_DESCRIPTOR)) ); - fn test_field_Header() { + fn test_field_Revision() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ACCESS_FILTER_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Revision) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ACCESS_FILTER_ACE), + stringify!(_SECURITY_DESCRIPTOR), "::", - stringify!(Header) + stringify!(Revision) ) ); } - test_field_Header(); - fn test_field_Mask() { + test_field_Revision(); + fn test_field_Sbz1() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ACCESS_FILTER_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Sbz1) as usize - ptr as usize }, - 4usize, + 1usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ACCESS_FILTER_ACE), + stringify!(_SECURITY_DESCRIPTOR), "::", - stringify!(Mask) + stringify!(Sbz1) ) ); } - test_field_Mask(); - fn test_field_SidStart() { + test_field_Sbz1(); + fn test_field_Control() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ACCESS_FILTER_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Control) as usize - ptr as usize }, - 8usize, + 2usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ACCESS_FILTER_ACE), + stringify!(_SECURITY_DESCRIPTOR), "::", - stringify!(SidStart) + stringify!(Control) ) ); } - test_field_SidStart(); -} -pub type SYSTEM_ACCESS_FILTER_ACE = _SYSTEM_ACCESS_FILTER_ACE; -pub type PSYSTEM_ACCESS_FILTER_ACE = *mut _SYSTEM_ACCESS_FILTER_ACE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _ACCESS_ALLOWED_OBJECT_ACE { - pub Header: ACE_HEADER, - pub Mask: ACCESS_MASK, - pub Flags: DWORD, - pub ObjectType: GUID, - pub InheritedObjectType: GUID, - pub SidStart: DWORD, -} -#[test] -fn bindgen_test_layout__ACCESS_ALLOWED_OBJECT_ACE() { - assert_eq!( - ::std::mem::size_of::<_ACCESS_ALLOWED_OBJECT_ACE>(), - 48usize, - concat!("Size of: ", stringify!(_ACCESS_ALLOWED_OBJECT_ACE)) - ); - assert_eq!( - ::std::mem::align_of::<_ACCESS_ALLOWED_OBJECT_ACE>(), - 4usize, - concat!("Alignment of ", stringify!(_ACCESS_ALLOWED_OBJECT_ACE)) - ); - fn test_field_Header() { + test_field_Control(); + fn test_field_Owner() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Owner) as usize - ptr as usize }, - 0usize, + 8usize, concat!( "Offset of field: ", - stringify!(_ACCESS_ALLOWED_OBJECT_ACE), + stringify!(_SECURITY_DESCRIPTOR), "::", - stringify!(Header) + stringify!(Owner) ) ); } - test_field_Header(); - fn test_field_Mask() { + test_field_Owner(); + fn test_field_Group() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Group) as usize - ptr as usize }, - 4usize, + 16usize, concat!( "Offset of field: ", - stringify!(_ACCESS_ALLOWED_OBJECT_ACE), + stringify!(_SECURITY_DESCRIPTOR), "::", - stringify!(Mask) + stringify!(Group) ) ); } - test_field_Mask(); - fn test_field_Flags() { + test_field_Group(); + fn test_field_Sacl() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Sacl) as usize - ptr as usize }, - 8usize, + 24usize, concat!( "Offset of field: ", - stringify!(_ACCESS_ALLOWED_OBJECT_ACE), + stringify!(_SECURITY_DESCRIPTOR), "::", - stringify!(Flags) + stringify!(Sacl) ) ); } - test_field_Flags(); - fn test_field_ObjectType() { + test_field_Sacl(); + fn test_field_Dacl() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ObjectType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Dacl) as usize - ptr as usize }, - 12usize, + 32usize, concat!( "Offset of field: ", - stringify!(_ACCESS_ALLOWED_OBJECT_ACE), + stringify!(_SECURITY_DESCRIPTOR), "::", - stringify!(ObjectType) + stringify!(Dacl) ) ); } - test_field_ObjectType(); - fn test_field_InheritedObjectType() { + test_field_Dacl(); +} +pub type SECURITY_DESCRIPTOR = _SECURITY_DESCRIPTOR; +pub type PISECURITY_DESCRIPTOR = *mut _SECURITY_DESCRIPTOR; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SECURITY_OBJECT_AI_PARAMS { + pub Size: DWORD, + pub ConstraintMask: DWORD, +} +#[test] +fn bindgen_test_layout__SECURITY_OBJECT_AI_PARAMS() { + assert_eq!( + ::std::mem::size_of::<_SECURITY_OBJECT_AI_PARAMS>(), + 8usize, + concat!("Size of: ", stringify!(_SECURITY_OBJECT_AI_PARAMS)) + ); + assert_eq!( + ::std::mem::align_of::<_SECURITY_OBJECT_AI_PARAMS>(), + 4usize, + concat!("Alignment of ", stringify!(_SECURITY_OBJECT_AI_PARAMS)) + ); + fn test_field_Size() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_OBJECT_AI_PARAMS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).InheritedObjectType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Size) as usize - ptr as usize }, - 28usize, + 0usize, concat!( "Offset of field: ", - stringify!(_ACCESS_ALLOWED_OBJECT_ACE), + stringify!(_SECURITY_OBJECT_AI_PARAMS), "::", - stringify!(InheritedObjectType) + stringify!(Size) ) ); } - test_field_InheritedObjectType(); - fn test_field_SidStart() { + test_field_Size(); + fn test_field_ConstraintMask() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_OBJECT_AI_PARAMS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ConstraintMask) as usize - ptr as usize }, - 44usize, + 4usize, concat!( "Offset of field: ", - stringify!(_ACCESS_ALLOWED_OBJECT_ACE), + stringify!(_SECURITY_OBJECT_AI_PARAMS), "::", - stringify!(SidStart) + stringify!(ConstraintMask) ) ); } - test_field_SidStart(); + test_field_ConstraintMask(); } -pub type ACCESS_ALLOWED_OBJECT_ACE = _ACCESS_ALLOWED_OBJECT_ACE; -pub type PACCESS_ALLOWED_OBJECT_ACE = *mut _ACCESS_ALLOWED_OBJECT_ACE; +pub type SECURITY_OBJECT_AI_PARAMS = _SECURITY_OBJECT_AI_PARAMS; +pub type PSECURITY_OBJECT_AI_PARAMS = *mut _SECURITY_OBJECT_AI_PARAMS; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _ACCESS_DENIED_OBJECT_ACE { - pub Header: ACE_HEADER, - pub Mask: ACCESS_MASK, - pub Flags: DWORD, - pub ObjectType: GUID, - pub InheritedObjectType: GUID, - pub SidStart: DWORD, +pub struct _OBJECT_TYPE_LIST { + pub Level: WORD, + pub Sbz: WORD, + pub ObjectType: *mut GUID, } #[test] -fn bindgen_test_layout__ACCESS_DENIED_OBJECT_ACE() { +fn bindgen_test_layout__OBJECT_TYPE_LIST() { assert_eq!( - ::std::mem::size_of::<_ACCESS_DENIED_OBJECT_ACE>(), - 48usize, - concat!("Size of: ", stringify!(_ACCESS_DENIED_OBJECT_ACE)) + ::std::mem::size_of::<_OBJECT_TYPE_LIST>(), + 16usize, + concat!("Size of: ", stringify!(_OBJECT_TYPE_LIST)) ); assert_eq!( - ::std::mem::align_of::<_ACCESS_DENIED_OBJECT_ACE>(), - 4usize, - concat!("Alignment of ", stringify!(_ACCESS_DENIED_OBJECT_ACE)) + ::std::mem::align_of::<_OBJECT_TYPE_LIST>(), + 8usize, + concat!("Alignment of ", stringify!(_OBJECT_TYPE_LIST)) ); - fn test_field_Header() { + fn test_field_Level() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_OBJECT_TYPE_LIST>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Level) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_ACCESS_DENIED_OBJECT_ACE), + stringify!(_OBJECT_TYPE_LIST), "::", - stringify!(Header) + stringify!(Level) ) ); } - test_field_Header(); - fn test_field_Mask() { + test_field_Level(); + fn test_field_Sbz() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_OBJECT_TYPE_LIST>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Sbz) as usize - ptr as usize }, - 4usize, + 2usize, concat!( "Offset of field: ", - stringify!(_ACCESS_DENIED_OBJECT_ACE), + stringify!(_OBJECT_TYPE_LIST), "::", - stringify!(Mask) + stringify!(Sbz) ) ); } - test_field_Mask(); - fn test_field_Flags() { + test_field_Sbz(); + fn test_field_ObjectType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_OBJECT_TYPE_LIST>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ObjectType) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_ACCESS_DENIED_OBJECT_ACE), + stringify!(_OBJECT_TYPE_LIST), "::", - stringify!(Flags) + stringify!(ObjectType) ) ); } - test_field_Flags(); - fn test_field_ObjectType() { + test_field_ObjectType(); +} +pub type OBJECT_TYPE_LIST = _OBJECT_TYPE_LIST; +pub type POBJECT_TYPE_LIST = *mut _OBJECT_TYPE_LIST; +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _AUDIT_EVENT_TYPE { + AuditEventObjectAccess = 0, + AuditEventDirectoryServiceAccess = 1, +} +pub use self::_AUDIT_EVENT_TYPE as AUDIT_EVENT_TYPE; +pub type PAUDIT_EVENT_TYPE = *mut _AUDIT_EVENT_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _PRIVILEGE_SET { + pub PrivilegeCount: DWORD, + pub Control: DWORD, + pub Privilege: [LUID_AND_ATTRIBUTES; 1usize], +} +#[test] +fn bindgen_test_layout__PRIVILEGE_SET() { + assert_eq!( + ::std::mem::size_of::<_PRIVILEGE_SET>(), + 20usize, + concat!("Size of: ", stringify!(_PRIVILEGE_SET)) + ); + assert_eq!( + ::std::mem::align_of::<_PRIVILEGE_SET>(), + 4usize, + concat!("Alignment of ", stringify!(_PRIVILEGE_SET)) + ); + fn test_field_PrivilegeCount() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_PRIVILEGE_SET>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ObjectType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).PrivilegeCount) as usize - ptr as usize }, - 12usize, + 0usize, concat!( "Offset of field: ", - stringify!(_ACCESS_DENIED_OBJECT_ACE), + stringify!(_PRIVILEGE_SET), "::", - stringify!(ObjectType) + stringify!(PrivilegeCount) ) ); } - test_field_ObjectType(); - fn test_field_InheritedObjectType() { + test_field_PrivilegeCount(); + fn test_field_Control() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_PRIVILEGE_SET>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).InheritedObjectType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Control) as usize - ptr as usize }, - 28usize, + 4usize, concat!( "Offset of field: ", - stringify!(_ACCESS_DENIED_OBJECT_ACE), + stringify!(_PRIVILEGE_SET), "::", - stringify!(InheritedObjectType) + stringify!(Control) ) ); } - test_field_InheritedObjectType(); - fn test_field_SidStart() { + test_field_Control(); + fn test_field_Privilege() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_PRIVILEGE_SET>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Privilege) as usize - ptr as usize }, - 44usize, + 8usize, concat!( "Offset of field: ", - stringify!(_ACCESS_DENIED_OBJECT_ACE), + stringify!(_PRIVILEGE_SET), "::", - stringify!(SidStart) + stringify!(Privilege) ) ); } - test_field_SidStart(); + test_field_Privilege(); } -pub type ACCESS_DENIED_OBJECT_ACE = _ACCESS_DENIED_OBJECT_ACE; -pub type PACCESS_DENIED_OBJECT_ACE = *mut _ACCESS_DENIED_OBJECT_ACE; +pub type PRIVILEGE_SET = _PRIVILEGE_SET; +pub type PPRIVILEGE_SET = *mut _PRIVILEGE_SET; +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _ACCESS_REASON_TYPE { + AccessReasonNone = 0, + AccessReasonAllowedAce = 65536, + AccessReasonDeniedAce = 131072, + AccessReasonAllowedParentAce = 196608, + AccessReasonDeniedParentAce = 262144, + AccessReasonNotGrantedByCape = 327680, + AccessReasonNotGrantedByParentCape = 393216, + AccessReasonNotGrantedToAppContainer = 458752, + AccessReasonMissingPrivilege = 1048576, + AccessReasonFromPrivilege = 2097152, + AccessReasonIntegrityLevel = 3145728, + AccessReasonOwnership = 4194304, + AccessReasonNullDacl = 5242880, + AccessReasonEmptyDacl = 6291456, + AccessReasonNoSD = 7340032, + AccessReasonNoGrant = 8388608, + AccessReasonTrustLabel = 9437184, + AccessReasonFilterAce = 10485760, +} +pub use self::_ACCESS_REASON_TYPE as ACCESS_REASON_TYPE; +pub type ACCESS_REASON = DWORD; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _SYSTEM_AUDIT_OBJECT_ACE { - pub Header: ACE_HEADER, - pub Mask: ACCESS_MASK, - pub Flags: DWORD, - pub ObjectType: GUID, - pub InheritedObjectType: GUID, - pub SidStart: DWORD, +pub struct _ACCESS_REASONS { + pub Data: [ACCESS_REASON; 32usize], } #[test] -fn bindgen_test_layout__SYSTEM_AUDIT_OBJECT_ACE() { +fn bindgen_test_layout__ACCESS_REASONS() { assert_eq!( - ::std::mem::size_of::<_SYSTEM_AUDIT_OBJECT_ACE>(), - 48usize, - concat!("Size of: ", stringify!(_SYSTEM_AUDIT_OBJECT_ACE)) + ::std::mem::size_of::<_ACCESS_REASONS>(), + 128usize, + concat!("Size of: ", stringify!(_ACCESS_REASONS)) ); assert_eq!( - ::std::mem::align_of::<_SYSTEM_AUDIT_OBJECT_ACE>(), + ::std::mem::align_of::<_ACCESS_REASONS>(), 4usize, - concat!("Alignment of ", stringify!(_SYSTEM_AUDIT_OBJECT_ACE)) + concat!("Alignment of ", stringify!(_ACCESS_REASONS)) ); - fn test_field_Header() { + fn test_field_Data() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_ACCESS_REASONS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Data) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_AUDIT_OBJECT_ACE), + stringify!(_ACCESS_REASONS), "::", - stringify!(Header) + stringify!(Data) ) ); } - test_field_Header(); - fn test_field_Mask() { + test_field_Data(); +} +pub type ACCESS_REASONS = _ACCESS_REASONS; +pub type PACCESS_REASONS = *mut _ACCESS_REASONS; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SE_SECURITY_DESCRIPTOR { + pub Size: DWORD, + pub Flags: DWORD, + pub SecurityDescriptor: PSECURITY_DESCRIPTOR, +} +#[test] +fn bindgen_test_layout__SE_SECURITY_DESCRIPTOR() { + assert_eq!( + ::std::mem::size_of::<_SE_SECURITY_DESCRIPTOR>(), + 16usize, + concat!("Size of: ", stringify!(_SE_SECURITY_DESCRIPTOR)) + ); + assert_eq!( + ::std::mem::align_of::<_SE_SECURITY_DESCRIPTOR>(), + 8usize, + concat!("Alignment of ", stringify!(_SE_SECURITY_DESCRIPTOR)) + ); + fn test_field_Size() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_SECURITY_DESCRIPTOR>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Size) as usize - ptr as usize }, - 4usize, + 0usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_AUDIT_OBJECT_ACE), + stringify!(_SE_SECURITY_DESCRIPTOR), "::", - stringify!(Mask) + stringify!(Size) ) ); } - test_field_Mask(); + test_field_Size(); fn test_field_Flags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_SECURITY_DESCRIPTOR>::uninit(); let ptr = uninit.as_ptr(); ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, - 8usize, + 4usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_AUDIT_OBJECT_ACE), + stringify!(_SE_SECURITY_DESCRIPTOR), "::", stringify!(Flags) ) ); } test_field_Flags(); - fn test_field_ObjectType() { + fn test_field_SecurityDescriptor() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_SECURITY_DESCRIPTOR>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ObjectType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SecurityDescriptor) as usize - ptr as usize }, - 12usize, + 8usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_AUDIT_OBJECT_ACE), + stringify!(_SE_SECURITY_DESCRIPTOR), "::", - stringify!(ObjectType) + stringify!(SecurityDescriptor) ) ); } - test_field_ObjectType(); - fn test_field_InheritedObjectType() { + test_field_SecurityDescriptor(); +} +pub type SE_SECURITY_DESCRIPTOR = _SE_SECURITY_DESCRIPTOR; +pub type PSE_SECURITY_DESCRIPTOR = *mut _SE_SECURITY_DESCRIPTOR; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SE_ACCESS_REQUEST { + pub Size: DWORD, + pub SeSecurityDescriptor: PSE_SECURITY_DESCRIPTOR, + pub DesiredAccess: ACCESS_MASK, + pub PreviouslyGrantedAccess: ACCESS_MASK, + pub PrincipalSelfSid: PSID, + pub GenericMapping: PGENERIC_MAPPING, + pub ObjectTypeListCount: DWORD, + pub ObjectTypeList: POBJECT_TYPE_LIST, +} +#[test] +fn bindgen_test_layout__SE_ACCESS_REQUEST() { + assert_eq!( + ::std::mem::size_of::<_SE_ACCESS_REQUEST>(), + 56usize, + concat!("Size of: ", stringify!(_SE_ACCESS_REQUEST)) + ); + assert_eq!( + ::std::mem::align_of::<_SE_ACCESS_REQUEST>(), + 8usize, + concat!("Alignment of ", stringify!(_SE_ACCESS_REQUEST)) + ); + fn test_field_Size() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REQUEST>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).InheritedObjectType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Size) as usize - ptr as usize }, - 28usize, + 0usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_AUDIT_OBJECT_ACE), + stringify!(_SE_ACCESS_REQUEST), "::", - stringify!(InheritedObjectType) + stringify!(Size) ) ); } - test_field_InheritedObjectType(); - fn test_field_SidStart() { + test_field_Size(); + fn test_field_SeSecurityDescriptor() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REQUEST>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SeSecurityDescriptor) as usize - ptr as usize }, - 44usize, + 8usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_AUDIT_OBJECT_ACE), + stringify!(_SE_ACCESS_REQUEST), "::", - stringify!(SidStart) + stringify!(SeSecurityDescriptor) ) ); } - test_field_SidStart(); -} -pub type SYSTEM_AUDIT_OBJECT_ACE = _SYSTEM_AUDIT_OBJECT_ACE; -pub type PSYSTEM_AUDIT_OBJECT_ACE = *mut _SYSTEM_AUDIT_OBJECT_ACE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SYSTEM_ALARM_OBJECT_ACE { - pub Header: ACE_HEADER, - pub Mask: ACCESS_MASK, - pub Flags: DWORD, - pub ObjectType: GUID, - pub InheritedObjectType: GUID, - pub SidStart: DWORD, -} -#[test] -fn bindgen_test_layout__SYSTEM_ALARM_OBJECT_ACE() { - assert_eq!( - ::std::mem::size_of::<_SYSTEM_ALARM_OBJECT_ACE>(), - 48usize, - concat!("Size of: ", stringify!(_SYSTEM_ALARM_OBJECT_ACE)) - ); - assert_eq!( - ::std::mem::align_of::<_SYSTEM_ALARM_OBJECT_ACE>(), - 4usize, - concat!("Alignment of ", stringify!(_SYSTEM_ALARM_OBJECT_ACE)) - ); - fn test_field_Header() { + test_field_SeSecurityDescriptor(); + fn test_field_DesiredAccess() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REQUEST>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).DesiredAccess) as usize - ptr as usize }, - 0usize, + 16usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ALARM_OBJECT_ACE), + stringify!(_SE_ACCESS_REQUEST), "::", - stringify!(Header) + stringify!(DesiredAccess) ) ); } - test_field_Header(); - fn test_field_Mask() { + test_field_DesiredAccess(); + fn test_field_PreviouslyGrantedAccess() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REQUEST>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).PreviouslyGrantedAccess) as usize - ptr as usize }, - 4usize, + 20usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ALARM_OBJECT_ACE), + stringify!(_SE_ACCESS_REQUEST), "::", - stringify!(Mask) + stringify!(PreviouslyGrantedAccess) ) ); } - test_field_Mask(); - fn test_field_Flags() { + test_field_PreviouslyGrantedAccess(); + fn test_field_PrincipalSelfSid() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REQUEST>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).PrincipalSelfSid) as usize - ptr as usize }, - 8usize, + 24usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ALARM_OBJECT_ACE), + stringify!(_SE_ACCESS_REQUEST), "::", - stringify!(Flags) + stringify!(PrincipalSelfSid) ) ); } - test_field_Flags(); - fn test_field_ObjectType() { + test_field_PrincipalSelfSid(); + fn test_field_GenericMapping() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REQUEST>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ObjectType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).GenericMapping) as usize - ptr as usize }, - 12usize, + 32usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ALARM_OBJECT_ACE), + stringify!(_SE_ACCESS_REQUEST), "::", - stringify!(ObjectType) + stringify!(GenericMapping) ) ); } - test_field_ObjectType(); - fn test_field_InheritedObjectType() { + test_field_GenericMapping(); + fn test_field_ObjectTypeListCount() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REQUEST>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).InheritedObjectType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ObjectTypeListCount) as usize - ptr as usize }, - 28usize, + 40usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ALARM_OBJECT_ACE), + stringify!(_SE_ACCESS_REQUEST), "::", - stringify!(InheritedObjectType) + stringify!(ObjectTypeListCount) ) ); } - test_field_InheritedObjectType(); - fn test_field_SidStart() { + test_field_ObjectTypeListCount(); + fn test_field_ObjectTypeList() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REQUEST>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ObjectTypeList) as usize - ptr as usize }, - 44usize, + 48usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ALARM_OBJECT_ACE), + stringify!(_SE_ACCESS_REQUEST), "::", - stringify!(SidStart) + stringify!(ObjectTypeList) ) ); } - test_field_SidStart(); + test_field_ObjectTypeList(); } -pub type SYSTEM_ALARM_OBJECT_ACE = _SYSTEM_ALARM_OBJECT_ACE; -pub type PSYSTEM_ALARM_OBJECT_ACE = *mut _SYSTEM_ALARM_OBJECT_ACE; +pub type SE_ACCESS_REQUEST = _SE_ACCESS_REQUEST; +pub type PSE_ACCESS_REQUEST = *mut _SE_ACCESS_REQUEST; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _ACCESS_ALLOWED_CALLBACK_ACE { - pub Header: ACE_HEADER, - pub Mask: ACCESS_MASK, - pub SidStart: DWORD, +pub struct _SE_ACCESS_REPLY { + pub Size: DWORD, + pub ResultListCount: DWORD, + pub GrantedAccess: PACCESS_MASK, + pub AccessStatus: PDWORD, + pub AccessReason: PACCESS_REASONS, + pub Privileges: *mut PPRIVILEGE_SET, } #[test] -fn bindgen_test_layout__ACCESS_ALLOWED_CALLBACK_ACE() { +fn bindgen_test_layout__SE_ACCESS_REPLY() { assert_eq!( - ::std::mem::size_of::<_ACCESS_ALLOWED_CALLBACK_ACE>(), - 12usize, - concat!("Size of: ", stringify!(_ACCESS_ALLOWED_CALLBACK_ACE)) + ::std::mem::size_of::<_SE_ACCESS_REPLY>(), + 40usize, + concat!("Size of: ", stringify!(_SE_ACCESS_REPLY)) ); assert_eq!( - ::std::mem::align_of::<_ACCESS_ALLOWED_CALLBACK_ACE>(), - 4usize, - concat!("Alignment of ", stringify!(_ACCESS_ALLOWED_CALLBACK_ACE)) + ::std::mem::align_of::<_SE_ACCESS_REPLY>(), + 8usize, + concat!("Alignment of ", stringify!(_SE_ACCESS_REPLY)) ); - fn test_field_Header() { + fn test_field_Size() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_CALLBACK_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REPLY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Size) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_ACCESS_ALLOWED_CALLBACK_ACE), + stringify!(_SE_ACCESS_REPLY), "::", - stringify!(Header) + stringify!(Size) ) ); } - test_field_Header(); - fn test_field_Mask() { + test_field_Size(); + fn test_field_ResultListCount() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_CALLBACK_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REPLY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ResultListCount) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", - stringify!(_ACCESS_ALLOWED_CALLBACK_ACE), + stringify!(_SE_ACCESS_REPLY), "::", - stringify!(Mask) + stringify!(ResultListCount) ) ); } - test_field_Mask(); - fn test_field_SidStart() { + test_field_ResultListCount(); + fn test_field_GrantedAccess() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_CALLBACK_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REPLY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).GrantedAccess) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_ACCESS_ALLOWED_CALLBACK_ACE), + stringify!(_SE_ACCESS_REPLY), "::", - stringify!(SidStart) + stringify!(GrantedAccess) ) ); } - test_field_SidStart(); -} -pub type ACCESS_ALLOWED_CALLBACK_ACE = _ACCESS_ALLOWED_CALLBACK_ACE; -pub type PACCESS_ALLOWED_CALLBACK_ACE = *mut _ACCESS_ALLOWED_CALLBACK_ACE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _ACCESS_DENIED_CALLBACK_ACE { - pub Header: ACE_HEADER, - pub Mask: ACCESS_MASK, - pub SidStart: DWORD, -} -#[test] -fn bindgen_test_layout__ACCESS_DENIED_CALLBACK_ACE() { - assert_eq!( - ::std::mem::size_of::<_ACCESS_DENIED_CALLBACK_ACE>(), - 12usize, - concat!("Size of: ", stringify!(_ACCESS_DENIED_CALLBACK_ACE)) - ); - assert_eq!( - ::std::mem::align_of::<_ACCESS_DENIED_CALLBACK_ACE>(), - 4usize, - concat!("Alignment of ", stringify!(_ACCESS_DENIED_CALLBACK_ACE)) - ); - fn test_field_Header() { + test_field_GrantedAccess(); + fn test_field_AccessStatus() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_CALLBACK_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REPLY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AccessStatus) as usize - ptr as usize }, - 0usize, + 16usize, concat!( "Offset of field: ", - stringify!(_ACCESS_DENIED_CALLBACK_ACE), + stringify!(_SE_ACCESS_REPLY), "::", - stringify!(Header) + stringify!(AccessStatus) ) ); } - test_field_Header(); - fn test_field_Mask() { + test_field_AccessStatus(); + fn test_field_AccessReason() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_CALLBACK_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REPLY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AccessReason) as usize - ptr as usize }, - 4usize, + 24usize, concat!( "Offset of field: ", - stringify!(_ACCESS_DENIED_CALLBACK_ACE), + stringify!(_SE_ACCESS_REPLY), "::", - stringify!(Mask) + stringify!(AccessReason) ) ); } - test_field_Mask(); - fn test_field_SidStart() { + test_field_AccessReason(); + fn test_field_Privileges() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_DENIED_CALLBACK_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REPLY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Privileges) as usize - ptr as usize }, - 8usize, + 32usize, concat!( "Offset of field: ", - stringify!(_ACCESS_DENIED_CALLBACK_ACE), + stringify!(_SE_ACCESS_REPLY), "::", - stringify!(SidStart) + stringify!(Privileges) ) ); } - test_field_SidStart(); + test_field_Privileges(); } -pub type ACCESS_DENIED_CALLBACK_ACE = _ACCESS_DENIED_CALLBACK_ACE; -pub type PACCESS_DENIED_CALLBACK_ACE = *mut _ACCESS_DENIED_CALLBACK_ACE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SYSTEM_AUDIT_CALLBACK_ACE { - pub Header: ACE_HEADER, - pub Mask: ACCESS_MASK, - pub SidStart: DWORD, +pub type SE_ACCESS_REPLY = _SE_ACCESS_REPLY; +pub type PSE_ACCESS_REPLY = *mut _SE_ACCESS_REPLY; +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _SECURITY_IMPERSONATION_LEVEL { + SecurityAnonymous = 0, + SecurityIdentification = 1, + SecurityImpersonation = 2, + SecurityDelegation = 3, +} +pub use self::_SECURITY_IMPERSONATION_LEVEL as SECURITY_IMPERSONATION_LEVEL; +pub type PSECURITY_IMPERSONATION_LEVEL = *mut _SECURITY_IMPERSONATION_LEVEL; +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _TOKEN_TYPE { + TokenPrimary = 1, + TokenImpersonation = 2, +} +pub use self::_TOKEN_TYPE as TOKEN_TYPE; +pub type PTOKEN_TYPE = *mut TOKEN_TYPE; +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _TOKEN_ELEVATION_TYPE { + TokenElevationTypeDefault = 1, + TokenElevationTypeFull = 2, + TokenElevationTypeLimited = 3, +} +pub use self::_TOKEN_ELEVATION_TYPE as TOKEN_ELEVATION_TYPE; +pub type PTOKEN_ELEVATION_TYPE = *mut _TOKEN_ELEVATION_TYPE; +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _TOKEN_INFORMATION_CLASS { + TokenUser = 1, + TokenGroups = 2, + TokenPrivileges = 3, + TokenOwner = 4, + TokenPrimaryGroup = 5, + TokenDefaultDacl = 6, + TokenSource = 7, + TokenType = 8, + TokenImpersonationLevel = 9, + TokenStatistics = 10, + TokenRestrictedSids = 11, + TokenSessionId = 12, + TokenGroupsAndPrivileges = 13, + TokenSessionReference = 14, + TokenSandBoxInert = 15, + TokenAuditPolicy = 16, + TokenOrigin = 17, + TokenElevationType = 18, + TokenLinkedToken = 19, + TokenElevation = 20, + TokenHasRestrictions = 21, + TokenAccessInformation = 22, + TokenVirtualizationAllowed = 23, + TokenVirtualizationEnabled = 24, + TokenIntegrityLevel = 25, + TokenUIAccess = 26, + TokenMandatoryPolicy = 27, + TokenLogonSid = 28, + TokenIsAppContainer = 29, + TokenCapabilities = 30, + TokenAppContainerSid = 31, + TokenAppContainerNumber = 32, + TokenUserClaimAttributes = 33, + TokenDeviceClaimAttributes = 34, + TokenRestrictedUserClaimAttributes = 35, + TokenRestrictedDeviceClaimAttributes = 36, + TokenDeviceGroups = 37, + TokenRestrictedDeviceGroups = 38, + TokenSecurityAttributes = 39, + TokenIsRestricted = 40, + TokenProcessTrustLevel = 41, + TokenPrivateNameSpace = 42, + TokenSingletonAttributes = 43, + TokenBnoIsolation = 44, + TokenChildProcessFlags = 45, + TokenIsLessPrivilegedAppContainer = 46, + TokenIsSandboxed = 47, + TokenIsAppSilo = 48, + MaxTokenInfoClass = 49, +} +pub use self::_TOKEN_INFORMATION_CLASS as TOKEN_INFORMATION_CLASS; +pub type PTOKEN_INFORMATION_CLASS = *mut _TOKEN_INFORMATION_CLASS; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _TOKEN_USER { + pub User: SID_AND_ATTRIBUTES, } #[test] -fn bindgen_test_layout__SYSTEM_AUDIT_CALLBACK_ACE() { +fn bindgen_test_layout__TOKEN_USER() { assert_eq!( - ::std::mem::size_of::<_SYSTEM_AUDIT_CALLBACK_ACE>(), - 12usize, - concat!("Size of: ", stringify!(_SYSTEM_AUDIT_CALLBACK_ACE)) + ::std::mem::size_of::<_TOKEN_USER>(), + 16usize, + concat!("Size of: ", stringify!(_TOKEN_USER)) ); assert_eq!( - ::std::mem::align_of::<_SYSTEM_AUDIT_CALLBACK_ACE>(), - 4usize, - concat!("Alignment of ", stringify!(_SYSTEM_AUDIT_CALLBACK_ACE)) + ::std::mem::align_of::<_TOKEN_USER>(), + 8usize, + concat!("Alignment of ", stringify!(_TOKEN_USER)) ); - fn test_field_Header() { + fn test_field_User() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_CALLBACK_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_USER>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).User) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_AUDIT_CALLBACK_ACE), + stringify!(_TOKEN_USER), "::", - stringify!(Header) + stringify!(User) ) ); } - test_field_Header(); - fn test_field_Mask() { + test_field_User(); +} +pub type TOKEN_USER = _TOKEN_USER; +pub type PTOKEN_USER = *mut _TOKEN_USER; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _SE_TOKEN_USER { + pub __bindgen_anon_1: _SE_TOKEN_USER__bindgen_ty_1, + pub __bindgen_anon_2: _SE_TOKEN_USER__bindgen_ty_2, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _SE_TOKEN_USER__bindgen_ty_1 { + pub TokenUser: TOKEN_USER, + pub User: SID_AND_ATTRIBUTES, +} +#[test] +fn bindgen_test_layout__SE_TOKEN_USER__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<_SE_TOKEN_USER__bindgen_ty_1>(), + 16usize, + concat!("Size of: ", stringify!(_SE_TOKEN_USER__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::<_SE_TOKEN_USER__bindgen_ty_1>(), + 8usize, + concat!("Alignment of ", stringify!(_SE_TOKEN_USER__bindgen_ty_1)) + ); + fn test_field_TokenUser() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_CALLBACK_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_TOKEN_USER__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).TokenUser) as usize - ptr as usize }, - 4usize, + 0usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_AUDIT_CALLBACK_ACE), + stringify!(_SE_TOKEN_USER__bindgen_ty_1), "::", - stringify!(Mask) + stringify!(TokenUser) ) ); } - test_field_Mask(); - fn test_field_SidStart() { + test_field_TokenUser(); + fn test_field_User() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_CALLBACK_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_TOKEN_USER__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).User) as usize - ptr as usize }, - 8usize, + 0usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_AUDIT_CALLBACK_ACE), + stringify!(_SE_TOKEN_USER__bindgen_ty_1), "::", - stringify!(SidStart) + stringify!(User) ) ); } - test_field_SidStart(); + test_field_User(); } -pub type SYSTEM_AUDIT_CALLBACK_ACE = _SYSTEM_AUDIT_CALLBACK_ACE; -pub type PSYSTEM_AUDIT_CALLBACK_ACE = *mut _SYSTEM_AUDIT_CALLBACK_ACE; #[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SYSTEM_ALARM_CALLBACK_ACE { - pub Header: ACE_HEADER, - pub Mask: ACCESS_MASK, - pub SidStart: DWORD, +#[derive(Copy, Clone)] +pub union _SE_TOKEN_USER__bindgen_ty_2 { + pub Sid: SID, + pub Buffer: [BYTE; 68usize], } #[test] -fn bindgen_test_layout__SYSTEM_ALARM_CALLBACK_ACE() { +fn bindgen_test_layout__SE_TOKEN_USER__bindgen_ty_2() { assert_eq!( - ::std::mem::size_of::<_SYSTEM_ALARM_CALLBACK_ACE>(), - 12usize, - concat!("Size of: ", stringify!(_SYSTEM_ALARM_CALLBACK_ACE)) + ::std::mem::size_of::<_SE_TOKEN_USER__bindgen_ty_2>(), + 68usize, + concat!("Size of: ", stringify!(_SE_TOKEN_USER__bindgen_ty_2)) ); assert_eq!( - ::std::mem::align_of::<_SYSTEM_ALARM_CALLBACK_ACE>(), + ::std::mem::align_of::<_SE_TOKEN_USER__bindgen_ty_2>(), 4usize, - concat!("Alignment of ", stringify!(_SYSTEM_ALARM_CALLBACK_ACE)) + concat!("Alignment of ", stringify!(_SE_TOKEN_USER__bindgen_ty_2)) ); - fn test_field_Header() { + fn test_field_Sid() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_CALLBACK_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_TOKEN_USER__bindgen_ty_2>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Sid) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ALARM_CALLBACK_ACE), + stringify!(_SE_TOKEN_USER__bindgen_ty_2), "::", - stringify!(Header) + stringify!(Sid) ) ); } - test_field_Header(); - fn test_field_Mask() { + test_field_Sid(); + fn test_field_Buffer() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_CALLBACK_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_TOKEN_USER__bindgen_ty_2>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Buffer) as usize - ptr as usize }, - 4usize, + 0usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ALARM_CALLBACK_ACE), + stringify!(_SE_TOKEN_USER__bindgen_ty_2), "::", - stringify!(Mask) + stringify!(Buffer) ) ); } - test_field_Mask(); - fn test_field_SidStart() { + test_field_Buffer(); +} +#[test] +fn bindgen_test_layout__SE_TOKEN_USER() { + assert_eq!( + ::std::mem::size_of::<_SE_TOKEN_USER>(), + 88usize, + concat!("Size of: ", stringify!(_SE_TOKEN_USER)) + ); + assert_eq!( + ::std::mem::align_of::<_SE_TOKEN_USER>(), + 8usize, + concat!("Alignment of ", stringify!(_SE_TOKEN_USER)) + ); +} +pub type SE_TOKEN_USER = _SE_TOKEN_USER; +pub type PSE_TOKEN_USER = _SE_TOKEN_USER; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _TOKEN_GROUPS { + pub GroupCount: DWORD, + pub Groups: [SID_AND_ATTRIBUTES; 1usize], +} +#[test] +fn bindgen_test_layout__TOKEN_GROUPS() { + assert_eq!( + ::std::mem::size_of::<_TOKEN_GROUPS>(), + 24usize, + concat!("Size of: ", stringify!(_TOKEN_GROUPS)) + ); + assert_eq!( + ::std::mem::align_of::<_TOKEN_GROUPS>(), + 8usize, + concat!("Alignment of ", stringify!(_TOKEN_GROUPS)) + ); + fn test_field_GroupCount() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_CALLBACK_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).GroupCount) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_TOKEN_GROUPS), + "::", + stringify!(GroupCount) + ) + ); + } + test_field_GroupCount(); + fn test_field_Groups() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Groups) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ALARM_CALLBACK_ACE), + stringify!(_TOKEN_GROUPS), "::", - stringify!(SidStart) + stringify!(Groups) ) ); } - test_field_SidStart(); + test_field_Groups(); } -pub type SYSTEM_ALARM_CALLBACK_ACE = _SYSTEM_ALARM_CALLBACK_ACE; -pub type PSYSTEM_ALARM_CALLBACK_ACE = *mut _SYSTEM_ALARM_CALLBACK_ACE; +pub type TOKEN_GROUPS = _TOKEN_GROUPS; +pub type PTOKEN_GROUPS = *mut _TOKEN_GROUPS; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _ACCESS_ALLOWED_CALLBACK_OBJECT_ACE { - pub Header: ACE_HEADER, - pub Mask: ACCESS_MASK, - pub Flags: DWORD, - pub ObjectType: GUID, - pub InheritedObjectType: GUID, - pub SidStart: DWORD, +pub struct _TOKEN_PRIVILEGES { + pub PrivilegeCount: DWORD, + pub Privileges: [LUID_AND_ATTRIBUTES; 1usize], } #[test] -fn bindgen_test_layout__ACCESS_ALLOWED_CALLBACK_OBJECT_ACE() { +fn bindgen_test_layout__TOKEN_PRIVILEGES() { assert_eq!( - ::std::mem::size_of::<_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE>(), - 48usize, - concat!("Size of: ", stringify!(_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE)) + ::std::mem::size_of::<_TOKEN_PRIVILEGES>(), + 16usize, + concat!("Size of: ", stringify!(_TOKEN_PRIVILEGES)) ); assert_eq!( - ::std::mem::align_of::<_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE>(), + ::std::mem::align_of::<_TOKEN_PRIVILEGES>(), 4usize, - concat!( - "Alignment of ", - stringify!(_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE) - ) + concat!("Alignment of ", stringify!(_TOKEN_PRIVILEGES)) ); - fn test_field_Header() { + fn test_field_PrivilegeCount() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_PRIVILEGES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).PrivilegeCount) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_PRIVILEGES), "::", - stringify!(Header) + stringify!(PrivilegeCount) ) ); } - test_field_Header(); - fn test_field_Mask() { + test_field_PrivilegeCount(); + fn test_field_Privileges() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_PRIVILEGES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Privileges) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", - stringify!(_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_PRIVILEGES), "::", - stringify!(Mask) + stringify!(Privileges) ) ); } - test_field_Mask(); - fn test_field_Flags() { + test_field_Privileges(); +} +pub type TOKEN_PRIVILEGES = _TOKEN_PRIVILEGES; +pub type PTOKEN_PRIVILEGES = *mut _TOKEN_PRIVILEGES; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _TOKEN_OWNER { + pub Owner: PSID, +} +#[test] +fn bindgen_test_layout__TOKEN_OWNER() { + assert_eq!( + ::std::mem::size_of::<_TOKEN_OWNER>(), + 8usize, + concat!("Size of: ", stringify!(_TOKEN_OWNER)) + ); + assert_eq!( + ::std::mem::align_of::<_TOKEN_OWNER>(), + 8usize, + concat!("Alignment of ", stringify!(_TOKEN_OWNER)) + ); + fn test_field_Owner() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_OWNER>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Owner) as usize - ptr as usize }, - 8usize, + 0usize, concat!( "Offset of field: ", - stringify!(_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_OWNER), "::", - stringify!(Flags) + stringify!(Owner) ) ); } - test_field_Flags(); - fn test_field_ObjectType() { + test_field_Owner(); +} +pub type TOKEN_OWNER = _TOKEN_OWNER; +pub type PTOKEN_OWNER = *mut _TOKEN_OWNER; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _TOKEN_PRIMARY_GROUP { + pub PrimaryGroup: PSID, +} +#[test] +fn bindgen_test_layout__TOKEN_PRIMARY_GROUP() { + assert_eq!( + ::std::mem::size_of::<_TOKEN_PRIMARY_GROUP>(), + 8usize, + concat!("Size of: ", stringify!(_TOKEN_PRIMARY_GROUP)) + ); + assert_eq!( + ::std::mem::align_of::<_TOKEN_PRIMARY_GROUP>(), + 8usize, + concat!("Alignment of ", stringify!(_TOKEN_PRIMARY_GROUP)) + ); + fn test_field_PrimaryGroup() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_PRIMARY_GROUP>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ObjectType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).PrimaryGroup) as usize - ptr as usize }, - 12usize, + 0usize, concat!( "Offset of field: ", - stringify!(_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_PRIMARY_GROUP), "::", - stringify!(ObjectType) + stringify!(PrimaryGroup) ) ); } - test_field_ObjectType(); - fn test_field_InheritedObjectType() { + test_field_PrimaryGroup(); +} +pub type TOKEN_PRIMARY_GROUP = _TOKEN_PRIMARY_GROUP; +pub type PTOKEN_PRIMARY_GROUP = *mut _TOKEN_PRIMARY_GROUP; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _TOKEN_DEFAULT_DACL { + pub DefaultDacl: PACL, +} +#[test] +fn bindgen_test_layout__TOKEN_DEFAULT_DACL() { + assert_eq!( + ::std::mem::size_of::<_TOKEN_DEFAULT_DACL>(), + 8usize, + concat!("Size of: ", stringify!(_TOKEN_DEFAULT_DACL)) + ); + assert_eq!( + ::std::mem::align_of::<_TOKEN_DEFAULT_DACL>(), + 8usize, + concat!("Alignment of ", stringify!(_TOKEN_DEFAULT_DACL)) + ); + fn test_field_DefaultDacl() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_DEFAULT_DACL>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).InheritedObjectType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).DefaultDacl) as usize - ptr as usize }, - 28usize, + 0usize, concat!( "Offset of field: ", - stringify!(_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_DEFAULT_DACL), "::", - stringify!(InheritedObjectType) + stringify!(DefaultDacl) ) ); } - test_field_InheritedObjectType(); - fn test_field_SidStart() { + test_field_DefaultDacl(); +} +pub type TOKEN_DEFAULT_DACL = _TOKEN_DEFAULT_DACL; +pub type PTOKEN_DEFAULT_DACL = *mut _TOKEN_DEFAULT_DACL; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _TOKEN_USER_CLAIMS { + pub UserClaims: PCLAIMS_BLOB, +} +#[test] +fn bindgen_test_layout__TOKEN_USER_CLAIMS() { + assert_eq!( + ::std::mem::size_of::<_TOKEN_USER_CLAIMS>(), + 8usize, + concat!("Size of: ", stringify!(_TOKEN_USER_CLAIMS)) + ); + assert_eq!( + ::std::mem::align_of::<_TOKEN_USER_CLAIMS>(), + 8usize, + concat!("Alignment of ", stringify!(_TOKEN_USER_CLAIMS)) + ); + fn test_field_UserClaims() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_USER_CLAIMS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).UserClaims) as usize - ptr as usize }, - 44usize, + 0usize, concat!( "Offset of field: ", - stringify!(_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_USER_CLAIMS), "::", - stringify!(SidStart) + stringify!(UserClaims) ) ); } - test_field_SidStart(); + test_field_UserClaims(); } -pub type ACCESS_ALLOWED_CALLBACK_OBJECT_ACE = _ACCESS_ALLOWED_CALLBACK_OBJECT_ACE; -pub type PACCESS_ALLOWED_CALLBACK_OBJECT_ACE = *mut _ACCESS_ALLOWED_CALLBACK_OBJECT_ACE; +pub type TOKEN_USER_CLAIMS = _TOKEN_USER_CLAIMS; +pub type PTOKEN_USER_CLAIMS = *mut _TOKEN_USER_CLAIMS; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _ACCESS_DENIED_CALLBACK_OBJECT_ACE { - pub Header: ACE_HEADER, - pub Mask: ACCESS_MASK, - pub Flags: DWORD, - pub ObjectType: GUID, - pub InheritedObjectType: GUID, - pub SidStart: DWORD, +pub struct _TOKEN_DEVICE_CLAIMS { + pub DeviceClaims: PCLAIMS_BLOB, } #[test] -fn bindgen_test_layout__ACCESS_DENIED_CALLBACK_OBJECT_ACE() { +fn bindgen_test_layout__TOKEN_DEVICE_CLAIMS() { assert_eq!( - ::std::mem::size_of::<_ACCESS_DENIED_CALLBACK_OBJECT_ACE>(), - 48usize, - concat!("Size of: ", stringify!(_ACCESS_DENIED_CALLBACK_OBJECT_ACE)) + ::std::mem::size_of::<_TOKEN_DEVICE_CLAIMS>(), + 8usize, + concat!("Size of: ", stringify!(_TOKEN_DEVICE_CLAIMS)) ); assert_eq!( - ::std::mem::align_of::<_ACCESS_DENIED_CALLBACK_OBJECT_ACE>(), - 4usize, - concat!( - "Alignment of ", - stringify!(_ACCESS_DENIED_CALLBACK_OBJECT_ACE) - ) + ::std::mem::align_of::<_TOKEN_DEVICE_CLAIMS>(), + 8usize, + concat!("Alignment of ", stringify!(_TOKEN_DEVICE_CLAIMS)) ); - fn test_field_Header() { + fn test_field_DeviceClaims() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_ACCESS_DENIED_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_DEVICE_CLAIMS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).DeviceClaims) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_ACCESS_DENIED_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_DEVICE_CLAIMS), "::", - stringify!(Header) + stringify!(DeviceClaims) ) ); } - test_field_Header(); - fn test_field_Mask() { + test_field_DeviceClaims(); +} +pub type TOKEN_DEVICE_CLAIMS = _TOKEN_DEVICE_CLAIMS; +pub type PTOKEN_DEVICE_CLAIMS = *mut _TOKEN_DEVICE_CLAIMS; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _TOKEN_GROUPS_AND_PRIVILEGES { + pub SidCount: DWORD, + pub SidLength: DWORD, + pub Sids: PSID_AND_ATTRIBUTES, + pub RestrictedSidCount: DWORD, + pub RestrictedSidLength: DWORD, + pub RestrictedSids: PSID_AND_ATTRIBUTES, + pub PrivilegeCount: DWORD, + pub PrivilegeLength: DWORD, + pub Privileges: PLUID_AND_ATTRIBUTES, + pub AuthenticationId: LUID, +} +#[test] +fn bindgen_test_layout__TOKEN_GROUPS_AND_PRIVILEGES() { + assert_eq!( + ::std::mem::size_of::<_TOKEN_GROUPS_AND_PRIVILEGES>(), + 56usize, + concat!("Size of: ", stringify!(_TOKEN_GROUPS_AND_PRIVILEGES)) + ); + assert_eq!( + ::std::mem::align_of::<_TOKEN_GROUPS_AND_PRIVILEGES>(), + 8usize, + concat!("Alignment of ", stringify!(_TOKEN_GROUPS_AND_PRIVILEGES)) + ); + fn test_field_SidCount() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_ACCESS_DENIED_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS_AND_PRIVILEGES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidCount) as usize - ptr as usize }, - 4usize, + 0usize, concat!( "Offset of field: ", - stringify!(_ACCESS_DENIED_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_GROUPS_AND_PRIVILEGES), "::", - stringify!(Mask) + stringify!(SidCount) ) ); } - test_field_Mask(); - fn test_field_Flags() { + test_field_SidCount(); + fn test_field_SidLength() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_ACCESS_DENIED_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS_AND_PRIVILEGES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidLength) as usize - ptr as usize }, - 8usize, + 4usize, concat!( "Offset of field: ", - stringify!(_ACCESS_DENIED_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_GROUPS_AND_PRIVILEGES), "::", - stringify!(Flags) + stringify!(SidLength) ) ); } - test_field_Flags(); - fn test_field_ObjectType() { + test_field_SidLength(); + fn test_field_Sids() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_ACCESS_DENIED_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS_AND_PRIVILEGES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ObjectType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Sids) as usize - ptr as usize }, - 12usize, + 8usize, concat!( "Offset of field: ", - stringify!(_ACCESS_DENIED_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_GROUPS_AND_PRIVILEGES), "::", - stringify!(ObjectType) + stringify!(Sids) ) ); } - test_field_ObjectType(); - fn test_field_InheritedObjectType() { + test_field_Sids(); + fn test_field_RestrictedSidCount() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_ACCESS_DENIED_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS_AND_PRIVILEGES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).InheritedObjectType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).RestrictedSidCount) as usize - ptr as usize }, - 28usize, + 16usize, concat!( "Offset of field: ", - stringify!(_ACCESS_DENIED_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_GROUPS_AND_PRIVILEGES), "::", - stringify!(InheritedObjectType) + stringify!(RestrictedSidCount) ) ); } - test_field_InheritedObjectType(); - fn test_field_SidStart() { + test_field_RestrictedSidCount(); + fn test_field_RestrictedSidLength() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_ACCESS_DENIED_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS_AND_PRIVILEGES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).RestrictedSidLength) as usize - ptr as usize }, - 44usize, + 20usize, concat!( "Offset of field: ", - stringify!(_ACCESS_DENIED_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_GROUPS_AND_PRIVILEGES), "::", - stringify!(SidStart) + stringify!(RestrictedSidLength) ) ); } - test_field_SidStart(); -} -pub type ACCESS_DENIED_CALLBACK_OBJECT_ACE = _ACCESS_DENIED_CALLBACK_OBJECT_ACE; -pub type PACCESS_DENIED_CALLBACK_OBJECT_ACE = *mut _ACCESS_DENIED_CALLBACK_OBJECT_ACE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SYSTEM_AUDIT_CALLBACK_OBJECT_ACE { - pub Header: ACE_HEADER, - pub Mask: ACCESS_MASK, - pub Flags: DWORD, - pub ObjectType: GUID, - pub InheritedObjectType: GUID, - pub SidStart: DWORD, -} -#[test] -fn bindgen_test_layout__SYSTEM_AUDIT_CALLBACK_OBJECT_ACE() { - assert_eq!( - ::std::mem::size_of::<_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE>(), - 48usize, - concat!("Size of: ", stringify!(_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE)) - ); - assert_eq!( - ::std::mem::align_of::<_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE>(), - 4usize, - concat!( - "Alignment of ", - stringify!(_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE) - ) - ); - fn test_field_Header() { + test_field_RestrictedSidLength(); + fn test_field_RestrictedSids() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS_AND_PRIVILEGES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).RestrictedSids) as usize - ptr as usize }, - 0usize, + 24usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_GROUPS_AND_PRIVILEGES), "::", - stringify!(Header) + stringify!(RestrictedSids) ) ); } - test_field_Header(); - fn test_field_Mask() { + test_field_RestrictedSids(); + fn test_field_PrivilegeCount() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS_AND_PRIVILEGES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).PrivilegeCount) as usize - ptr as usize }, - 4usize, + 32usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_GROUPS_AND_PRIVILEGES), "::", - stringify!(Mask) + stringify!(PrivilegeCount) ) ); } - test_field_Mask(); - fn test_field_Flags() { + test_field_PrivilegeCount(); + fn test_field_PrivilegeLength() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS_AND_PRIVILEGES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).PrivilegeLength) as usize - ptr as usize }, - 8usize, + 36usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_GROUPS_AND_PRIVILEGES), "::", - stringify!(Flags) + stringify!(PrivilegeLength) ) ); } - test_field_Flags(); - fn test_field_ObjectType() { + test_field_PrivilegeLength(); + fn test_field_Privileges() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS_AND_PRIVILEGES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ObjectType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Privileges) as usize - ptr as usize }, - 12usize, + 40usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_GROUPS_AND_PRIVILEGES), "::", - stringify!(ObjectType) + stringify!(Privileges) ) ); } - test_field_ObjectType(); - fn test_field_InheritedObjectType() { + test_field_Privileges(); + fn test_field_AuthenticationId() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS_AND_PRIVILEGES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).InheritedObjectType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AuthenticationId) as usize - ptr as usize }, - 28usize, + 48usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_GROUPS_AND_PRIVILEGES), "::", - stringify!(InheritedObjectType) + stringify!(AuthenticationId) ) ); } - test_field_InheritedObjectType(); - fn test_field_SidStart() { + test_field_AuthenticationId(); +} +pub type TOKEN_GROUPS_AND_PRIVILEGES = _TOKEN_GROUPS_AND_PRIVILEGES; +pub type PTOKEN_GROUPS_AND_PRIVILEGES = *mut _TOKEN_GROUPS_AND_PRIVILEGES; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _TOKEN_LINKED_TOKEN { + pub LinkedToken: HANDLE, +} +#[test] +fn bindgen_test_layout__TOKEN_LINKED_TOKEN() { + assert_eq!( + ::std::mem::size_of::<_TOKEN_LINKED_TOKEN>(), + 8usize, + concat!("Size of: ", stringify!(_TOKEN_LINKED_TOKEN)) + ); + assert_eq!( + ::std::mem::align_of::<_TOKEN_LINKED_TOKEN>(), + 8usize, + concat!("Alignment of ", stringify!(_TOKEN_LINKED_TOKEN)) + ); + fn test_field_LinkedToken() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_LINKED_TOKEN>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).LinkedToken) as usize - ptr as usize }, - 44usize, + 0usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_LINKED_TOKEN), "::", - stringify!(SidStart) + stringify!(LinkedToken) ) ); } - test_field_SidStart(); + test_field_LinkedToken(); } -pub type SYSTEM_AUDIT_CALLBACK_OBJECT_ACE = _SYSTEM_AUDIT_CALLBACK_OBJECT_ACE; -pub type PSYSTEM_AUDIT_CALLBACK_OBJECT_ACE = *mut _SYSTEM_AUDIT_CALLBACK_OBJECT_ACE; +pub type TOKEN_LINKED_TOKEN = _TOKEN_LINKED_TOKEN; +pub type PTOKEN_LINKED_TOKEN = *mut _TOKEN_LINKED_TOKEN; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _SYSTEM_ALARM_CALLBACK_OBJECT_ACE { - pub Header: ACE_HEADER, - pub Mask: ACCESS_MASK, - pub Flags: DWORD, - pub ObjectType: GUID, - pub InheritedObjectType: GUID, - pub SidStart: DWORD, +pub struct _TOKEN_ELEVATION { + pub TokenIsElevated: DWORD, } #[test] -fn bindgen_test_layout__SYSTEM_ALARM_CALLBACK_OBJECT_ACE() { +fn bindgen_test_layout__TOKEN_ELEVATION() { assert_eq!( - ::std::mem::size_of::<_SYSTEM_ALARM_CALLBACK_OBJECT_ACE>(), - 48usize, - concat!("Size of: ", stringify!(_SYSTEM_ALARM_CALLBACK_OBJECT_ACE)) + ::std::mem::size_of::<_TOKEN_ELEVATION>(), + 4usize, + concat!("Size of: ", stringify!(_TOKEN_ELEVATION)) ); assert_eq!( - ::std::mem::align_of::<_SYSTEM_ALARM_CALLBACK_OBJECT_ACE>(), + ::std::mem::align_of::<_TOKEN_ELEVATION>(), 4usize, - concat!( - "Alignment of ", - stringify!(_SYSTEM_ALARM_CALLBACK_OBJECT_ACE) - ) + concat!("Alignment of ", stringify!(_TOKEN_ELEVATION)) ); - fn test_field_Header() { + fn test_field_TokenIsElevated() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_ELEVATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Header) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).TokenIsElevated) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ALARM_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_ELEVATION), "::", - stringify!(Header) + stringify!(TokenIsElevated) ) ); } - test_field_Header(); - fn test_field_Mask() { + test_field_TokenIsElevated(); +} +pub type TOKEN_ELEVATION = _TOKEN_ELEVATION; +pub type PTOKEN_ELEVATION = *mut _TOKEN_ELEVATION; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _TOKEN_MANDATORY_LABEL { + pub Label: SID_AND_ATTRIBUTES, +} +#[test] +fn bindgen_test_layout__TOKEN_MANDATORY_LABEL() { + assert_eq!( + ::std::mem::size_of::<_TOKEN_MANDATORY_LABEL>(), + 16usize, + concat!("Size of: ", stringify!(_TOKEN_MANDATORY_LABEL)) + ); + assert_eq!( + ::std::mem::align_of::<_TOKEN_MANDATORY_LABEL>(), + 8usize, + concat!("Alignment of ", stringify!(_TOKEN_MANDATORY_LABEL)) + ); + fn test_field_Label() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_MANDATORY_LABEL>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Mask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Label) as usize - ptr as usize }, - 4usize, + 0usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ALARM_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_MANDATORY_LABEL), "::", - stringify!(Mask) + stringify!(Label) ) ); } - test_field_Mask(); - fn test_field_Flags() { + test_field_Label(); +} +pub type TOKEN_MANDATORY_LABEL = _TOKEN_MANDATORY_LABEL; +pub type PTOKEN_MANDATORY_LABEL = *mut _TOKEN_MANDATORY_LABEL; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _TOKEN_MANDATORY_POLICY { + pub Policy: DWORD, +} +#[test] +fn bindgen_test_layout__TOKEN_MANDATORY_POLICY() { + assert_eq!( + ::std::mem::size_of::<_TOKEN_MANDATORY_POLICY>(), + 4usize, + concat!("Size of: ", stringify!(_TOKEN_MANDATORY_POLICY)) + ); + assert_eq!( + ::std::mem::align_of::<_TOKEN_MANDATORY_POLICY>(), + 4usize, + concat!("Alignment of ", stringify!(_TOKEN_MANDATORY_POLICY)) + ); + fn test_field_Policy() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_MANDATORY_POLICY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Policy) as usize - ptr as usize }, - 8usize, + 0usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ALARM_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_MANDATORY_POLICY), "::", - stringify!(Flags) + stringify!(Policy) ) ); } - test_field_Flags(); - fn test_field_ObjectType() { + test_field_Policy(); +} +pub type TOKEN_MANDATORY_POLICY = _TOKEN_MANDATORY_POLICY; +pub type PTOKEN_MANDATORY_POLICY = *mut _TOKEN_MANDATORY_POLICY; +pub type PSECURITY_ATTRIBUTES_OPAQUE = PVOID; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _TOKEN_ACCESS_INFORMATION { + pub SidHash: PSID_AND_ATTRIBUTES_HASH, + pub RestrictedSidHash: PSID_AND_ATTRIBUTES_HASH, + pub Privileges: PTOKEN_PRIVILEGES, + pub AuthenticationId: LUID, + pub TokenType: TOKEN_TYPE, + pub ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL, + pub MandatoryPolicy: TOKEN_MANDATORY_POLICY, + pub Flags: DWORD, + pub AppContainerNumber: DWORD, + pub PackageSid: PSID, + pub CapabilitiesHash: PSID_AND_ATTRIBUTES_HASH, + pub TrustLevelSid: PSID, + pub SecurityAttributes: PSECURITY_ATTRIBUTES_OPAQUE, +} +#[test] +fn bindgen_test_layout__TOKEN_ACCESS_INFORMATION() { + assert_eq!( + ::std::mem::size_of::<_TOKEN_ACCESS_INFORMATION>(), + 88usize, + concat!("Size of: ", stringify!(_TOKEN_ACCESS_INFORMATION)) + ); + assert_eq!( + ::std::mem::align_of::<_TOKEN_ACCESS_INFORMATION>(), + 8usize, + concat!("Alignment of ", stringify!(_TOKEN_ACCESS_INFORMATION)) + ); + fn test_field_SidHash() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ObjectType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SidHash) as usize - ptr as usize }, - 12usize, + 0usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ALARM_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_ACCESS_INFORMATION), "::", - stringify!(ObjectType) + stringify!(SidHash) ) ); } - test_field_ObjectType(); - fn test_field_InheritedObjectType() { + test_field_SidHash(); + fn test_field_RestrictedSidHash() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).InheritedObjectType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).RestrictedSidHash) as usize - ptr as usize }, - 28usize, + 8usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ALARM_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_ACCESS_INFORMATION), "::", - stringify!(InheritedObjectType) + stringify!(RestrictedSidHash) ) ); } - test_field_InheritedObjectType(); - fn test_field_SidStart() { + test_field_RestrictedSidHash(); + fn test_field_Privileges() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SYSTEM_ALARM_CALLBACK_OBJECT_ACE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidStart) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Privileges) as usize - ptr as usize }, - 44usize, + 16usize, concat!( "Offset of field: ", - stringify!(_SYSTEM_ALARM_CALLBACK_OBJECT_ACE), + stringify!(_TOKEN_ACCESS_INFORMATION), "::", - stringify!(SidStart) + stringify!(Privileges) ) ); } - test_field_SidStart(); -} -pub type SYSTEM_ALARM_CALLBACK_OBJECT_ACE = _SYSTEM_ALARM_CALLBACK_OBJECT_ACE; -pub type PSYSTEM_ALARM_CALLBACK_OBJECT_ACE = *mut _SYSTEM_ALARM_CALLBACK_OBJECT_ACE; -#[repr(i32)] -#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] -pub enum _ACL_INFORMATION_CLASS { - AclRevisionInformation = 1, - AclSizeInformation = 2, -} -pub use self::_ACL_INFORMATION_CLASS as ACL_INFORMATION_CLASS; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _ACL_REVISION_INFORMATION { - pub AclRevision: DWORD, -} -#[test] -fn bindgen_test_layout__ACL_REVISION_INFORMATION() { - assert_eq!( - ::std::mem::size_of::<_ACL_REVISION_INFORMATION>(), - 4usize, - concat!("Size of: ", stringify!(_ACL_REVISION_INFORMATION)) - ); - assert_eq!( - ::std::mem::align_of::<_ACL_REVISION_INFORMATION>(), - 4usize, - concat!("Alignment of ", stringify!(_ACL_REVISION_INFORMATION)) - ); - fn test_field_AclRevision() { + test_field_Privileges(); + fn test_field_AuthenticationId() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACL_REVISION_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AclRevision) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AuthenticationId) as usize - ptr as usize }, - 0usize, + 24usize, concat!( "Offset of field: ", - stringify!(_ACL_REVISION_INFORMATION), + stringify!(_TOKEN_ACCESS_INFORMATION), "::", - stringify!(AclRevision) + stringify!(AuthenticationId) ) ); } - test_field_AclRevision(); -} -pub type ACL_REVISION_INFORMATION = _ACL_REVISION_INFORMATION; -pub type PACL_REVISION_INFORMATION = *mut ACL_REVISION_INFORMATION; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _ACL_SIZE_INFORMATION { - pub AceCount: DWORD, - pub AclBytesInUse: DWORD, - pub AclBytesFree: DWORD, -} -#[test] -fn bindgen_test_layout__ACL_SIZE_INFORMATION() { - assert_eq!( - ::std::mem::size_of::<_ACL_SIZE_INFORMATION>(), - 12usize, - concat!("Size of: ", stringify!(_ACL_SIZE_INFORMATION)) - ); - assert_eq!( - ::std::mem::align_of::<_ACL_SIZE_INFORMATION>(), - 4usize, - concat!("Alignment of ", stringify!(_ACL_SIZE_INFORMATION)) - ); - fn test_field_AceCount() { + test_field_AuthenticationId(); + fn test_field_TokenType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACL_SIZE_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AceCount) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).TokenType) as usize - ptr as usize }, - 0usize, + 32usize, concat!( "Offset of field: ", - stringify!(_ACL_SIZE_INFORMATION), + stringify!(_TOKEN_ACCESS_INFORMATION), "::", - stringify!(AceCount) + stringify!(TokenType) ) ); } - test_field_AceCount(); - fn test_field_AclBytesInUse() { + test_field_TokenType(); + fn test_field_ImpersonationLevel() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACL_SIZE_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AclBytesInUse) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ImpersonationLevel) as usize - ptr as usize }, - 4usize, + 36usize, concat!( "Offset of field: ", - stringify!(_ACL_SIZE_INFORMATION), + stringify!(_TOKEN_ACCESS_INFORMATION), "::", - stringify!(AclBytesInUse) + stringify!(ImpersonationLevel) ) ); } - test_field_AclBytesInUse(); - fn test_field_AclBytesFree() { + test_field_ImpersonationLevel(); + fn test_field_MandatoryPolicy() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACL_SIZE_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AclBytesFree) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).MandatoryPolicy) as usize - ptr as usize }, - 8usize, + 40usize, concat!( "Offset of field: ", - stringify!(_ACL_SIZE_INFORMATION), + stringify!(_TOKEN_ACCESS_INFORMATION), "::", - stringify!(AclBytesFree) + stringify!(MandatoryPolicy) ) ); } - test_field_AclBytesFree(); -} -pub type ACL_SIZE_INFORMATION = _ACL_SIZE_INFORMATION; -pub type PACL_SIZE_INFORMATION = *mut ACL_SIZE_INFORMATION; -pub type SECURITY_DESCRIPTOR_CONTROL = WORD; -pub type PSECURITY_DESCRIPTOR_CONTROL = *mut WORD; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SECURITY_DESCRIPTOR_RELATIVE { - pub Revision: BYTE, - pub Sbz1: BYTE, - pub Control: SECURITY_DESCRIPTOR_CONTROL, - pub Owner: DWORD, - pub Group: DWORD, - pub Sacl: DWORD, - pub Dacl: DWORD, -} -#[test] -fn bindgen_test_layout__SECURITY_DESCRIPTOR_RELATIVE() { - assert_eq!( - ::std::mem::size_of::<_SECURITY_DESCRIPTOR_RELATIVE>(), - 20usize, - concat!("Size of: ", stringify!(_SECURITY_DESCRIPTOR_RELATIVE)) - ); - assert_eq!( - ::std::mem::align_of::<_SECURITY_DESCRIPTOR_RELATIVE>(), - 4usize, - concat!("Alignment of ", stringify!(_SECURITY_DESCRIPTOR_RELATIVE)) - ); - fn test_field_Revision() { + test_field_MandatoryPolicy(); + fn test_field_Flags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR_RELATIVE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Revision) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, - 0usize, + 44usize, concat!( "Offset of field: ", - stringify!(_SECURITY_DESCRIPTOR_RELATIVE), + stringify!(_TOKEN_ACCESS_INFORMATION), "::", - stringify!(Revision) + stringify!(Flags) ) ); } - test_field_Revision(); - fn test_field_Sbz1() { + test_field_Flags(); + fn test_field_AppContainerNumber() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR_RELATIVE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Sbz1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AppContainerNumber) as usize - ptr as usize }, - 1usize, + 48usize, concat!( "Offset of field: ", - stringify!(_SECURITY_DESCRIPTOR_RELATIVE), + stringify!(_TOKEN_ACCESS_INFORMATION), "::", - stringify!(Sbz1) + stringify!(AppContainerNumber) ) ); } - test_field_Sbz1(); - fn test_field_Control() { + test_field_AppContainerNumber(); + fn test_field_PackageSid() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR_RELATIVE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Control) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).PackageSid) as usize - ptr as usize }, - 2usize, + 56usize, concat!( "Offset of field: ", - stringify!(_SECURITY_DESCRIPTOR_RELATIVE), + stringify!(_TOKEN_ACCESS_INFORMATION), "::", - stringify!(Control) + stringify!(PackageSid) ) ); } - test_field_Control(); - fn test_field_Owner() { + test_field_PackageSid(); + fn test_field_CapabilitiesHash() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR_RELATIVE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Owner) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).CapabilitiesHash) as usize - ptr as usize }, - 4usize, + 64usize, concat!( "Offset of field: ", - stringify!(_SECURITY_DESCRIPTOR_RELATIVE), + stringify!(_TOKEN_ACCESS_INFORMATION), "::", - stringify!(Owner) + stringify!(CapabilitiesHash) ) ); } - test_field_Owner(); - fn test_field_Group() { + test_field_CapabilitiesHash(); + fn test_field_TrustLevelSid() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR_RELATIVE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Group) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).TrustLevelSid) as usize - ptr as usize }, - 8usize, + 72usize, concat!( "Offset of field: ", - stringify!(_SECURITY_DESCRIPTOR_RELATIVE), + stringify!(_TOKEN_ACCESS_INFORMATION), "::", - stringify!(Group) + stringify!(TrustLevelSid) ) ); } - test_field_Group(); - fn test_field_Sacl() { + test_field_TrustLevelSid(); + fn test_field_SecurityAttributes() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR_RELATIVE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Sacl) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SecurityAttributes) as usize - ptr as usize }, - 12usize, + 80usize, concat!( "Offset of field: ", - stringify!(_SECURITY_DESCRIPTOR_RELATIVE), + stringify!(_TOKEN_ACCESS_INFORMATION), "::", - stringify!(Sacl) + stringify!(SecurityAttributes) ) ); } - test_field_Sacl(); - fn test_field_Dacl() { + test_field_SecurityAttributes(); +} +pub type TOKEN_ACCESS_INFORMATION = _TOKEN_ACCESS_INFORMATION; +pub type PTOKEN_ACCESS_INFORMATION = *mut _TOKEN_ACCESS_INFORMATION; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _TOKEN_AUDIT_POLICY { + pub PerUserPolicy: [BYTE; 30usize], +} +#[test] +fn bindgen_test_layout__TOKEN_AUDIT_POLICY() { + assert_eq!( + ::std::mem::size_of::<_TOKEN_AUDIT_POLICY>(), + 30usize, + concat!("Size of: ", stringify!(_TOKEN_AUDIT_POLICY)) + ); + assert_eq!( + ::std::mem::align_of::<_TOKEN_AUDIT_POLICY>(), + 1usize, + concat!("Alignment of ", stringify!(_TOKEN_AUDIT_POLICY)) + ); + fn test_field_PerUserPolicy() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR_RELATIVE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_AUDIT_POLICY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Dacl) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).PerUserPolicy) as usize - ptr as usize }, - 16usize, + 0usize, concat!( "Offset of field: ", - stringify!(_SECURITY_DESCRIPTOR_RELATIVE), + stringify!(_TOKEN_AUDIT_POLICY), "::", - stringify!(Dacl) + stringify!(PerUserPolicy) ) ); } - test_field_Dacl(); + test_field_PerUserPolicy(); } -pub type SECURITY_DESCRIPTOR_RELATIVE = _SECURITY_DESCRIPTOR_RELATIVE; -pub type PISECURITY_DESCRIPTOR_RELATIVE = *mut _SECURITY_DESCRIPTOR_RELATIVE; +pub type TOKEN_AUDIT_POLICY = _TOKEN_AUDIT_POLICY; +pub type PTOKEN_AUDIT_POLICY = *mut _TOKEN_AUDIT_POLICY; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _SECURITY_DESCRIPTOR { - pub Revision: BYTE, - pub Sbz1: BYTE, - pub Control: SECURITY_DESCRIPTOR_CONTROL, - pub Owner: PSID, - pub Group: PSID, - pub Sacl: PACL, - pub Dacl: PACL, +pub struct _TOKEN_SOURCE { + pub SourceName: [CHAR; 8usize], + pub SourceIdentifier: LUID, } #[test] -fn bindgen_test_layout__SECURITY_DESCRIPTOR() { +fn bindgen_test_layout__TOKEN_SOURCE() { assert_eq!( - ::std::mem::size_of::<_SECURITY_DESCRIPTOR>(), - 40usize, - concat!("Size of: ", stringify!(_SECURITY_DESCRIPTOR)) + ::std::mem::size_of::<_TOKEN_SOURCE>(), + 16usize, + concat!("Size of: ", stringify!(_TOKEN_SOURCE)) ); assert_eq!( - ::std::mem::align_of::<_SECURITY_DESCRIPTOR>(), - 8usize, - concat!("Alignment of ", stringify!(_SECURITY_DESCRIPTOR)) + ::std::mem::align_of::<_TOKEN_SOURCE>(), + 4usize, + concat!("Alignment of ", stringify!(_TOKEN_SOURCE)) ); - fn test_field_Revision() { + fn test_field_SourceName() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_SOURCE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Revision) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SourceName) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_SECURITY_DESCRIPTOR), + stringify!(_TOKEN_SOURCE), "::", - stringify!(Revision) + stringify!(SourceName) ) ); } - test_field_Revision(); - fn test_field_Sbz1() { + test_field_SourceName(); + fn test_field_SourceIdentifier() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_SOURCE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Sbz1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SourceIdentifier) as usize - ptr as usize }, - 1usize, + 8usize, concat!( "Offset of field: ", - stringify!(_SECURITY_DESCRIPTOR), + stringify!(_TOKEN_SOURCE), "::", - stringify!(Sbz1) + stringify!(SourceIdentifier) ) ); } - test_field_Sbz1(); - fn test_field_Control() { + test_field_SourceIdentifier(); +} +pub type TOKEN_SOURCE = _TOKEN_SOURCE; +pub type PTOKEN_SOURCE = *mut _TOKEN_SOURCE; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _TOKEN_STATISTICS { + pub TokenId: LUID, + pub AuthenticationId: LUID, + pub ExpirationTime: LARGE_INTEGER, + pub TokenType: TOKEN_TYPE, + pub ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL, + pub DynamicCharged: DWORD, + pub DynamicAvailable: DWORD, + pub GroupCount: DWORD, + pub PrivilegeCount: DWORD, + pub ModifiedId: LUID, +} +#[test] +fn bindgen_test_layout__TOKEN_STATISTICS() { + assert_eq!( + ::std::mem::size_of::<_TOKEN_STATISTICS>(), + 56usize, + concat!("Size of: ", stringify!(_TOKEN_STATISTICS)) + ); + assert_eq!( + ::std::mem::align_of::<_TOKEN_STATISTICS>(), + 8usize, + concat!("Alignment of ", stringify!(_TOKEN_STATISTICS)) + ); + fn test_field_TokenId() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_STATISTICS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Control) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).TokenId) as usize - ptr as usize }, - 2usize, + 0usize, concat!( "Offset of field: ", - stringify!(_SECURITY_DESCRIPTOR), + stringify!(_TOKEN_STATISTICS), "::", - stringify!(Control) + stringify!(TokenId) ) ); } - test_field_Control(); - fn test_field_Owner() { + test_field_TokenId(); + fn test_field_AuthenticationId() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_STATISTICS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Owner) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AuthenticationId) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_SECURITY_DESCRIPTOR), + stringify!(_TOKEN_STATISTICS), "::", - stringify!(Owner) + stringify!(AuthenticationId) ) ); } - test_field_Owner(); - fn test_field_Group() { + test_field_AuthenticationId(); + fn test_field_ExpirationTime() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_STATISTICS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Group) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ExpirationTime) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", - stringify!(_SECURITY_DESCRIPTOR), + stringify!(_TOKEN_STATISTICS), "::", - stringify!(Group) + stringify!(ExpirationTime) ) ); } - test_field_Group(); - fn test_field_Sacl() { + test_field_ExpirationTime(); + fn test_field_TokenType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_STATISTICS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Sacl) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).TokenType) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", - stringify!(_SECURITY_DESCRIPTOR), + stringify!(_TOKEN_STATISTICS), "::", - stringify!(Sacl) + stringify!(TokenType) ) ); } - test_field_Sacl(); - fn test_field_Dacl() { + test_field_TokenType(); + fn test_field_ImpersonationLevel() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_DESCRIPTOR>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_STATISTICS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Dacl) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ImpersonationLevel) as usize - ptr as usize }, - 32usize, + 28usize, concat!( "Offset of field: ", - stringify!(_SECURITY_DESCRIPTOR), + stringify!(_TOKEN_STATISTICS), "::", - stringify!(Dacl) + stringify!(ImpersonationLevel) ) ); } - test_field_Dacl(); -} -pub type SECURITY_DESCRIPTOR = _SECURITY_DESCRIPTOR; -pub type PISECURITY_DESCRIPTOR = *mut _SECURITY_DESCRIPTOR; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SECURITY_OBJECT_AI_PARAMS { - pub Size: DWORD, - pub ConstraintMask: DWORD, -} -#[test] -fn bindgen_test_layout__SECURITY_OBJECT_AI_PARAMS() { - assert_eq!( - ::std::mem::size_of::<_SECURITY_OBJECT_AI_PARAMS>(), - 8usize, - concat!("Size of: ", stringify!(_SECURITY_OBJECT_AI_PARAMS)) - ); - assert_eq!( - ::std::mem::align_of::<_SECURITY_OBJECT_AI_PARAMS>(), - 4usize, - concat!("Alignment of ", stringify!(_SECURITY_OBJECT_AI_PARAMS)) - ); - fn test_field_Size() { + test_field_ImpersonationLevel(); + fn test_field_DynamicCharged() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_OBJECT_AI_PARAMS>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_STATISTICS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Size) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).DynamicCharged) as usize - ptr as usize }, - 0usize, + 32usize, concat!( "Offset of field: ", - stringify!(_SECURITY_OBJECT_AI_PARAMS), + stringify!(_TOKEN_STATISTICS), "::", - stringify!(Size) + stringify!(DynamicCharged) ) ); } - test_field_Size(); - fn test_field_ConstraintMask() { + test_field_DynamicCharged(); + fn test_field_DynamicAvailable() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_OBJECT_AI_PARAMS>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_STATISTICS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ConstraintMask) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).DynamicAvailable) as usize - ptr as usize }, - 4usize, + 36usize, concat!( "Offset of field: ", - stringify!(_SECURITY_OBJECT_AI_PARAMS), + stringify!(_TOKEN_STATISTICS), "::", - stringify!(ConstraintMask) + stringify!(DynamicAvailable) ) ); } - test_field_ConstraintMask(); -} -pub type SECURITY_OBJECT_AI_PARAMS = _SECURITY_OBJECT_AI_PARAMS; -pub type PSECURITY_OBJECT_AI_PARAMS = *mut _SECURITY_OBJECT_AI_PARAMS; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _OBJECT_TYPE_LIST { - pub Level: WORD, - pub Sbz: WORD, - pub ObjectType: *mut GUID, -} -#[test] -fn bindgen_test_layout__OBJECT_TYPE_LIST() { - assert_eq!( - ::std::mem::size_of::<_OBJECT_TYPE_LIST>(), - 16usize, - concat!("Size of: ", stringify!(_OBJECT_TYPE_LIST)) - ); - assert_eq!( - ::std::mem::align_of::<_OBJECT_TYPE_LIST>(), - 8usize, - concat!("Alignment of ", stringify!(_OBJECT_TYPE_LIST)) - ); - fn test_field_Level() { + test_field_DynamicAvailable(); + fn test_field_GroupCount() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_OBJECT_TYPE_LIST>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_STATISTICS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Level) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).GroupCount) as usize - ptr as usize }, - 0usize, + 40usize, concat!( "Offset of field: ", - stringify!(_OBJECT_TYPE_LIST), + stringify!(_TOKEN_STATISTICS), "::", - stringify!(Level) + stringify!(GroupCount) ) ); } - test_field_Level(); - fn test_field_Sbz() { + test_field_GroupCount(); + fn test_field_PrivilegeCount() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_OBJECT_TYPE_LIST>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_STATISTICS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Sbz) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).PrivilegeCount) as usize - ptr as usize }, - 2usize, + 44usize, concat!( "Offset of field: ", - stringify!(_OBJECT_TYPE_LIST), + stringify!(_TOKEN_STATISTICS), "::", - stringify!(Sbz) + stringify!(PrivilegeCount) ) ); } - test_field_Sbz(); - fn test_field_ObjectType() { + test_field_PrivilegeCount(); + fn test_field_ModifiedId() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_OBJECT_TYPE_LIST>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_STATISTICS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ObjectType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ModifiedId) as usize - ptr as usize }, - 8usize, + 48usize, concat!( "Offset of field: ", - stringify!(_OBJECT_TYPE_LIST), + stringify!(_TOKEN_STATISTICS), "::", - stringify!(ObjectType) + stringify!(ModifiedId) ) ); } - test_field_ObjectType(); -} -pub type OBJECT_TYPE_LIST = _OBJECT_TYPE_LIST; -pub type POBJECT_TYPE_LIST = *mut _OBJECT_TYPE_LIST; -#[repr(i32)] -#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] -pub enum _AUDIT_EVENT_TYPE { - AuditEventObjectAccess = 0, - AuditEventDirectoryServiceAccess = 1, + test_field_ModifiedId(); } -pub use self::_AUDIT_EVENT_TYPE as AUDIT_EVENT_TYPE; -pub type PAUDIT_EVENT_TYPE = *mut _AUDIT_EVENT_TYPE; +pub type TOKEN_STATISTICS = _TOKEN_STATISTICS; +pub type PTOKEN_STATISTICS = *mut _TOKEN_STATISTICS; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _PRIVILEGE_SET { - pub PrivilegeCount: DWORD, - pub Control: DWORD, - pub Privilege: [LUID_AND_ATTRIBUTES; 1usize], +pub struct _TOKEN_CONTROL { + pub TokenId: LUID, + pub AuthenticationId: LUID, + pub ModifiedId: LUID, + pub TokenSource: TOKEN_SOURCE, } #[test] -fn bindgen_test_layout__PRIVILEGE_SET() { +fn bindgen_test_layout__TOKEN_CONTROL() { assert_eq!( - ::std::mem::size_of::<_PRIVILEGE_SET>(), - 20usize, - concat!("Size of: ", stringify!(_PRIVILEGE_SET)) + ::std::mem::size_of::<_TOKEN_CONTROL>(), + 40usize, + concat!("Size of: ", stringify!(_TOKEN_CONTROL)) ); assert_eq!( - ::std::mem::align_of::<_PRIVILEGE_SET>(), + ::std::mem::align_of::<_TOKEN_CONTROL>(), 4usize, - concat!("Alignment of ", stringify!(_PRIVILEGE_SET)) + concat!("Alignment of ", stringify!(_TOKEN_CONTROL)) ); - fn test_field_PrivilegeCount() { + fn test_field_TokenId() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_PRIVILEGE_SET>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_CONTROL>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).PrivilegeCount) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).TokenId) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_PRIVILEGE_SET), + stringify!(_TOKEN_CONTROL), "::", - stringify!(PrivilegeCount) + stringify!(TokenId) ) ); } - test_field_PrivilegeCount(); - fn test_field_Control() { + test_field_TokenId(); + fn test_field_AuthenticationId() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_PRIVILEGE_SET>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_CONTROL>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Control) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AuthenticationId) as usize - ptr as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", - stringify!(_PRIVILEGE_SET), + stringify!(_TOKEN_CONTROL), "::", - stringify!(Control) + stringify!(AuthenticationId) ) ); } - test_field_Control(); - fn test_field_Privilege() { + test_field_AuthenticationId(); + fn test_field_ModifiedId() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_PRIVILEGE_SET>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_CONTROL>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Privilege) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ModifiedId) as usize - ptr as usize }, - 8usize, + 16usize, concat!( "Offset of field: ", - stringify!(_PRIVILEGE_SET), + stringify!(_TOKEN_CONTROL), "::", - stringify!(Privilege) + stringify!(ModifiedId) ) ); } - test_field_Privilege(); + test_field_ModifiedId(); + fn test_field_TokenSource() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_TOKEN_CONTROL>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).TokenSource) as usize - ptr as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(_TOKEN_CONTROL), + "::", + stringify!(TokenSource) + ) + ); + } + test_field_TokenSource(); } -pub type PRIVILEGE_SET = _PRIVILEGE_SET; -pub type PPRIVILEGE_SET = *mut _PRIVILEGE_SET; +pub type TOKEN_CONTROL = _TOKEN_CONTROL; +pub type PTOKEN_CONTROL = *mut _TOKEN_CONTROL; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _TOKEN_ORIGIN { + pub OriginatingLogonSession: LUID, +} +#[test] +fn bindgen_test_layout__TOKEN_ORIGIN() { + assert_eq!( + ::std::mem::size_of::<_TOKEN_ORIGIN>(), + 8usize, + concat!("Size of: ", stringify!(_TOKEN_ORIGIN)) + ); + assert_eq!( + ::std::mem::align_of::<_TOKEN_ORIGIN>(), + 4usize, + concat!("Alignment of ", stringify!(_TOKEN_ORIGIN)) + ); + fn test_field_OriginatingLogonSession() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_TOKEN_ORIGIN>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).OriginatingLogonSession) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_TOKEN_ORIGIN), + "::", + stringify!(OriginatingLogonSession) + ) + ); + } + test_field_OriginatingLogonSession(); +} +pub type TOKEN_ORIGIN = _TOKEN_ORIGIN; +pub type PTOKEN_ORIGIN = *mut _TOKEN_ORIGIN; #[repr(i32)] #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] -pub enum _ACCESS_REASON_TYPE { - AccessReasonNone = 0, - AccessReasonAllowedAce = 65536, - AccessReasonDeniedAce = 131072, - AccessReasonAllowedParentAce = 196608, - AccessReasonDeniedParentAce = 262144, - AccessReasonNotGrantedByCape = 327680, - AccessReasonNotGrantedByParentCape = 393216, - AccessReasonNotGrantedToAppContainer = 458752, - AccessReasonMissingPrivilege = 1048576, - AccessReasonFromPrivilege = 2097152, - AccessReasonIntegrityLevel = 3145728, - AccessReasonOwnership = 4194304, - AccessReasonNullDacl = 5242880, - AccessReasonEmptyDacl = 6291456, - AccessReasonNoSD = 7340032, - AccessReasonNoGrant = 8388608, - AccessReasonTrustLabel = 9437184, - AccessReasonFilterAce = 10485760, +pub enum _MANDATORY_LEVEL { + MandatoryLevelUntrusted = 0, + MandatoryLevelLow = 1, + MandatoryLevelMedium = 2, + MandatoryLevelHigh = 3, + MandatoryLevelSystem = 4, + MandatoryLevelSecureProcess = 5, + MandatoryLevelCount = 6, } -pub use self::_ACCESS_REASON_TYPE as ACCESS_REASON_TYPE; -pub type ACCESS_REASON = DWORD; +pub use self::_MANDATORY_LEVEL as MANDATORY_LEVEL; +pub type PMANDATORY_LEVEL = *mut _MANDATORY_LEVEL; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _ACCESS_REASONS { - pub Data: [ACCESS_REASON; 32usize], +pub struct _TOKEN_APPCONTAINER_INFORMATION { + pub TokenAppContainer: PSID, } #[test] -fn bindgen_test_layout__ACCESS_REASONS() { +fn bindgen_test_layout__TOKEN_APPCONTAINER_INFORMATION() { assert_eq!( - ::std::mem::size_of::<_ACCESS_REASONS>(), - 128usize, - concat!("Size of: ", stringify!(_ACCESS_REASONS)) + ::std::mem::size_of::<_TOKEN_APPCONTAINER_INFORMATION>(), + 8usize, + concat!("Size of: ", stringify!(_TOKEN_APPCONTAINER_INFORMATION)) ); assert_eq!( - ::std::mem::align_of::<_ACCESS_REASONS>(), - 4usize, - concat!("Alignment of ", stringify!(_ACCESS_REASONS)) + ::std::mem::align_of::<_TOKEN_APPCONTAINER_INFORMATION>(), + 8usize, + concat!("Alignment of ", stringify!(_TOKEN_APPCONTAINER_INFORMATION)) ); - fn test_field_Data() { + fn test_field_TokenAppContainer() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_ACCESS_REASONS>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_APPCONTAINER_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Data) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).TokenAppContainer) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_ACCESS_REASONS), + stringify!(_TOKEN_APPCONTAINER_INFORMATION), "::", - stringify!(Data) + stringify!(TokenAppContainer) ) ); } - test_field_Data(); + test_field_TokenAppContainer(); } -pub type ACCESS_REASONS = _ACCESS_REASONS; -pub type PACCESS_REASONS = *mut _ACCESS_REASONS; +pub type TOKEN_APPCONTAINER_INFORMATION = _TOKEN_APPCONTAINER_INFORMATION; +pub type PTOKEN_APPCONTAINER_INFORMATION = *mut _TOKEN_APPCONTAINER_INFORMATION; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _SE_SECURITY_DESCRIPTOR { - pub Size: DWORD, - pub Flags: DWORD, - pub SecurityDescriptor: PSECURITY_DESCRIPTOR, +pub struct _TOKEN_SID_INFORMATION { + pub Sid: PSID, } #[test] -fn bindgen_test_layout__SE_SECURITY_DESCRIPTOR() { +fn bindgen_test_layout__TOKEN_SID_INFORMATION() { assert_eq!( - ::std::mem::size_of::<_SE_SECURITY_DESCRIPTOR>(), - 16usize, - concat!("Size of: ", stringify!(_SE_SECURITY_DESCRIPTOR)) + ::std::mem::size_of::<_TOKEN_SID_INFORMATION>(), + 8usize, + concat!("Size of: ", stringify!(_TOKEN_SID_INFORMATION)) ); assert_eq!( - ::std::mem::align_of::<_SE_SECURITY_DESCRIPTOR>(), + ::std::mem::align_of::<_TOKEN_SID_INFORMATION>(), 8usize, - concat!("Alignment of ", stringify!(_SE_SECURITY_DESCRIPTOR)) + concat!("Alignment of ", stringify!(_TOKEN_SID_INFORMATION)) ); - fn test_field_Size() { + fn test_field_Sid() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_SECURITY_DESCRIPTOR>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_SID_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Size) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Sid) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_SE_SECURITY_DESCRIPTOR), + stringify!(_TOKEN_SID_INFORMATION), "::", - stringify!(Size) + stringify!(Sid) ) ); } - test_field_Size(); - fn test_field_Flags() { + test_field_Sid(); +} +pub type TOKEN_SID_INFORMATION = _TOKEN_SID_INFORMATION; +pub type PTOKEN_SID_INFORMATION = *mut _TOKEN_SID_INFORMATION; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _TOKEN_BNO_ISOLATION_INFORMATION { + pub IsolationPrefix: PWSTR, + pub IsolationEnabled: BOOLEAN, +} +#[test] +fn bindgen_test_layout__TOKEN_BNO_ISOLATION_INFORMATION() { + assert_eq!( + ::std::mem::size_of::<_TOKEN_BNO_ISOLATION_INFORMATION>(), + 16usize, + concat!("Size of: ", stringify!(_TOKEN_BNO_ISOLATION_INFORMATION)) + ); + assert_eq!( + ::std::mem::align_of::<_TOKEN_BNO_ISOLATION_INFORMATION>(), + 8usize, + concat!( + "Alignment of ", + stringify!(_TOKEN_BNO_ISOLATION_INFORMATION) + ) + ); + fn test_field_IsolationPrefix() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_SECURITY_DESCRIPTOR>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_BNO_ISOLATION_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).IsolationPrefix) as usize - ptr as usize }, - 4usize, + 0usize, concat!( "Offset of field: ", - stringify!(_SE_SECURITY_DESCRIPTOR), + stringify!(_TOKEN_BNO_ISOLATION_INFORMATION), "::", - stringify!(Flags) + stringify!(IsolationPrefix) ) ); } - test_field_Flags(); - fn test_field_SecurityDescriptor() { + test_field_IsolationPrefix(); + fn test_field_IsolationEnabled() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_SECURITY_DESCRIPTOR>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_TOKEN_BNO_ISOLATION_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SecurityDescriptor) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).IsolationEnabled) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_SE_SECURITY_DESCRIPTOR), + stringify!(_TOKEN_BNO_ISOLATION_INFORMATION), "::", - stringify!(SecurityDescriptor) + stringify!(IsolationEnabled) ) ); } - test_field_SecurityDescriptor(); + test_field_IsolationEnabled(); } -pub type SE_SECURITY_DESCRIPTOR = _SE_SECURITY_DESCRIPTOR; -pub type PSE_SECURITY_DESCRIPTOR = *mut _SE_SECURITY_DESCRIPTOR; +pub type TOKEN_BNO_ISOLATION_INFORMATION = _TOKEN_BNO_ISOLATION_INFORMATION; +pub type PTOKEN_BNO_ISOLATION_INFORMATION = *mut _TOKEN_BNO_ISOLATION_INFORMATION; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _SE_ACCESS_REQUEST { - pub Size: DWORD, - pub SeSecurityDescriptor: PSE_SECURITY_DESCRIPTOR, - pub DesiredAccess: ACCESS_MASK, - pub PreviouslyGrantedAccess: ACCESS_MASK, - pub PrincipalSelfSid: PSID, - pub GenericMapping: PGENERIC_MAPPING, - pub ObjectTypeListCount: DWORD, - pub ObjectTypeList: POBJECT_TYPE_LIST, +pub struct _CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE { + pub Version: DWORD64, + pub Name: PWSTR, } #[test] -fn bindgen_test_layout__SE_ACCESS_REQUEST() { +fn bindgen_test_layout__CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE() { assert_eq!( - ::std::mem::size_of::<_SE_ACCESS_REQUEST>(), - 56usize, - concat!("Size of: ", stringify!(_SE_ACCESS_REQUEST)) + ::std::mem::size_of::<_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE>(), + 16usize, + concat!( + "Size of: ", + stringify!(_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE) + ) ); assert_eq!( - ::std::mem::align_of::<_SE_ACCESS_REQUEST>(), + ::std::mem::align_of::<_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE>(), 8usize, - concat!("Alignment of ", stringify!(_SE_ACCESS_REQUEST)) + concat!( + "Alignment of ", + stringify!(_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE) + ) ); - fn test_field_Size() { + fn test_field_Version() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REQUEST>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Size) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Version) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_SE_ACCESS_REQUEST), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE), "::", - stringify!(Size) + stringify!(Version) ) ); } - test_field_Size(); - fn test_field_SeSecurityDescriptor() { + test_field_Version(); + fn test_field_Name() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REQUEST>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SeSecurityDescriptor) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Name) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_SE_ACCESS_REQUEST), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE), "::", - stringify!(SeSecurityDescriptor) + stringify!(Name) ) ); } - test_field_SeSecurityDescriptor(); - fn test_field_DesiredAccess() { + test_field_Name(); +} +pub type CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE = _CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE; +pub type PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE = *mut _CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE { + pub pValue: PVOID, + pub ValueLength: DWORD, +} +#[test] +fn bindgen_test_layout__CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE() { + assert_eq!( + ::std::mem::size_of::<_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE>(), + 16usize, + concat!( + "Size of: ", + stringify!(_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE) + ) + ); + assert_eq!( + ::std::mem::align_of::<_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE>(), + 8usize, + concat!( + "Alignment of ", + stringify!(_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE) + ) + ); + fn test_field_pValue() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REQUEST>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE>::uninit( + ); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).DesiredAccess) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).pValue) as usize - ptr as usize }, - 16usize, + 0usize, concat!( "Offset of field: ", - stringify!(_SE_ACCESS_REQUEST), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE), "::", - stringify!(DesiredAccess) + stringify!(pValue) ) ); } - test_field_DesiredAccess(); - fn test_field_PreviouslyGrantedAccess() { + test_field_pValue(); + fn test_field_ValueLength() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REQUEST>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE>::uninit( + ); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).PreviouslyGrantedAccess) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ValueLength) as usize - ptr as usize }, - 20usize, + 8usize, concat!( "Offset of field: ", - stringify!(_SE_ACCESS_REQUEST), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE), "::", - stringify!(PreviouslyGrantedAccess) + stringify!(ValueLength) ) ); } - test_field_PreviouslyGrantedAccess(); - fn test_field_PrincipalSelfSid() { + test_field_ValueLength(); +} +pub type CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE = _CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE; +pub type PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE = + *mut _CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _CLAIM_SECURITY_ATTRIBUTE_V1 { + pub Name: PWSTR, + pub ValueType: WORD, + pub Reserved: WORD, + pub Flags: DWORD, + pub ValueCount: DWORD, + pub Values: _CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1 { + pub pInt64: PLONG64, + pub pUint64: PDWORD64, + pub ppString: *mut PWSTR, + pub pFqbn: PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE, + pub pOctetString: PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE, +} +#[test] +fn bindgen_test_layout__CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1>(), + 8usize, + concat!( + "Size of: ", + stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1) + ) + ); + assert_eq!( + ::std::mem::align_of::<_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1>(), + 8usize, + concat!( + "Alignment of ", + stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1) + ) + ); + fn test_field_pInt64() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REQUEST>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).PrincipalSelfSid) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).pInt64) as usize - ptr as usize }, - 24usize, + 0usize, concat!( "Offset of field: ", - stringify!(_SE_ACCESS_REQUEST), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1), "::", - stringify!(PrincipalSelfSid) + stringify!(pInt64) ) ); } - test_field_PrincipalSelfSid(); - fn test_field_GenericMapping() { + test_field_pInt64(); + fn test_field_pUint64() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REQUEST>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).GenericMapping) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).pUint64) as usize - ptr as usize }, - 32usize, + 0usize, concat!( "Offset of field: ", - stringify!(_SE_ACCESS_REQUEST), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1), "::", - stringify!(GenericMapping) + stringify!(pUint64) ) ); } - test_field_GenericMapping(); - fn test_field_ObjectTypeListCount() { + test_field_pUint64(); + fn test_field_ppString() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REQUEST>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ObjectTypeListCount) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ppString) as usize - ptr as usize }, - 40usize, + 0usize, concat!( "Offset of field: ", - stringify!(_SE_ACCESS_REQUEST), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1), "::", - stringify!(ObjectTypeListCount) + stringify!(ppString) ) ); } - test_field_ObjectTypeListCount(); - fn test_field_ObjectTypeList() { + test_field_ppString(); + fn test_field_pFqbn() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REQUEST>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ObjectTypeList) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).pFqbn) as usize - ptr as usize }, - 48usize, + 0usize, concat!( "Offset of field: ", - stringify!(_SE_ACCESS_REQUEST), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1), "::", - stringify!(ObjectTypeList) + stringify!(pFqbn) ) ); } - test_field_ObjectTypeList(); -} -pub type SE_ACCESS_REQUEST = _SE_ACCESS_REQUEST; -pub type PSE_ACCESS_REQUEST = *mut _SE_ACCESS_REQUEST; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SE_ACCESS_REPLY { - pub Size: DWORD, - pub ResultListCount: DWORD, - pub GrantedAccess: PACCESS_MASK, - pub AccessStatus: PDWORD, - pub AccessReason: PACCESS_REASONS, - pub Privileges: *mut PPRIVILEGE_SET, + test_field_pFqbn(); + fn test_field_pOctetString() { + assert_eq!( + unsafe { + let uninit = + ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).pOctetString) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1), + "::", + stringify!(pOctetString) + ) + ); + } + test_field_pOctetString(); } #[test] -fn bindgen_test_layout__SE_ACCESS_REPLY() { +fn bindgen_test_layout__CLAIM_SECURITY_ATTRIBUTE_V1() { assert_eq!( - ::std::mem::size_of::<_SE_ACCESS_REPLY>(), - 40usize, - concat!("Size of: ", stringify!(_SE_ACCESS_REPLY)) + ::std::mem::size_of::<_CLAIM_SECURITY_ATTRIBUTE_V1>(), + 32usize, + concat!("Size of: ", stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1)) ); assert_eq!( - ::std::mem::align_of::<_SE_ACCESS_REPLY>(), + ::std::mem::align_of::<_CLAIM_SECURITY_ATTRIBUTE_V1>(), 8usize, - concat!("Alignment of ", stringify!(_SE_ACCESS_REPLY)) + concat!("Alignment of ", stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1)) ); - fn test_field_Size() { + fn test_field_Name() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REPLY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Size) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Name) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_SE_ACCESS_REPLY), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1), "::", - stringify!(Size) + stringify!(Name) ) ); } - test_field_Size(); - fn test_field_ResultListCount() { + test_field_Name(); + fn test_field_ValueType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REPLY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ResultListCount) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ValueType) as usize - ptr as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", - stringify!(_SE_ACCESS_REPLY), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1), "::", - stringify!(ResultListCount) + stringify!(ValueType) ) ); } - test_field_ResultListCount(); - fn test_field_GrantedAccess() { + test_field_ValueType(); + fn test_field_Reserved() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REPLY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).GrantedAccess) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize }, - 8usize, + 10usize, concat!( "Offset of field: ", - stringify!(_SE_ACCESS_REPLY), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1), "::", - stringify!(GrantedAccess) + stringify!(Reserved) ) ); } - test_field_GrantedAccess(); - fn test_field_AccessStatus() { + test_field_Reserved(); + fn test_field_Flags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REPLY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AccessStatus) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, - 16usize, + 12usize, concat!( "Offset of field: ", - stringify!(_SE_ACCESS_REPLY), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1), "::", - stringify!(AccessStatus) + stringify!(Flags) ) ); } - test_field_AccessStatus(); - fn test_field_AccessReason() { + test_field_Flags(); + fn test_field_ValueCount() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REPLY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AccessReason) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ValueCount) as usize - ptr as usize }, - 24usize, + 16usize, concat!( "Offset of field: ", - stringify!(_SE_ACCESS_REPLY), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1), "::", - stringify!(AccessReason) + stringify!(ValueCount) ) ); } - test_field_AccessReason(); - fn test_field_Privileges() { + test_field_ValueCount(); + fn test_field_Values() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_ACCESS_REPLY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Privileges) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Values) as usize - ptr as usize }, - 32usize, + 24usize, concat!( "Offset of field: ", - stringify!(_SE_ACCESS_REPLY), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1), "::", - stringify!(Privileges) + stringify!(Values) ) ); } - test_field_Privileges(); -} -pub type SE_ACCESS_REPLY = _SE_ACCESS_REPLY; -pub type PSE_ACCESS_REPLY = *mut _SE_ACCESS_REPLY; -#[repr(i32)] -#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] -pub enum _SECURITY_IMPERSONATION_LEVEL { - SecurityAnonymous = 0, - SecurityIdentification = 1, - SecurityImpersonation = 2, - SecurityDelegation = 3, -} -pub use self::_SECURITY_IMPERSONATION_LEVEL as SECURITY_IMPERSONATION_LEVEL; -pub type PSECURITY_IMPERSONATION_LEVEL = *mut _SECURITY_IMPERSONATION_LEVEL; -#[repr(i32)] -#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] -pub enum _TOKEN_TYPE { - TokenPrimary = 1, - TokenImpersonation = 2, -} -pub use self::_TOKEN_TYPE as TOKEN_TYPE; -pub type PTOKEN_TYPE = *mut TOKEN_TYPE; -#[repr(i32)] -#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] -pub enum _TOKEN_ELEVATION_TYPE { - TokenElevationTypeDefault = 1, - TokenElevationTypeFull = 2, - TokenElevationTypeLimited = 3, + test_field_Values(); } -pub use self::_TOKEN_ELEVATION_TYPE as TOKEN_ELEVATION_TYPE; -pub type PTOKEN_ELEVATION_TYPE = *mut _TOKEN_ELEVATION_TYPE; -#[repr(i32)] -#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] -pub enum _TOKEN_INFORMATION_CLASS { - TokenUser = 1, - TokenGroups = 2, - TokenPrivileges = 3, - TokenOwner = 4, - TokenPrimaryGroup = 5, - TokenDefaultDacl = 6, - TokenSource = 7, - TokenType = 8, - TokenImpersonationLevel = 9, - TokenStatistics = 10, - TokenRestrictedSids = 11, - TokenSessionId = 12, - TokenGroupsAndPrivileges = 13, - TokenSessionReference = 14, - TokenSandBoxInert = 15, - TokenAuditPolicy = 16, - TokenOrigin = 17, - TokenElevationType = 18, - TokenLinkedToken = 19, - TokenElevation = 20, - TokenHasRestrictions = 21, - TokenAccessInformation = 22, - TokenVirtualizationAllowed = 23, - TokenVirtualizationEnabled = 24, - TokenIntegrityLevel = 25, - TokenUIAccess = 26, - TokenMandatoryPolicy = 27, - TokenLogonSid = 28, - TokenIsAppContainer = 29, - TokenCapabilities = 30, - TokenAppContainerSid = 31, - TokenAppContainerNumber = 32, - TokenUserClaimAttributes = 33, - TokenDeviceClaimAttributes = 34, - TokenRestrictedUserClaimAttributes = 35, - TokenRestrictedDeviceClaimAttributes = 36, - TokenDeviceGroups = 37, - TokenRestrictedDeviceGroups = 38, - TokenSecurityAttributes = 39, - TokenIsRestricted = 40, - TokenProcessTrustLevel = 41, - TokenPrivateNameSpace = 42, - TokenSingletonAttributes = 43, - TokenBnoIsolation = 44, - TokenChildProcessFlags = 45, - TokenIsLessPrivilegedAppContainer = 46, - TokenIsSandboxed = 47, - TokenIsAppSilo = 48, - MaxTokenInfoClass = 49, +pub type CLAIM_SECURITY_ATTRIBUTE_V1 = _CLAIM_SECURITY_ATTRIBUTE_V1; +pub type PCLAIM_SECURITY_ATTRIBUTE_V1 = *mut _CLAIM_SECURITY_ATTRIBUTE_V1; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 { + pub Name: DWORD, + pub ValueType: WORD, + pub Reserved: WORD, + pub Flags: DWORD, + pub ValueCount: DWORD, + pub Values: _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1, } -pub use self::_TOKEN_INFORMATION_CLASS as TOKEN_INFORMATION_CLASS; -pub type PTOKEN_INFORMATION_CLASS = *mut _TOKEN_INFORMATION_CLASS; #[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _TOKEN_USER { - pub User: SID_AND_ATTRIBUTES, +#[derive(Copy, Clone)] +pub union _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1 { + pub pInt64: [DWORD; 1usize], + pub pUint64: [DWORD; 1usize], + pub ppString: [DWORD; 1usize], + pub pFqbn: [DWORD; 1usize], + pub pOctetString: [DWORD; 1usize], } #[test] -fn bindgen_test_layout__TOKEN_USER() { +fn bindgen_test_layout__CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_TOKEN_USER>(), - 16usize, - concat!("Size of: ", stringify!(_TOKEN_USER)) + ::std::mem::size_of::<_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1>(), + 4usize, + concat!( + "Size of: ", + stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1) + ) ); assert_eq!( - ::std::mem::align_of::<_TOKEN_USER>(), - 8usize, - concat!("Alignment of ", stringify!(_TOKEN_USER)) + ::std::mem::align_of::<_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1>(), + 4usize, + concat!( + "Alignment of ", + stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1) + ) ); - fn test_field_User() { + fn test_field_pInt64() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_USER>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).User) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).pInt64) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_USER), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1), "::", - stringify!(User) + stringify!(pInt64) ) ); } - test_field_User(); -} -pub type TOKEN_USER = _TOKEN_USER; -pub type PTOKEN_USER = *mut _TOKEN_USER; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _SE_TOKEN_USER { - pub __bindgen_anon_1: _SE_TOKEN_USER__bindgen_ty_1, - pub __bindgen_anon_2: _SE_TOKEN_USER__bindgen_ty_2, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _SE_TOKEN_USER__bindgen_ty_1 { - pub TokenUser: TOKEN_USER, - pub User: SID_AND_ATTRIBUTES, -} -#[test] -fn bindgen_test_layout__SE_TOKEN_USER__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_SE_TOKEN_USER__bindgen_ty_1>(), - 16usize, - concat!("Size of: ", stringify!(_SE_TOKEN_USER__bindgen_ty_1)) - ); - assert_eq!( - ::std::mem::align_of::<_SE_TOKEN_USER__bindgen_ty_1>(), - 8usize, - concat!("Alignment of ", stringify!(_SE_TOKEN_USER__bindgen_ty_1)) - ); - fn test_field_TokenUser() { + test_field_pInt64(); + fn test_field_pUint64() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_TOKEN_USER__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).TokenUser) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).pUint64) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_SE_TOKEN_USER__bindgen_ty_1), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1), "::", - stringify!(TokenUser) + stringify!(pUint64) ) ); } - test_field_TokenUser(); - fn test_field_User() { + test_field_pUint64(); + fn test_field_ppString() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_TOKEN_USER__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).User) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ppString) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_SE_TOKEN_USER__bindgen_ty_1), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1), "::", - stringify!(User) + stringify!(ppString) ) ); } - test_field_User(); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _SE_TOKEN_USER__bindgen_ty_2 { - pub Sid: SID, - pub Buffer: [BYTE; 68usize], -} -#[test] -fn bindgen_test_layout__SE_TOKEN_USER__bindgen_ty_2() { - assert_eq!( - ::std::mem::size_of::<_SE_TOKEN_USER__bindgen_ty_2>(), - 68usize, - concat!("Size of: ", stringify!(_SE_TOKEN_USER__bindgen_ty_2)) - ); - assert_eq!( - ::std::mem::align_of::<_SE_TOKEN_USER__bindgen_ty_2>(), - 4usize, - concat!("Alignment of ", stringify!(_SE_TOKEN_USER__bindgen_ty_2)) - ); - fn test_field_Sid() { + test_field_ppString(); + fn test_field_pFqbn() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_TOKEN_USER__bindgen_ty_2>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Sid) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).pFqbn) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_SE_TOKEN_USER__bindgen_ty_2), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1), "::", - stringify!(Sid) + stringify!(pFqbn) ) ); } - test_field_Sid(); - fn test_field_Buffer() { + test_field_pFqbn(); + fn test_field_pOctetString() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_TOKEN_USER__bindgen_ty_2>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Buffer) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).pOctetString) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_SE_TOKEN_USER__bindgen_ty_2), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1), "::", - stringify!(Buffer) + stringify!(pOctetString) ) ); } - test_field_Buffer(); -} -#[test] -fn bindgen_test_layout__SE_TOKEN_USER() { - assert_eq!( - ::std::mem::size_of::<_SE_TOKEN_USER>(), - 88usize, - concat!("Size of: ", stringify!(_SE_TOKEN_USER)) - ); - assert_eq!( - ::std::mem::align_of::<_SE_TOKEN_USER>(), - 8usize, - concat!("Alignment of ", stringify!(_SE_TOKEN_USER)) - ); -} -pub type SE_TOKEN_USER = _SE_TOKEN_USER; -pub type PSE_TOKEN_USER = _SE_TOKEN_USER; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _TOKEN_GROUPS { - pub GroupCount: DWORD, - pub Groups: [SID_AND_ATTRIBUTES; 1usize], + test_field_pOctetString(); } #[test] -fn bindgen_test_layout__TOKEN_GROUPS() { +fn bindgen_test_layout__CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1() { assert_eq!( - ::std::mem::size_of::<_TOKEN_GROUPS>(), - 24usize, - concat!("Size of: ", stringify!(_TOKEN_GROUPS)) + ::std::mem::size_of::<_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1>(), + 20usize, + concat!( + "Size of: ", + stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1) + ) ); assert_eq!( - ::std::mem::align_of::<_TOKEN_GROUPS>(), - 8usize, - concat!("Alignment of ", stringify!(_TOKEN_GROUPS)) + ::std::mem::align_of::<_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1>(), + 4usize, + concat!( + "Alignment of ", + stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1) + ) ); - fn test_field_GroupCount() { + fn test_field_Name() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).GroupCount) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Name) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_GROUPS), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1), "::", - stringify!(GroupCount) + stringify!(Name) ) ); } - test_field_GroupCount(); - fn test_field_Groups() { + test_field_Name(); + fn test_field_ValueType() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Groups) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ValueType) as usize - ptr as usize }, - 8usize, + 4usize, concat!( "Offset of field: ", - stringify!(_TOKEN_GROUPS), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1), "::", - stringify!(Groups) + stringify!(ValueType) ) ); } - test_field_Groups(); -} -pub type TOKEN_GROUPS = _TOKEN_GROUPS; -pub type PTOKEN_GROUPS = *mut _TOKEN_GROUPS; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _TOKEN_PRIVILEGES { - pub PrivilegeCount: DWORD, - pub Privileges: [LUID_AND_ATTRIBUTES; 1usize], -} -#[test] -fn bindgen_test_layout__TOKEN_PRIVILEGES() { - assert_eq!( - ::std::mem::size_of::<_TOKEN_PRIVILEGES>(), - 16usize, - concat!("Size of: ", stringify!(_TOKEN_PRIVILEGES)) - ); - assert_eq!( - ::std::mem::align_of::<_TOKEN_PRIVILEGES>(), - 4usize, - concat!("Alignment of ", stringify!(_TOKEN_PRIVILEGES)) - ); - fn test_field_PrivilegeCount() { + test_field_ValueType(); + fn test_field_Reserved() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_PRIVILEGES>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).PrivilegeCount) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize }, - 0usize, + 6usize, concat!( "Offset of field: ", - stringify!(_TOKEN_PRIVILEGES), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1), "::", - stringify!(PrivilegeCount) + stringify!(Reserved) ) ); } - test_field_PrivilegeCount(); - fn test_field_Privileges() { + test_field_Reserved(); + fn test_field_Flags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_PRIVILEGES>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Privileges) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", - stringify!(_TOKEN_PRIVILEGES), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1), "::", - stringify!(Privileges) + stringify!(Flags) ) ); } - test_field_Privileges(); -} -pub type TOKEN_PRIVILEGES = _TOKEN_PRIVILEGES; -pub type PTOKEN_PRIVILEGES = *mut _TOKEN_PRIVILEGES; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _TOKEN_OWNER { - pub Owner: PSID, -} -#[test] -fn bindgen_test_layout__TOKEN_OWNER() { - assert_eq!( - ::std::mem::size_of::<_TOKEN_OWNER>(), - 8usize, - concat!("Size of: ", stringify!(_TOKEN_OWNER)) - ); - assert_eq!( - ::std::mem::align_of::<_TOKEN_OWNER>(), - 8usize, - concat!("Alignment of ", stringify!(_TOKEN_OWNER)) - ); - fn test_field_Owner() { + test_field_Flags(); + fn test_field_ValueCount() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_OWNER>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Owner) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ValueCount) as usize - ptr as usize }, - 0usize, + 12usize, concat!( "Offset of field: ", - stringify!(_TOKEN_OWNER), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1), "::", - stringify!(Owner) + stringify!(ValueCount) ) ); } - test_field_Owner(); -} -pub type TOKEN_OWNER = _TOKEN_OWNER; -pub type PTOKEN_OWNER = *mut _TOKEN_OWNER; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _TOKEN_PRIMARY_GROUP { - pub PrimaryGroup: PSID, -} -#[test] -fn bindgen_test_layout__TOKEN_PRIMARY_GROUP() { - assert_eq!( - ::std::mem::size_of::<_TOKEN_PRIMARY_GROUP>(), - 8usize, - concat!("Size of: ", stringify!(_TOKEN_PRIMARY_GROUP)) - ); - assert_eq!( - ::std::mem::align_of::<_TOKEN_PRIMARY_GROUP>(), - 8usize, - concat!("Alignment of ", stringify!(_TOKEN_PRIMARY_GROUP)) - ); - fn test_field_PrimaryGroup() { + test_field_ValueCount(); + fn test_field_Values() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_PRIMARY_GROUP>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).PrimaryGroup) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Values) as usize - ptr as usize }, - 0usize, + 16usize, concat!( "Offset of field: ", - stringify!(_TOKEN_PRIMARY_GROUP), + stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1), "::", - stringify!(PrimaryGroup) + stringify!(Values) ) ); } - test_field_PrimaryGroup(); + test_field_Values(); } -pub type TOKEN_PRIMARY_GROUP = _TOKEN_PRIMARY_GROUP; -pub type PTOKEN_PRIMARY_GROUP = *mut _TOKEN_PRIMARY_GROUP; +pub type CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 = _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1; +pub type PCLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 = *mut _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1; #[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _TOKEN_DEFAULT_DACL { - pub DefaultDacl: PACL, +#[derive(Copy, Clone)] +pub struct _CLAIM_SECURITY_ATTRIBUTES_INFORMATION { + pub Version: WORD, + pub Reserved: WORD, + pub AttributeCount: DWORD, + pub Attribute: _CLAIM_SECURITY_ATTRIBUTES_INFORMATION__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _CLAIM_SECURITY_ATTRIBUTES_INFORMATION__bindgen_ty_1 { + pub pAttributeV1: PCLAIM_SECURITY_ATTRIBUTE_V1, } #[test] -fn bindgen_test_layout__TOKEN_DEFAULT_DACL() { +fn bindgen_test_layout__CLAIM_SECURITY_ATTRIBUTES_INFORMATION__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_TOKEN_DEFAULT_DACL>(), + ::std::mem::size_of::<_CLAIM_SECURITY_ATTRIBUTES_INFORMATION__bindgen_ty_1>(), 8usize, - concat!("Size of: ", stringify!(_TOKEN_DEFAULT_DACL)) + concat!( + "Size of: ", + stringify!(_CLAIM_SECURITY_ATTRIBUTES_INFORMATION__bindgen_ty_1) + ) ); assert_eq!( - ::std::mem::align_of::<_TOKEN_DEFAULT_DACL>(), + ::std::mem::align_of::<_CLAIM_SECURITY_ATTRIBUTES_INFORMATION__bindgen_ty_1>(), 8usize, - concat!("Alignment of ", stringify!(_TOKEN_DEFAULT_DACL)) + concat!( + "Alignment of ", + stringify!(_CLAIM_SECURITY_ATTRIBUTES_INFORMATION__bindgen_ty_1) + ) ); - fn test_field_DefaultDacl() { + fn test_field_pAttributeV1() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_DEFAULT_DACL>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _CLAIM_SECURITY_ATTRIBUTES_INFORMATION__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).DefaultDacl) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).pAttributeV1) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_DEFAULT_DACL), + stringify!(_CLAIM_SECURITY_ATTRIBUTES_INFORMATION__bindgen_ty_1), "::", - stringify!(DefaultDacl) + stringify!(pAttributeV1) ) ); } - test_field_DefaultDacl(); -} -pub type TOKEN_DEFAULT_DACL = _TOKEN_DEFAULT_DACL; -pub type PTOKEN_DEFAULT_DACL = *mut _TOKEN_DEFAULT_DACL; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _TOKEN_USER_CLAIMS { - pub UserClaims: PCLAIMS_BLOB, + test_field_pAttributeV1(); } #[test] -fn bindgen_test_layout__TOKEN_USER_CLAIMS() { +fn bindgen_test_layout__CLAIM_SECURITY_ATTRIBUTES_INFORMATION() { assert_eq!( - ::std::mem::size_of::<_TOKEN_USER_CLAIMS>(), - 8usize, - concat!("Size of: ", stringify!(_TOKEN_USER_CLAIMS)) + ::std::mem::size_of::<_CLAIM_SECURITY_ATTRIBUTES_INFORMATION>(), + 16usize, + concat!( + "Size of: ", + stringify!(_CLAIM_SECURITY_ATTRIBUTES_INFORMATION) + ) ); assert_eq!( - ::std::mem::align_of::<_TOKEN_USER_CLAIMS>(), + ::std::mem::align_of::<_CLAIM_SECURITY_ATTRIBUTES_INFORMATION>(), 8usize, - concat!("Alignment of ", stringify!(_TOKEN_USER_CLAIMS)) + concat!( + "Alignment of ", + stringify!(_CLAIM_SECURITY_ATTRIBUTES_INFORMATION) + ) ); - fn test_field_UserClaims() { + fn test_field_Version() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_USER_CLAIMS>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTES_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).UserClaims) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Version) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_USER_CLAIMS), + stringify!(_CLAIM_SECURITY_ATTRIBUTES_INFORMATION), "::", - stringify!(UserClaims) + stringify!(Version) ) ); } - test_field_UserClaims(); -} -pub type TOKEN_USER_CLAIMS = _TOKEN_USER_CLAIMS; -pub type PTOKEN_USER_CLAIMS = *mut _TOKEN_USER_CLAIMS; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _TOKEN_DEVICE_CLAIMS { - pub DeviceClaims: PCLAIMS_BLOB, -} -#[test] -fn bindgen_test_layout__TOKEN_DEVICE_CLAIMS() { - assert_eq!( - ::std::mem::size_of::<_TOKEN_DEVICE_CLAIMS>(), - 8usize, - concat!("Size of: ", stringify!(_TOKEN_DEVICE_CLAIMS)) - ); - assert_eq!( - ::std::mem::align_of::<_TOKEN_DEVICE_CLAIMS>(), - 8usize, - concat!("Alignment of ", stringify!(_TOKEN_DEVICE_CLAIMS)) - ); - fn test_field_DeviceClaims() { + test_field_Version(); + fn test_field_Reserved() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_DEVICE_CLAIMS>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTES_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).DeviceClaims) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize }, - 0usize, + 2usize, concat!( "Offset of field: ", - stringify!(_TOKEN_DEVICE_CLAIMS), + stringify!(_CLAIM_SECURITY_ATTRIBUTES_INFORMATION), "::", - stringify!(DeviceClaims) + stringify!(Reserved) ) ); } - test_field_DeviceClaims(); -} -pub type TOKEN_DEVICE_CLAIMS = _TOKEN_DEVICE_CLAIMS; -pub type PTOKEN_DEVICE_CLAIMS = *mut _TOKEN_DEVICE_CLAIMS; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _TOKEN_GROUPS_AND_PRIVILEGES { - pub SidCount: DWORD, - pub SidLength: DWORD, - pub Sids: PSID_AND_ATTRIBUTES, - pub RestrictedSidCount: DWORD, - pub RestrictedSidLength: DWORD, - pub RestrictedSids: PSID_AND_ATTRIBUTES, - pub PrivilegeCount: DWORD, - pub PrivilegeLength: DWORD, - pub Privileges: PLUID_AND_ATTRIBUTES, - pub AuthenticationId: LUID, -} -#[test] -fn bindgen_test_layout__TOKEN_GROUPS_AND_PRIVILEGES() { - assert_eq!( - ::std::mem::size_of::<_TOKEN_GROUPS_AND_PRIVILEGES>(), - 56usize, - concat!("Size of: ", stringify!(_TOKEN_GROUPS_AND_PRIVILEGES)) - ); - assert_eq!( - ::std::mem::align_of::<_TOKEN_GROUPS_AND_PRIVILEGES>(), - 8usize, - concat!("Alignment of ", stringify!(_TOKEN_GROUPS_AND_PRIVILEGES)) - ); - fn test_field_SidCount() { + test_field_Reserved(); + fn test_field_AttributeCount() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS_AND_PRIVILEGES>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTES_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidCount) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AttributeCount) as usize - ptr as usize }, - 0usize, + 4usize, concat!( "Offset of field: ", - stringify!(_TOKEN_GROUPS_AND_PRIVILEGES), + stringify!(_CLAIM_SECURITY_ATTRIBUTES_INFORMATION), "::", - stringify!(SidCount) + stringify!(AttributeCount) ) ); } - test_field_SidCount(); - fn test_field_SidLength() { + test_field_AttributeCount(); + fn test_field_Attribute() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS_AND_PRIVILEGES>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTES_INFORMATION>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidLength) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Attribute) as usize - ptr as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", - stringify!(_TOKEN_GROUPS_AND_PRIVILEGES), + stringify!(_CLAIM_SECURITY_ATTRIBUTES_INFORMATION), "::", - stringify!(SidLength) + stringify!(Attribute) ) ); } - test_field_SidLength(); - fn test_field_Sids() { + test_field_Attribute(); +} +pub type CLAIM_SECURITY_ATTRIBUTES_INFORMATION = _CLAIM_SECURITY_ATTRIBUTES_INFORMATION; +pub type PCLAIM_SECURITY_ATTRIBUTES_INFORMATION = *mut _CLAIM_SECURITY_ATTRIBUTES_INFORMATION; +pub type SECURITY_CONTEXT_TRACKING_MODE = BOOLEAN; +pub type PSECURITY_CONTEXT_TRACKING_MODE = *mut BOOLEAN; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SECURITY_QUALITY_OF_SERVICE { + pub Length: DWORD, + pub ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL, + pub ContextTrackingMode: SECURITY_CONTEXT_TRACKING_MODE, + pub EffectiveOnly: BOOLEAN, +} +#[test] +fn bindgen_test_layout__SECURITY_QUALITY_OF_SERVICE() { + assert_eq!( + ::std::mem::size_of::<_SECURITY_QUALITY_OF_SERVICE>(), + 12usize, + concat!("Size of: ", stringify!(_SECURITY_QUALITY_OF_SERVICE)) + ); + assert_eq!( + ::std::mem::align_of::<_SECURITY_QUALITY_OF_SERVICE>(), + 4usize, + concat!("Alignment of ", stringify!(_SECURITY_QUALITY_OF_SERVICE)) + ); + fn test_field_Length() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS_AND_PRIVILEGES>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_QUALITY_OF_SERVICE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Sids) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Length) as usize - ptr as usize }, - 8usize, + 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_GROUPS_AND_PRIVILEGES), + stringify!(_SECURITY_QUALITY_OF_SERVICE), "::", - stringify!(Sids) + stringify!(Length) ) ); } - test_field_Sids(); - fn test_field_RestrictedSidCount() { + test_field_Length(); + fn test_field_ImpersonationLevel() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS_AND_PRIVILEGES>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_QUALITY_OF_SERVICE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).RestrictedSidCount) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ImpersonationLevel) as usize - ptr as usize }, - 16usize, + 4usize, concat!( "Offset of field: ", - stringify!(_TOKEN_GROUPS_AND_PRIVILEGES), + stringify!(_SECURITY_QUALITY_OF_SERVICE), "::", - stringify!(RestrictedSidCount) + stringify!(ImpersonationLevel) ) ); } - test_field_RestrictedSidCount(); - fn test_field_RestrictedSidLength() { + test_field_ImpersonationLevel(); + fn test_field_ContextTrackingMode() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS_AND_PRIVILEGES>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_QUALITY_OF_SERVICE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).RestrictedSidLength) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ContextTrackingMode) as usize - ptr as usize }, - 20usize, + 8usize, concat!( "Offset of field: ", - stringify!(_TOKEN_GROUPS_AND_PRIVILEGES), + stringify!(_SECURITY_QUALITY_OF_SERVICE), "::", - stringify!(RestrictedSidLength) + stringify!(ContextTrackingMode) ) ); } - test_field_RestrictedSidLength(); - fn test_field_RestrictedSids() { + test_field_ContextTrackingMode(); + fn test_field_EffectiveOnly() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS_AND_PRIVILEGES>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_QUALITY_OF_SERVICE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).RestrictedSids) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).EffectiveOnly) as usize - ptr as usize }, - 24usize, + 9usize, concat!( "Offset of field: ", - stringify!(_TOKEN_GROUPS_AND_PRIVILEGES), + stringify!(_SECURITY_QUALITY_OF_SERVICE), "::", - stringify!(RestrictedSids) + stringify!(EffectiveOnly) ) ); } - test_field_RestrictedSids(); - fn test_field_PrivilegeCount() { + test_field_EffectiveOnly(); +} +pub type SECURITY_QUALITY_OF_SERVICE = _SECURITY_QUALITY_OF_SERVICE; +pub type PSECURITY_QUALITY_OF_SERVICE = *mut _SECURITY_QUALITY_OF_SERVICE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _SE_IMPERSONATION_STATE { + pub Token: PACCESS_TOKEN, + pub CopyOnOpen: BOOLEAN, + pub EffectiveOnly: BOOLEAN, + pub Level: SECURITY_IMPERSONATION_LEVEL, +} +#[test] +fn bindgen_test_layout__SE_IMPERSONATION_STATE() { + assert_eq!( + ::std::mem::size_of::<_SE_IMPERSONATION_STATE>(), + 16usize, + concat!("Size of: ", stringify!(_SE_IMPERSONATION_STATE)) + ); + assert_eq!( + ::std::mem::align_of::<_SE_IMPERSONATION_STATE>(), + 8usize, + concat!("Alignment of ", stringify!(_SE_IMPERSONATION_STATE)) + ); + fn test_field_Token() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS_AND_PRIVILEGES>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_IMPERSONATION_STATE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).PrivilegeCount) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Token) as usize - ptr as usize }, - 32usize, + 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_GROUPS_AND_PRIVILEGES), + stringify!(_SE_IMPERSONATION_STATE), "::", - stringify!(PrivilegeCount) + stringify!(Token) ) ); } - test_field_PrivilegeCount(); - fn test_field_PrivilegeLength() { + test_field_Token(); + fn test_field_CopyOnOpen() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS_AND_PRIVILEGES>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_IMPERSONATION_STATE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).PrivilegeLength) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).CopyOnOpen) as usize - ptr as usize }, - 36usize, + 8usize, concat!( "Offset of field: ", - stringify!(_TOKEN_GROUPS_AND_PRIVILEGES), + stringify!(_SE_IMPERSONATION_STATE), "::", - stringify!(PrivilegeLength) + stringify!(CopyOnOpen) ) ); } - test_field_PrivilegeLength(); - fn test_field_Privileges() { + test_field_CopyOnOpen(); + fn test_field_EffectiveOnly() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS_AND_PRIVILEGES>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_IMPERSONATION_STATE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Privileges) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).EffectiveOnly) as usize - ptr as usize }, - 40usize, + 9usize, concat!( "Offset of field: ", - stringify!(_TOKEN_GROUPS_AND_PRIVILEGES), + stringify!(_SE_IMPERSONATION_STATE), "::", - stringify!(Privileges) + stringify!(EffectiveOnly) ) ); } - test_field_Privileges(); - fn test_field_AuthenticationId() { + test_field_EffectiveOnly(); + fn test_field_Level() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_GROUPS_AND_PRIVILEGES>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SE_IMPERSONATION_STATE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AuthenticationId) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Level) as usize - ptr as usize }, - 48usize, + 12usize, concat!( "Offset of field: ", - stringify!(_TOKEN_GROUPS_AND_PRIVILEGES), + stringify!(_SE_IMPERSONATION_STATE), "::", - stringify!(AuthenticationId) + stringify!(Level) ) ); } - test_field_AuthenticationId(); + test_field_Level(); } -pub type TOKEN_GROUPS_AND_PRIVILEGES = _TOKEN_GROUPS_AND_PRIVILEGES; -pub type PTOKEN_GROUPS_AND_PRIVILEGES = *mut _TOKEN_GROUPS_AND_PRIVILEGES; +pub type SE_IMPERSONATION_STATE = _SE_IMPERSONATION_STATE; +pub type PSE_IMPERSONATION_STATE = *mut _SE_IMPERSONATION_STATE; +pub type SECURITY_INFORMATION = DWORD; +pub type PSECURITY_INFORMATION = *mut DWORD; +pub type SE_SIGNING_LEVEL = BYTE; +pub type PSE_SIGNING_LEVEL = *mut BYTE; +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _SE_IMAGE_SIGNATURE_TYPE { + SeImageSignatureNone = 0, + SeImageSignatureEmbedded = 1, + SeImageSignatureCache = 2, + SeImageSignatureCatalogCached = 3, + SeImageSignatureCatalogNotCached = 4, + SeImageSignatureCatalogHint = 5, + SeImageSignaturePackageCatalog = 6, + SeImageSignaturePplMitigated = 7, +} +pub use self::_SE_IMAGE_SIGNATURE_TYPE as SE_IMAGE_SIGNATURE_TYPE; +pub type PSE_IMAGE_SIGNATURE_TYPE = *mut _SE_IMAGE_SIGNATURE_TYPE; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _TOKEN_LINKED_TOKEN { - pub LinkedToken: HANDLE, +pub struct _SECURITY_CAPABILITIES { + pub AppContainerSid: PSID, + pub Capabilities: PSID_AND_ATTRIBUTES, + pub CapabilityCount: DWORD, + pub Reserved: DWORD, } #[test] -fn bindgen_test_layout__TOKEN_LINKED_TOKEN() { +fn bindgen_test_layout__SECURITY_CAPABILITIES() { assert_eq!( - ::std::mem::size_of::<_TOKEN_LINKED_TOKEN>(), - 8usize, - concat!("Size of: ", stringify!(_TOKEN_LINKED_TOKEN)) + ::std::mem::size_of::<_SECURITY_CAPABILITIES>(), + 24usize, + concat!("Size of: ", stringify!(_SECURITY_CAPABILITIES)) ); assert_eq!( - ::std::mem::align_of::<_TOKEN_LINKED_TOKEN>(), + ::std::mem::align_of::<_SECURITY_CAPABILITIES>(), 8usize, - concat!("Alignment of ", stringify!(_TOKEN_LINKED_TOKEN)) + concat!("Alignment of ", stringify!(_SECURITY_CAPABILITIES)) ); - fn test_field_LinkedToken() { + fn test_field_AppContainerSid() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_LINKED_TOKEN>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_CAPABILITIES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).LinkedToken) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).AppContainerSid) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_LINKED_TOKEN), + stringify!(_SECURITY_CAPABILITIES), "::", - stringify!(LinkedToken) + stringify!(AppContainerSid) ) ); } - test_field_LinkedToken(); -} -pub type TOKEN_LINKED_TOKEN = _TOKEN_LINKED_TOKEN; -pub type PTOKEN_LINKED_TOKEN = *mut _TOKEN_LINKED_TOKEN; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _TOKEN_ELEVATION { - pub TokenIsElevated: DWORD, -} -#[test] -fn bindgen_test_layout__TOKEN_ELEVATION() { - assert_eq!( - ::std::mem::size_of::<_TOKEN_ELEVATION>(), - 4usize, - concat!("Size of: ", stringify!(_TOKEN_ELEVATION)) - ); - assert_eq!( - ::std::mem::align_of::<_TOKEN_ELEVATION>(), - 4usize, - concat!("Alignment of ", stringify!(_TOKEN_ELEVATION)) - ); - fn test_field_TokenIsElevated() { + test_field_AppContainerSid(); + fn test_field_Capabilities() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_ELEVATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_CAPABILITIES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).TokenIsElevated) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Capabilities) as usize - ptr as usize }, - 0usize, + 8usize, concat!( "Offset of field: ", - stringify!(_TOKEN_ELEVATION), + stringify!(_SECURITY_CAPABILITIES), "::", - stringify!(TokenIsElevated) + stringify!(Capabilities) ) ); } - test_field_TokenIsElevated(); -} -pub type TOKEN_ELEVATION = _TOKEN_ELEVATION; -pub type PTOKEN_ELEVATION = *mut _TOKEN_ELEVATION; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _TOKEN_MANDATORY_LABEL { - pub Label: SID_AND_ATTRIBUTES, -} -#[test] -fn bindgen_test_layout__TOKEN_MANDATORY_LABEL() { - assert_eq!( - ::std::mem::size_of::<_TOKEN_MANDATORY_LABEL>(), - 16usize, - concat!("Size of: ", stringify!(_TOKEN_MANDATORY_LABEL)) - ); - assert_eq!( - ::std::mem::align_of::<_TOKEN_MANDATORY_LABEL>(), - 8usize, - concat!("Alignment of ", stringify!(_TOKEN_MANDATORY_LABEL)) - ); - fn test_field_Label() { + test_field_Capabilities(); + fn test_field_CapabilityCount() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_MANDATORY_LABEL>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_CAPABILITIES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Label) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).CapabilityCount) as usize - ptr as usize }, - 0usize, + 16usize, concat!( "Offset of field: ", - stringify!(_TOKEN_MANDATORY_LABEL), + stringify!(_SECURITY_CAPABILITIES), "::", - stringify!(Label) + stringify!(CapabilityCount) ) ); } - test_field_Label(); -} -pub type TOKEN_MANDATORY_LABEL = _TOKEN_MANDATORY_LABEL; -pub type PTOKEN_MANDATORY_LABEL = *mut _TOKEN_MANDATORY_LABEL; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _TOKEN_MANDATORY_POLICY { - pub Policy: DWORD, -} -#[test] -fn bindgen_test_layout__TOKEN_MANDATORY_POLICY() { - assert_eq!( - ::std::mem::size_of::<_TOKEN_MANDATORY_POLICY>(), - 4usize, - concat!("Size of: ", stringify!(_TOKEN_MANDATORY_POLICY)) - ); - assert_eq!( - ::std::mem::align_of::<_TOKEN_MANDATORY_POLICY>(), - 4usize, - concat!("Alignment of ", stringify!(_TOKEN_MANDATORY_POLICY)) - ); - fn test_field_Policy() { + test_field_CapabilityCount(); + fn test_field_Reserved() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_MANDATORY_POLICY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_SECURITY_CAPABILITIES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Policy) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize }, - 0usize, + 20usize, concat!( "Offset of field: ", - stringify!(_TOKEN_MANDATORY_POLICY), + stringify!(_SECURITY_CAPABILITIES), "::", - stringify!(Policy) + stringify!(Reserved) ) ); } - test_field_Policy(); + test_field_Reserved(); } -pub type TOKEN_MANDATORY_POLICY = _TOKEN_MANDATORY_POLICY; -pub type PTOKEN_MANDATORY_POLICY = *mut _TOKEN_MANDATORY_POLICY; -pub type PSECURITY_ATTRIBUTES_OPAQUE = PVOID; +pub type SECURITY_CAPABILITIES = _SECURITY_CAPABILITIES; +pub type PSECURITY_CAPABILITIES = *mut _SECURITY_CAPABILITIES; +pub type LPSECURITY_CAPABILITIES = *mut _SECURITY_CAPABILITIES; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _TOKEN_ACCESS_INFORMATION { - pub SidHash: PSID_AND_ATTRIBUTES_HASH, - pub RestrictedSidHash: PSID_AND_ATTRIBUTES_HASH, - pub Privileges: PTOKEN_PRIVILEGES, - pub AuthenticationId: LUID, - pub TokenType: TOKEN_TYPE, - pub ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL, - pub MandatoryPolicy: TOKEN_MANDATORY_POLICY, +pub struct _JOB_SET_ARRAY { + pub JobHandle: HANDLE, + pub MemberLevel: DWORD, pub Flags: DWORD, - pub AppContainerNumber: DWORD, - pub PackageSid: PSID, - pub CapabilitiesHash: PSID_AND_ATTRIBUTES_HASH, - pub TrustLevelSid: PSID, - pub SecurityAttributes: PSECURITY_ATTRIBUTES_OPAQUE, } #[test] -fn bindgen_test_layout__TOKEN_ACCESS_INFORMATION() { +fn bindgen_test_layout__JOB_SET_ARRAY() { assert_eq!( - ::std::mem::size_of::<_TOKEN_ACCESS_INFORMATION>(), - 88usize, - concat!("Size of: ", stringify!(_TOKEN_ACCESS_INFORMATION)) + ::std::mem::size_of::<_JOB_SET_ARRAY>(), + 16usize, + concat!("Size of: ", stringify!(_JOB_SET_ARRAY)) ); assert_eq!( - ::std::mem::align_of::<_TOKEN_ACCESS_INFORMATION>(), + ::std::mem::align_of::<_JOB_SET_ARRAY>(), 8usize, - concat!("Alignment of ", stringify!(_TOKEN_ACCESS_INFORMATION)) + concat!("Alignment of ", stringify!(_JOB_SET_ARRAY)) ); - fn test_field_SidHash() { + fn test_field_JobHandle() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JOB_SET_ARRAY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SidHash) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).JobHandle) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_ACCESS_INFORMATION), + stringify!(_JOB_SET_ARRAY), "::", - stringify!(SidHash) + stringify!(JobHandle) ) ); } - test_field_SidHash(); - fn test_field_RestrictedSidHash() { + test_field_JobHandle(); + fn test_field_MemberLevel() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JOB_SET_ARRAY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).RestrictedSidHash) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).MemberLevel) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_TOKEN_ACCESS_INFORMATION), + stringify!(_JOB_SET_ARRAY), "::", - stringify!(RestrictedSidHash) + stringify!(MemberLevel) ) ); } - test_field_RestrictedSidHash(); - fn test_field_Privileges() { + test_field_MemberLevel(); + fn test_field_Flags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JOB_SET_ARRAY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Privileges) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, - 16usize, + 12usize, concat!( "Offset of field: ", - stringify!(_TOKEN_ACCESS_INFORMATION), + stringify!(_JOB_SET_ARRAY), "::", - stringify!(Privileges) + stringify!(Flags) ) ); } - test_field_Privileges(); - fn test_field_AuthenticationId() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AuthenticationId) as usize - ptr as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(_TOKEN_ACCESS_INFORMATION), - "::", - stringify!(AuthenticationId) - ) - ); - } - test_field_AuthenticationId(); - fn test_field_TokenType() { + test_field_Flags(); +} +pub type JOB_SET_ARRAY = _JOB_SET_ARRAY; +pub type PJOB_SET_ARRAY = *mut _JOB_SET_ARRAY; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _EXCEPTION_REGISTRATION_RECORD { + pub Next: *mut _EXCEPTION_REGISTRATION_RECORD, + pub Handler: PEXCEPTION_ROUTINE, +} +#[test] +fn bindgen_test_layout__EXCEPTION_REGISTRATION_RECORD() { + assert_eq!( + ::std::mem::size_of::<_EXCEPTION_REGISTRATION_RECORD>(), + 16usize, + concat!("Size of: ", stringify!(_EXCEPTION_REGISTRATION_RECORD)) + ); + assert_eq!( + ::std::mem::align_of::<_EXCEPTION_REGISTRATION_RECORD>(), + 8usize, + concat!("Alignment of ", stringify!(_EXCEPTION_REGISTRATION_RECORD)) + ); + fn test_field_Next() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_REGISTRATION_RECORD>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).TokenType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Next) as usize - ptr as usize }, - 32usize, + 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_ACCESS_INFORMATION), + stringify!(_EXCEPTION_REGISTRATION_RECORD), "::", - stringify!(TokenType) + stringify!(Next) ) ); } - test_field_TokenType(); - fn test_field_ImpersonationLevel() { + test_field_Next(); + fn test_field_Handler() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_REGISTRATION_RECORD>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ImpersonationLevel) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Handler) as usize - ptr as usize }, - 36usize, + 8usize, concat!( "Offset of field: ", - stringify!(_TOKEN_ACCESS_INFORMATION), + stringify!(_EXCEPTION_REGISTRATION_RECORD), "::", - stringify!(ImpersonationLevel) + stringify!(Handler) ) ); } - test_field_ImpersonationLevel(); - fn test_field_MandatoryPolicy() { + test_field_Handler(); +} +pub type EXCEPTION_REGISTRATION_RECORD = _EXCEPTION_REGISTRATION_RECORD; +pub type PEXCEPTION_REGISTRATION_RECORD = *mut EXCEPTION_REGISTRATION_RECORD; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NT_TIB { + pub ExceptionList: *mut _EXCEPTION_REGISTRATION_RECORD, + pub StackBase: PVOID, + pub StackLimit: PVOID, + pub SubSystemTib: PVOID, + pub __bindgen_anon_1: _NT_TIB__bindgen_ty_1, + pub ArbitraryUserPointer: PVOID, + pub Self_: *mut _NT_TIB, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NT_TIB__bindgen_ty_1 { + pub FiberData: PVOID, + pub Version: DWORD, +} +#[test] +fn bindgen_test_layout__NT_TIB__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<_NT_TIB__bindgen_ty_1>(), + 8usize, + concat!("Size of: ", stringify!(_NT_TIB__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::<_NT_TIB__bindgen_ty_1>(), + 8usize, + concat!("Alignment of ", stringify!(_NT_TIB__bindgen_ty_1)) + ); + fn test_field_FiberData() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).MandatoryPolicy) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).FiberData) as usize - ptr as usize }, - 40usize, + 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_ACCESS_INFORMATION), + stringify!(_NT_TIB__bindgen_ty_1), "::", - stringify!(MandatoryPolicy) + stringify!(FiberData) ) ); } - test_field_MandatoryPolicy(); - fn test_field_Flags() { + test_field_FiberData(); + fn test_field_Version() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Version) as usize - ptr as usize }, - 44usize, + 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_ACCESS_INFORMATION), + stringify!(_NT_TIB__bindgen_ty_1), "::", - stringify!(Flags) + stringify!(Version) ) ); } - test_field_Flags(); - fn test_field_AppContainerNumber() { + test_field_Version(); +} +#[test] +fn bindgen_test_layout__NT_TIB() { + assert_eq!( + ::std::mem::size_of::<_NT_TIB>(), + 56usize, + concat!("Size of: ", stringify!(_NT_TIB)) + ); + assert_eq!( + ::std::mem::align_of::<_NT_TIB>(), + 8usize, + concat!("Alignment of ", stringify!(_NT_TIB)) + ); + fn test_field_ExceptionList() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AppContainerNumber) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ExceptionList) as usize - ptr as usize }, - 48usize, + 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_ACCESS_INFORMATION), + stringify!(_NT_TIB), "::", - stringify!(AppContainerNumber) + stringify!(ExceptionList) ) ); } - test_field_AppContainerNumber(); - fn test_field_PackageSid() { + test_field_ExceptionList(); + fn test_field_StackBase() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).PackageSid) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).StackBase) as usize - ptr as usize }, - 56usize, + 8usize, concat!( "Offset of field: ", - stringify!(_TOKEN_ACCESS_INFORMATION), + stringify!(_NT_TIB), "::", - stringify!(PackageSid) + stringify!(StackBase) ) ); } - test_field_PackageSid(); - fn test_field_CapabilitiesHash() { + test_field_StackBase(); + fn test_field_StackLimit() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).CapabilitiesHash) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).StackLimit) as usize - ptr as usize }, - 64usize, + 16usize, concat!( "Offset of field: ", - stringify!(_TOKEN_ACCESS_INFORMATION), + stringify!(_NT_TIB), "::", - stringify!(CapabilitiesHash) + stringify!(StackLimit) ) ); } - test_field_CapabilitiesHash(); - fn test_field_TrustLevelSid() { + test_field_StackLimit(); + fn test_field_SubSystemTib() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).TrustLevelSid) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SubSystemTib) as usize - ptr as usize }, - 72usize, + 24usize, concat!( "Offset of field: ", - stringify!(_TOKEN_ACCESS_INFORMATION), + stringify!(_NT_TIB), "::", - stringify!(TrustLevelSid) + stringify!(SubSystemTib) ) ); } - test_field_TrustLevelSid(); - fn test_field_SecurityAttributes() { + test_field_SubSystemTib(); + fn test_field_ArbitraryUserPointer() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_ACCESS_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SecurityAttributes) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ArbitraryUserPointer) as usize - ptr as usize }, - 80usize, + 40usize, concat!( "Offset of field: ", - stringify!(_TOKEN_ACCESS_INFORMATION), + stringify!(_NT_TIB), "::", - stringify!(SecurityAttributes) + stringify!(ArbitraryUserPointer) ) ); } - test_field_SecurityAttributes(); -} -pub type TOKEN_ACCESS_INFORMATION = _TOKEN_ACCESS_INFORMATION; -pub type PTOKEN_ACCESS_INFORMATION = *mut _TOKEN_ACCESS_INFORMATION; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _TOKEN_AUDIT_POLICY { - pub PerUserPolicy: [BYTE; 30usize], -} -#[test] -fn bindgen_test_layout__TOKEN_AUDIT_POLICY() { - assert_eq!( - ::std::mem::size_of::<_TOKEN_AUDIT_POLICY>(), - 30usize, - concat!("Size of: ", stringify!(_TOKEN_AUDIT_POLICY)) - ); - assert_eq!( - ::std::mem::align_of::<_TOKEN_AUDIT_POLICY>(), - 1usize, - concat!("Alignment of ", stringify!(_TOKEN_AUDIT_POLICY)) - ); - fn test_field_PerUserPolicy() { + test_field_ArbitraryUserPointer(); + fn test_field_Self() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_AUDIT_POLICY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).PerUserPolicy) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Self_) as usize - ptr as usize }, - 0usize, + 48usize, concat!( "Offset of field: ", - stringify!(_TOKEN_AUDIT_POLICY), + stringify!(_NT_TIB), "::", - stringify!(PerUserPolicy) + stringify!(Self_) ) ); } - test_field_PerUserPolicy(); + test_field_Self(); } -pub type TOKEN_AUDIT_POLICY = _TOKEN_AUDIT_POLICY; -pub type PTOKEN_AUDIT_POLICY = *mut _TOKEN_AUDIT_POLICY; +pub type NT_TIB = _NT_TIB; +pub type PNT_TIB = *mut NT_TIB; #[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _TOKEN_SOURCE { - pub SourceName: [CHAR; 8usize], - pub SourceIdentifier: LUID, +#[derive(Copy, Clone)] +pub struct _NT_TIB32 { + pub ExceptionList: DWORD, + pub StackBase: DWORD, + pub StackLimit: DWORD, + pub SubSystemTib: DWORD, + pub __bindgen_anon_1: _NT_TIB32__bindgen_ty_1, + pub ArbitraryUserPointer: DWORD, + pub Self_: DWORD, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NT_TIB32__bindgen_ty_1 { + pub FiberData: DWORD, + pub Version: DWORD, } #[test] -fn bindgen_test_layout__TOKEN_SOURCE() { +fn bindgen_test_layout__NT_TIB32__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_TOKEN_SOURCE>(), - 16usize, - concat!("Size of: ", stringify!(_TOKEN_SOURCE)) + ::std::mem::size_of::<_NT_TIB32__bindgen_ty_1>(), + 4usize, + concat!("Size of: ", stringify!(_NT_TIB32__bindgen_ty_1)) ); assert_eq!( - ::std::mem::align_of::<_TOKEN_SOURCE>(), + ::std::mem::align_of::<_NT_TIB32__bindgen_ty_1>(), 4usize, - concat!("Alignment of ", stringify!(_TOKEN_SOURCE)) + concat!("Alignment of ", stringify!(_NT_TIB32__bindgen_ty_1)) ); - fn test_field_SourceName() { + fn test_field_FiberData() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_SOURCE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB32__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SourceName) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).FiberData) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_SOURCE), + stringify!(_NT_TIB32__bindgen_ty_1), "::", - stringify!(SourceName) + stringify!(FiberData) ) ); } - test_field_SourceName(); - fn test_field_SourceIdentifier() { + test_field_FiberData(); + fn test_field_Version() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_SOURCE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB32__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SourceIdentifier) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Version) as usize - ptr as usize }, - 8usize, + 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_SOURCE), + stringify!(_NT_TIB32__bindgen_ty_1), "::", - stringify!(SourceIdentifier) + stringify!(Version) ) ); } - test_field_SourceIdentifier(); -} -pub type TOKEN_SOURCE = _TOKEN_SOURCE; -pub type PTOKEN_SOURCE = *mut _TOKEN_SOURCE; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _TOKEN_STATISTICS { - pub TokenId: LUID, - pub AuthenticationId: LUID, - pub ExpirationTime: LARGE_INTEGER, - pub TokenType: TOKEN_TYPE, - pub ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL, - pub DynamicCharged: DWORD, - pub DynamicAvailable: DWORD, - pub GroupCount: DWORD, - pub PrivilegeCount: DWORD, - pub ModifiedId: LUID, + test_field_Version(); } #[test] -fn bindgen_test_layout__TOKEN_STATISTICS() { +fn bindgen_test_layout__NT_TIB32() { assert_eq!( - ::std::mem::size_of::<_TOKEN_STATISTICS>(), - 56usize, - concat!("Size of: ", stringify!(_TOKEN_STATISTICS)) + ::std::mem::size_of::<_NT_TIB32>(), + 28usize, + concat!("Size of: ", stringify!(_NT_TIB32)) ); assert_eq!( - ::std::mem::align_of::<_TOKEN_STATISTICS>(), - 8usize, - concat!("Alignment of ", stringify!(_TOKEN_STATISTICS)) + ::std::mem::align_of::<_NT_TIB32>(), + 4usize, + concat!("Alignment of ", stringify!(_NT_TIB32)) ); - fn test_field_TokenId() { + fn test_field_ExceptionList() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_STATISTICS>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB32>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).TokenId) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ExceptionList) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_STATISTICS), + stringify!(_NT_TIB32), "::", - stringify!(TokenId) + stringify!(ExceptionList) ) ); } - test_field_TokenId(); - fn test_field_AuthenticationId() { + test_field_ExceptionList(); + fn test_field_StackBase() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_STATISTICS>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB32>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AuthenticationId) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).StackBase) as usize - ptr as usize }, - 8usize, + 4usize, concat!( "Offset of field: ", - stringify!(_TOKEN_STATISTICS), + stringify!(_NT_TIB32), "::", - stringify!(AuthenticationId) + stringify!(StackBase) ) ); } - test_field_AuthenticationId(); - fn test_field_ExpirationTime() { + test_field_StackBase(); + fn test_field_StackLimit() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_STATISTICS>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB32>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExpirationTime) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).StackLimit) as usize - ptr as usize }, - 16usize, + 8usize, concat!( "Offset of field: ", - stringify!(_TOKEN_STATISTICS), + stringify!(_NT_TIB32), "::", - stringify!(ExpirationTime) + stringify!(StackLimit) ) ); } - test_field_ExpirationTime(); - fn test_field_TokenType() { + test_field_StackLimit(); + fn test_field_SubSystemTib() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_STATISTICS>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB32>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).TokenType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SubSystemTib) as usize - ptr as usize }, - 24usize, + 12usize, concat!( "Offset of field: ", - stringify!(_TOKEN_STATISTICS), + stringify!(_NT_TIB32), "::", - stringify!(TokenType) + stringify!(SubSystemTib) ) ); } - test_field_TokenType(); - fn test_field_ImpersonationLevel() { + test_field_SubSystemTib(); + fn test_field_ArbitraryUserPointer() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_STATISTICS>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB32>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ImpersonationLevel) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ArbitraryUserPointer) as usize - ptr as usize }, - 28usize, + 20usize, concat!( "Offset of field: ", - stringify!(_TOKEN_STATISTICS), + stringify!(_NT_TIB32), "::", - stringify!(ImpersonationLevel) + stringify!(ArbitraryUserPointer) ) ); } - test_field_ImpersonationLevel(); - fn test_field_DynamicCharged() { + test_field_ArbitraryUserPointer(); + fn test_field_Self() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_STATISTICS>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB32>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).DynamicCharged) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Self_) as usize - ptr as usize }, - 32usize, + 24usize, concat!( "Offset of field: ", - stringify!(_TOKEN_STATISTICS), + stringify!(_NT_TIB32), "::", - stringify!(DynamicCharged) + stringify!(Self_) ) ); } - test_field_DynamicCharged(); - fn test_field_DynamicAvailable() { + test_field_Self(); +} +pub type NT_TIB32 = _NT_TIB32; +pub type PNT_TIB32 = *mut _NT_TIB32; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NT_TIB64 { + pub ExceptionList: DWORD64, + pub StackBase: DWORD64, + pub StackLimit: DWORD64, + pub SubSystemTib: DWORD64, + pub __bindgen_anon_1: _NT_TIB64__bindgen_ty_1, + pub ArbitraryUserPointer: DWORD64, + pub Self_: DWORD64, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NT_TIB64__bindgen_ty_1 { + pub FiberData: DWORD64, + pub Version: DWORD, +} +#[test] +fn bindgen_test_layout__NT_TIB64__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<_NT_TIB64__bindgen_ty_1>(), + 8usize, + concat!("Size of: ", stringify!(_NT_TIB64__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::<_NT_TIB64__bindgen_ty_1>(), + 8usize, + concat!("Alignment of ", stringify!(_NT_TIB64__bindgen_ty_1)) + ); + fn test_field_FiberData() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_STATISTICS>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB64__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).DynamicAvailable) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).FiberData) as usize - ptr as usize }, - 36usize, + 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_STATISTICS), + stringify!(_NT_TIB64__bindgen_ty_1), "::", - stringify!(DynamicAvailable) + stringify!(FiberData) ) ); } - test_field_DynamicAvailable(); - fn test_field_GroupCount() { + test_field_FiberData(); + fn test_field_Version() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_STATISTICS>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB64__bindgen_ty_1>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).GroupCount) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Version) as usize - ptr as usize }, - 40usize, + 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_STATISTICS), + stringify!(_NT_TIB64__bindgen_ty_1), "::", - stringify!(GroupCount) + stringify!(Version) ) ); } - test_field_GroupCount(); - fn test_field_PrivilegeCount() { + test_field_Version(); +} +#[test] +fn bindgen_test_layout__NT_TIB64() { + assert_eq!( + ::std::mem::size_of::<_NT_TIB64>(), + 56usize, + concat!("Size of: ", stringify!(_NT_TIB64)) + ); + assert_eq!( + ::std::mem::align_of::<_NT_TIB64>(), + 8usize, + concat!("Alignment of ", stringify!(_NT_TIB64)) + ); + fn test_field_ExceptionList() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_STATISTICS>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).PrivilegeCount) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ExceptionList) as usize - ptr as usize }, - 44usize, + 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_STATISTICS), + stringify!(_NT_TIB64), "::", - stringify!(PrivilegeCount) + stringify!(ExceptionList) ) ); } - test_field_PrivilegeCount(); - fn test_field_ModifiedId() { + test_field_ExceptionList(); + fn test_field_StackBase() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_STATISTICS>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ModifiedId) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).StackBase) as usize - ptr as usize }, - 48usize, + 8usize, concat!( "Offset of field: ", - stringify!(_TOKEN_STATISTICS), + stringify!(_NT_TIB64), "::", - stringify!(ModifiedId) + stringify!(StackBase) ) ); } - test_field_ModifiedId(); -} -pub type TOKEN_STATISTICS = _TOKEN_STATISTICS; -pub type PTOKEN_STATISTICS = *mut _TOKEN_STATISTICS; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _TOKEN_CONTROL { - pub TokenId: LUID, - pub AuthenticationId: LUID, - pub ModifiedId: LUID, - pub TokenSource: TOKEN_SOURCE, -} -#[test] -fn bindgen_test_layout__TOKEN_CONTROL() { - assert_eq!( - ::std::mem::size_of::<_TOKEN_CONTROL>(), - 40usize, - concat!("Size of: ", stringify!(_TOKEN_CONTROL)) - ); - assert_eq!( - ::std::mem::align_of::<_TOKEN_CONTROL>(), - 4usize, - concat!("Alignment of ", stringify!(_TOKEN_CONTROL)) - ); - fn test_field_TokenId() { + test_field_StackBase(); + fn test_field_StackLimit() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_CONTROL>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).TokenId) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).StackLimit) as usize - ptr as usize }, - 0usize, + 16usize, concat!( "Offset of field: ", - stringify!(_TOKEN_CONTROL), + stringify!(_NT_TIB64), "::", - stringify!(TokenId) + stringify!(StackLimit) ) ); } - test_field_TokenId(); - fn test_field_AuthenticationId() { + test_field_StackLimit(); + fn test_field_SubSystemTib() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_CONTROL>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AuthenticationId) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).SubSystemTib) as usize - ptr as usize }, - 8usize, + 24usize, concat!( "Offset of field: ", - stringify!(_TOKEN_CONTROL), + stringify!(_NT_TIB64), "::", - stringify!(AuthenticationId) + stringify!(SubSystemTib) ) ); } - test_field_AuthenticationId(); - fn test_field_ModifiedId() { + test_field_SubSystemTib(); + fn test_field_ArbitraryUserPointer() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_CONTROL>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ModifiedId) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ArbitraryUserPointer) as usize - ptr as usize }, - 16usize, + 40usize, concat!( "Offset of field: ", - stringify!(_TOKEN_CONTROL), + stringify!(_NT_TIB64), "::", - stringify!(ModifiedId) + stringify!(ArbitraryUserPointer) ) ); } - test_field_ModifiedId(); - fn test_field_TokenSource() { + test_field_ArbitraryUserPointer(); + fn test_field_Self() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_CONTROL>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_NT_TIB64>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).TokenSource) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Self_) as usize - ptr as usize }, - 24usize, + 48usize, concat!( "Offset of field: ", - stringify!(_TOKEN_CONTROL), + stringify!(_NT_TIB64), "::", - stringify!(TokenSource) + stringify!(Self_) ) ); } - test_field_TokenSource(); + test_field_Self(); } -pub type TOKEN_CONTROL = _TOKEN_CONTROL; -pub type PTOKEN_CONTROL = *mut _TOKEN_CONTROL; +pub type NT_TIB64 = _NT_TIB64; +pub type PNT_TIB64 = *mut _NT_TIB64; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _TOKEN_ORIGIN { - pub OriginatingLogonSession: LUID, +pub struct _UMS_CREATE_THREAD_ATTRIBUTES { + pub UmsVersion: DWORD, + pub UmsContext: PVOID, + pub UmsCompletionList: PVOID, } #[test] -fn bindgen_test_layout__TOKEN_ORIGIN() { +fn bindgen_test_layout__UMS_CREATE_THREAD_ATTRIBUTES() { assert_eq!( - ::std::mem::size_of::<_TOKEN_ORIGIN>(), - 8usize, - concat!("Size of: ", stringify!(_TOKEN_ORIGIN)) + ::std::mem::size_of::<_UMS_CREATE_THREAD_ATTRIBUTES>(), + 24usize, + concat!("Size of: ", stringify!(_UMS_CREATE_THREAD_ATTRIBUTES)) ); assert_eq!( - ::std::mem::align_of::<_TOKEN_ORIGIN>(), - 4usize, - concat!("Alignment of ", stringify!(_TOKEN_ORIGIN)) + ::std::mem::align_of::<_UMS_CREATE_THREAD_ATTRIBUTES>(), + 8usize, + concat!("Alignment of ", stringify!(_UMS_CREATE_THREAD_ATTRIBUTES)) ); - fn test_field_OriginatingLogonSession() { + fn test_field_UmsVersion() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_ORIGIN>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_UMS_CREATE_THREAD_ATTRIBUTES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).OriginatingLogonSession) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).UmsVersion) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_ORIGIN), + stringify!(_UMS_CREATE_THREAD_ATTRIBUTES), "::", - stringify!(OriginatingLogonSession) + stringify!(UmsVersion) ) ); } - test_field_OriginatingLogonSession(); -} -pub type TOKEN_ORIGIN = _TOKEN_ORIGIN; -pub type PTOKEN_ORIGIN = *mut _TOKEN_ORIGIN; -#[repr(i32)] -#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] -pub enum _MANDATORY_LEVEL { - MandatoryLevelUntrusted = 0, - MandatoryLevelLow = 1, - MandatoryLevelMedium = 2, - MandatoryLevelHigh = 3, - MandatoryLevelSystem = 4, - MandatoryLevelSecureProcess = 5, - MandatoryLevelCount = 6, -} -pub use self::_MANDATORY_LEVEL as MANDATORY_LEVEL; -pub type PMANDATORY_LEVEL = *mut _MANDATORY_LEVEL; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _TOKEN_APPCONTAINER_INFORMATION { - pub TokenAppContainer: PSID, -} -#[test] -fn bindgen_test_layout__TOKEN_APPCONTAINER_INFORMATION() { - assert_eq!( - ::std::mem::size_of::<_TOKEN_APPCONTAINER_INFORMATION>(), - 8usize, - concat!("Size of: ", stringify!(_TOKEN_APPCONTAINER_INFORMATION)) - ); - assert_eq!( - ::std::mem::align_of::<_TOKEN_APPCONTAINER_INFORMATION>(), - 8usize, - concat!("Alignment of ", stringify!(_TOKEN_APPCONTAINER_INFORMATION)) - ); - fn test_field_TokenAppContainer() { + test_field_UmsVersion(); + fn test_field_UmsContext() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_APPCONTAINER_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_UMS_CREATE_THREAD_ATTRIBUTES>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).TokenAppContainer) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).UmsContext) as usize - ptr as usize }, - 0usize, + 8usize, concat!( "Offset of field: ", - stringify!(_TOKEN_APPCONTAINER_INFORMATION), + stringify!(_UMS_CREATE_THREAD_ATTRIBUTES), "::", - stringify!(TokenAppContainer) + stringify!(UmsContext) ) ); } - test_field_TokenAppContainer(); + test_field_UmsContext(); + fn test_field_UmsCompletionList() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_UMS_CREATE_THREAD_ATTRIBUTES>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).UmsCompletionList) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_UMS_CREATE_THREAD_ATTRIBUTES), + "::", + stringify!(UmsCompletionList) + ) + ); + } + test_field_UmsCompletionList(); } -pub type TOKEN_APPCONTAINER_INFORMATION = _TOKEN_APPCONTAINER_INFORMATION; -pub type PTOKEN_APPCONTAINER_INFORMATION = *mut _TOKEN_APPCONTAINER_INFORMATION; +pub type UMS_CREATE_THREAD_ATTRIBUTES = _UMS_CREATE_THREAD_ATTRIBUTES; +pub type PUMS_CREATE_THREAD_ATTRIBUTES = *mut _UMS_CREATE_THREAD_ATTRIBUTES; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _TOKEN_SID_INFORMATION { - pub Sid: PSID, +pub struct _COMPONENT_FILTER { + pub ComponentFlags: DWORD, } #[test] -fn bindgen_test_layout__TOKEN_SID_INFORMATION() { +fn bindgen_test_layout__COMPONENT_FILTER() { assert_eq!( - ::std::mem::size_of::<_TOKEN_SID_INFORMATION>(), - 8usize, - concat!("Size of: ", stringify!(_TOKEN_SID_INFORMATION)) + ::std::mem::size_of::<_COMPONENT_FILTER>(), + 4usize, + concat!("Size of: ", stringify!(_COMPONENT_FILTER)) ); assert_eq!( - ::std::mem::align_of::<_TOKEN_SID_INFORMATION>(), - 8usize, - concat!("Alignment of ", stringify!(_TOKEN_SID_INFORMATION)) + ::std::mem::align_of::<_COMPONENT_FILTER>(), + 4usize, + concat!("Alignment of ", stringify!(_COMPONENT_FILTER)) ); - fn test_field_Sid() { + fn test_field_ComponentFlags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_SID_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_COMPONENT_FILTER>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Sid) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ComponentFlags) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_SID_INFORMATION), + stringify!(_COMPONENT_FILTER), "::", - stringify!(Sid) + stringify!(ComponentFlags) ) ); } - test_field_Sid(); + test_field_ComponentFlags(); } -pub type TOKEN_SID_INFORMATION = _TOKEN_SID_INFORMATION; -pub type PTOKEN_SID_INFORMATION = *mut _TOKEN_SID_INFORMATION; +pub type COMPONENT_FILTER = _COMPONENT_FILTER; +pub type PCOMPONENT_FILTER = *mut _COMPONENT_FILTER; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _TOKEN_BNO_ISOLATION_INFORMATION { - pub IsolationPrefix: PWSTR, - pub IsolationEnabled: BOOLEAN, +pub struct _PROCESS_DYNAMIC_EH_CONTINUATION_TARGET { + pub TargetAddress: ULONG_PTR, + pub Flags: ULONG_PTR, } #[test] -fn bindgen_test_layout__TOKEN_BNO_ISOLATION_INFORMATION() { +fn bindgen_test_layout__PROCESS_DYNAMIC_EH_CONTINUATION_TARGET() { assert_eq!( - ::std::mem::size_of::<_TOKEN_BNO_ISOLATION_INFORMATION>(), + ::std::mem::size_of::<_PROCESS_DYNAMIC_EH_CONTINUATION_TARGET>(), 16usize, - concat!("Size of: ", stringify!(_TOKEN_BNO_ISOLATION_INFORMATION)) + concat!( + "Size of: ", + stringify!(_PROCESS_DYNAMIC_EH_CONTINUATION_TARGET) + ) ); assert_eq!( - ::std::mem::align_of::<_TOKEN_BNO_ISOLATION_INFORMATION>(), + ::std::mem::align_of::<_PROCESS_DYNAMIC_EH_CONTINUATION_TARGET>(), 8usize, concat!( "Alignment of ", - stringify!(_TOKEN_BNO_ISOLATION_INFORMATION) + stringify!(_PROCESS_DYNAMIC_EH_CONTINUATION_TARGET) ) ); - fn test_field_IsolationPrefix() { + fn test_field_TargetAddress() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_BNO_ISOLATION_INFORMATION>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_PROCESS_DYNAMIC_EH_CONTINUATION_TARGET>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).IsolationPrefix) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).TargetAddress) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_TOKEN_BNO_ISOLATION_INFORMATION), + stringify!(_PROCESS_DYNAMIC_EH_CONTINUATION_TARGET), "::", - stringify!(IsolationPrefix) + stringify!(TargetAddress) ) ); } - test_field_IsolationPrefix(); - fn test_field_IsolationEnabled() { + test_field_TargetAddress(); + fn test_field_Flags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_TOKEN_BNO_ISOLATION_INFORMATION>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_PROCESS_DYNAMIC_EH_CONTINUATION_TARGET>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).IsolationEnabled) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_TOKEN_BNO_ISOLATION_INFORMATION), + stringify!(_PROCESS_DYNAMIC_EH_CONTINUATION_TARGET), "::", - stringify!(IsolationEnabled) + stringify!(Flags) ) ); } - test_field_IsolationEnabled(); + test_field_Flags(); } -pub type TOKEN_BNO_ISOLATION_INFORMATION = _TOKEN_BNO_ISOLATION_INFORMATION; -pub type PTOKEN_BNO_ISOLATION_INFORMATION = *mut _TOKEN_BNO_ISOLATION_INFORMATION; +pub type PROCESS_DYNAMIC_EH_CONTINUATION_TARGET = _PROCESS_DYNAMIC_EH_CONTINUATION_TARGET; +pub type PPROCESS_DYNAMIC_EH_CONTINUATION_TARGET = *mut _PROCESS_DYNAMIC_EH_CONTINUATION_TARGET; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE { - pub Version: DWORD64, - pub Name: PWSTR, +pub struct _PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION { + pub NumberOfTargets: WORD, + pub Reserved: WORD, + pub Reserved2: DWORD, + pub Targets: PPROCESS_DYNAMIC_EH_CONTINUATION_TARGET, } #[test] -fn bindgen_test_layout__CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE() { +fn bindgen_test_layout__PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION() { assert_eq!( - ::std::mem::size_of::<_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE>(), + ::std::mem::size_of::<_PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION>(), 16usize, concat!( "Size of: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE) + stringify!(_PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION) ) ); assert_eq!( - ::std::mem::align_of::<_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE>(), + ::std::mem::align_of::<_PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION>(), 8usize, concat!( "Alignment of ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE) + stringify!(_PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION) ) ); - fn test_field_Version() { + fn test_field_NumberOfTargets() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Version) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).NumberOfTargets) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE), + stringify!(_PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION), "::", - stringify!(Version) + stringify!(NumberOfTargets) ) ); } - test_field_Version(); - fn test_field_Name() { + test_field_NumberOfTargets(); + fn test_field_Reserved() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Name) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize + }, + 2usize, + concat!( + "Offset of field: ", + stringify!(_PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION), + "::", + stringify!(Reserved) + ) + ); + } + test_field_Reserved(); + fn test_field_Reserved2() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::< + _PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION, + >::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Reserved2) as usize - ptr as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(_PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION), + "::", + stringify!(Reserved2) + ) + ); + } + test_field_Reserved2(); + fn test_field_Targets() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::< + _PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION, + >::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Targets) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE), + stringify!(_PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION), "::", - stringify!(Name) + stringify!(Targets) ) ); } - test_field_Name(); + test_field_Targets(); } -pub type CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE = _CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE; -pub type PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE = *mut _CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE; +pub type PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION = + _PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION; +pub type PPROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION = + *mut _PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE { - pub pValue: PVOID, - pub ValueLength: DWORD, +pub struct _PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE { + pub BaseAddress: ULONG_PTR, + pub Size: SIZE_T, + pub Flags: DWORD, } #[test] -fn bindgen_test_layout__CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE() { +fn bindgen_test_layout__PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE() { assert_eq!( - ::std::mem::size_of::<_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE>(), - 16usize, + ::std::mem::size_of::<_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE>(), + 24usize, concat!( "Size of: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE) + stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE) ) ); assert_eq!( - ::std::mem::align_of::<_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE>(), + ::std::mem::align_of::<_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE>(), 8usize, concat!( "Alignment of ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE) + stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE) ) ); - fn test_field_pValue() { + fn test_field_BaseAddress() { assert_eq!( unsafe { let uninit = - ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE>::uninit( - ); + ::std::mem::MaybeUninit::<_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).pValue) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).BaseAddress) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE), + stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE), "::", - stringify!(pValue) + stringify!(BaseAddress) ) ); } - test_field_pValue(); - fn test_field_ValueLength() { + test_field_BaseAddress(); + fn test_field_Size() { assert_eq!( unsafe { let uninit = - ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE>::uninit( - ); + ::std::mem::MaybeUninit::<_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ValueLength) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Size) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE), + stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE), "::", - stringify!(ValueLength) + stringify!(Size) ) ); } - test_field_ValueLength(); + test_field_Size(); + fn test_field_Flags() { + assert_eq!( + unsafe { + let uninit = + ::std::mem::MaybeUninit::<_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE), + "::", + stringify!(Flags) + ) + ); + } + test_field_Flags(); } -pub type CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE = _CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE; -pub type PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE = - *mut _CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE; +pub type PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE = _PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE; +pub type PPROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE = *mut _PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE; #[repr(C)] -#[derive(Copy, Clone)] -pub struct _CLAIM_SECURITY_ATTRIBUTE_V1 { - pub Name: PWSTR, - pub ValueType: WORD, +#[derive(Debug, Copy, Clone)] +pub struct _PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION { + pub NumberOfRanges: WORD, pub Reserved: WORD, - pub Flags: DWORD, - pub ValueCount: DWORD, - pub Values: _CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1 { - pub pInt64: PLONG64, - pub pUint64: PDWORD64, - pub ppString: *mut PWSTR, - pub pFqbn: PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE, - pub pOctetString: PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE, + pub Reserved2: DWORD, + pub Ranges: PPROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE, } #[test] -fn bindgen_test_layout__CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1() { +fn bindgen_test_layout__PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION() { assert_eq!( - ::std::mem::size_of::<_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1>(), - 8usize, + ::std::mem::size_of::<_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION>(), + 16usize, concat!( "Size of: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1) + stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION) ) ); assert_eq!( - ::std::mem::align_of::<_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1>(), + ::std::mem::align_of::<_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION>(), 8usize, concat!( "Alignment of ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1) + stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION) ) ); - fn test_field_pInt64() { + fn test_field_NumberOfRanges() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).pInt64) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).NumberOfRanges) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1), + stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION), "::", - stringify!(pInt64) + stringify!(NumberOfRanges) ) ); } - test_field_pInt64(); - fn test_field_pUint64() { + test_field_NumberOfRanges(); + fn test_field_Reserved() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).pUint64) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize }, - 0usize, + 2usize, concat!( "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1), + stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION), "::", - stringify!(pUint64) + stringify!(Reserved) ) ); } - test_field_pUint64(); - fn test_field_ppString() { + test_field_Reserved(); + fn test_field_Reserved2() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ppString) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Reserved2) as usize - ptr as usize }, - 0usize, + 4usize, concat!( "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1), + stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION), "::", - stringify!(ppString) + stringify!(Reserved2) ) ); } - test_field_ppString(); - fn test_field_pFqbn() { - assert_eq!( - unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).pFqbn) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1), - "::", - stringify!(pFqbn) - ) - ); - } - test_field_pFqbn(); - fn test_field_pOctetString() { + test_field_Reserved2(); + fn test_field_Ranges() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).pOctetString) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Ranges) as usize - ptr as usize }, - 0usize, + 8usize, concat!( "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1__bindgen_ty_1), + stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION), "::", - stringify!(pOctetString) + stringify!(Ranges) ) ); } - test_field_pOctetString(); + test_field_Ranges(); +} +pub type PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION = + _PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION; +pub type PPROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION = + *mut _PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _QUOTA_LIMITS { + pub PagedPoolLimit: SIZE_T, + pub NonPagedPoolLimit: SIZE_T, + pub MinimumWorkingSetSize: SIZE_T, + pub MaximumWorkingSetSize: SIZE_T, + pub PagefileLimit: SIZE_T, + pub TimeLimit: LARGE_INTEGER, } #[test] -fn bindgen_test_layout__CLAIM_SECURITY_ATTRIBUTE_V1() { +fn bindgen_test_layout__QUOTA_LIMITS() { assert_eq!( - ::std::mem::size_of::<_CLAIM_SECURITY_ATTRIBUTE_V1>(), - 32usize, - concat!("Size of: ", stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1)) + ::std::mem::size_of::<_QUOTA_LIMITS>(), + 48usize, + concat!("Size of: ", stringify!(_QUOTA_LIMITS)) ); assert_eq!( - ::std::mem::align_of::<_CLAIM_SECURITY_ATTRIBUTE_V1>(), + ::std::mem::align_of::<_QUOTA_LIMITS>(), 8usize, - concat!("Alignment of ", stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1)) + concat!("Alignment of ", stringify!(_QUOTA_LIMITS)) ); - fn test_field_Name() { + fn test_field_PagedPoolLimit() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Name) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).PagedPoolLimit) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1), + stringify!(_QUOTA_LIMITS), "::", - stringify!(Name) + stringify!(PagedPoolLimit) ) ); } - test_field_Name(); - fn test_field_ValueType() { + test_field_PagedPoolLimit(); + fn test_field_NonPagedPoolLimit() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ValueType) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).NonPagedPoolLimit) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1), + stringify!(_QUOTA_LIMITS), "::", - stringify!(ValueType) + stringify!(NonPagedPoolLimit) ) ); } - test_field_ValueType(); - fn test_field_Reserved() { + test_field_NonPagedPoolLimit(); + fn test_field_MinimumWorkingSetSize() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).MinimumWorkingSetSize) as usize - ptr as usize }, - 10usize, + 16usize, concat!( "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1), + stringify!(_QUOTA_LIMITS), "::", - stringify!(Reserved) + stringify!(MinimumWorkingSetSize) ) ); } - test_field_Reserved(); - fn test_field_Flags() { + test_field_MinimumWorkingSetSize(); + fn test_field_MaximumWorkingSetSize() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).MaximumWorkingSetSize) as usize - ptr as usize }, - 12usize, + 24usize, concat!( "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1), + stringify!(_QUOTA_LIMITS), "::", - stringify!(Flags) + stringify!(MaximumWorkingSetSize) ) ); } - test_field_Flags(); - fn test_field_ValueCount() { + test_field_MaximumWorkingSetSize(); + fn test_field_PagefileLimit() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ValueCount) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).PagefileLimit) as usize - ptr as usize }, - 16usize, + 32usize, concat!( "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1), + stringify!(_QUOTA_LIMITS), "::", - stringify!(ValueCount) + stringify!(PagefileLimit) ) ); } - test_field_ValueCount(); - fn test_field_Values() { + test_field_PagefileLimit(); + fn test_field_TimeLimit() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_V1>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Values) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).TimeLimit) as usize - ptr as usize }, - 24usize, + 40usize, concat!( "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_V1), + stringify!(_QUOTA_LIMITS), "::", - stringify!(Values) + stringify!(TimeLimit) ) ); } - test_field_Values(); + test_field_TimeLimit(); } -pub type CLAIM_SECURITY_ATTRIBUTE_V1 = _CLAIM_SECURITY_ATTRIBUTE_V1; -pub type PCLAIM_SECURITY_ATTRIBUTE_V1 = *mut _CLAIM_SECURITY_ATTRIBUTE_V1; +pub type QUOTA_LIMITS = _QUOTA_LIMITS; +pub type PQUOTA_LIMITS = *mut _QUOTA_LIMITS; #[repr(C)] #[derive(Copy, Clone)] -pub struct _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 { - pub Name: DWORD, - pub ValueType: WORD, - pub Reserved: WORD, - pub Flags: DWORD, - pub ValueCount: DWORD, - pub Values: _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1, +pub union _RATE_QUOTA_LIMIT { + pub RateData: DWORD, + pub __bindgen_anon_1: _RATE_QUOTA_LIMIT__bindgen_ty_1, } #[repr(C)] -#[derive(Copy, Clone)] -pub union _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1 { - pub pInt64: [DWORD; 1usize], - pub pUint64: [DWORD; 1usize], - pub ppString: [DWORD; 1usize], - pub pFqbn: [DWORD; 1usize], - pub pOctetString: [DWORD; 1usize], +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct _RATE_QUOTA_LIMIT__bindgen_ty_1 { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } #[test] -fn bindgen_test_layout__CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1() { +fn bindgen_test_layout__RATE_QUOTA_LIMIT__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1>(), + ::std::mem::size_of::<_RATE_QUOTA_LIMIT__bindgen_ty_1>(), 4usize, - concat!( - "Size of: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1) - ) + concat!("Size of: ", stringify!(_RATE_QUOTA_LIMIT__bindgen_ty_1)) ); assert_eq!( - ::std::mem::align_of::<_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1>(), + ::std::mem::align_of::<_RATE_QUOTA_LIMIT__bindgen_ty_1>(), 4usize, - concat!( - "Alignment of ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1) - ) + concat!("Alignment of ", stringify!(_RATE_QUOTA_LIMIT__bindgen_ty_1)) ); - fn test_field_pInt64() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).pInt64) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1), - "::", - stringify!(pInt64) - ) - ); +} +impl _RATE_QUOTA_LIMIT__bindgen_ty_1 { + #[inline] + pub fn RatePercent(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 7u8) as u32) } } - test_field_pInt64(); - fn test_field_pUint64() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).pUint64) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1), - "::", - stringify!(pUint64) - ) - ); + #[inline] + pub fn set_RatePercent(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 7u8, val as u64) + } } - test_field_pUint64(); - fn test_field_ppString() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ppString) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1), - "::", - stringify!(ppString) - ) - ); + #[inline] + pub fn Reserved0(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 25u8) as u32) } } - test_field_ppString(); - fn test_field_pFqbn() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).pFqbn) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1), - "::", - stringify!(pFqbn) - ) - ); + #[inline] + pub fn set_Reserved0(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 25u8, val as u64) + } } - test_field_pFqbn(); - fn test_field_pOctetString() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).pOctetString) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1__bindgen_ty_1), - "::", - stringify!(pOctetString) - ) - ); + #[inline] + pub fn new_bitfield_1( + RatePercent: DWORD, + Reserved0: DWORD, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 7u8, { + let RatePercent: u32 = unsafe { ::std::mem::transmute(RatePercent) }; + RatePercent as u64 + }); + __bindgen_bitfield_unit.set(7usize, 25u8, { + let Reserved0: u32 = unsafe { ::std::mem::transmute(Reserved0) }; + Reserved0 as u64 + }); + __bindgen_bitfield_unit } - test_field_pOctetString(); } #[test] -fn bindgen_test_layout__CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1() { +fn bindgen_test_layout__RATE_QUOTA_LIMIT() { assert_eq!( - ::std::mem::size_of::<_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1>(), - 20usize, - concat!( - "Size of: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1) - ) + ::std::mem::size_of::<_RATE_QUOTA_LIMIT>(), + 4usize, + concat!("Size of: ", stringify!(_RATE_QUOTA_LIMIT)) ); assert_eq!( - ::std::mem::align_of::<_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1>(), + ::std::mem::align_of::<_RATE_QUOTA_LIMIT>(), 4usize, - concat!( - "Alignment of ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1) - ) + concat!("Alignment of ", stringify!(_RATE_QUOTA_LIMIT)) ); - fn test_field_Name() { + fn test_field_RateData() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_RATE_QUOTA_LIMIT>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Name) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).RateData) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1), - "::", - stringify!(Name) - ) - ); - } - test_field_Name(); - fn test_field_ValueType() { - assert_eq!( - unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ValueType) as usize - ptr as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1), - "::", - stringify!(ValueType) - ) - ); - } - test_field_ValueType(); - fn test_field_Reserved() { - assert_eq!( - unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize - }, - 6usize, - concat!( - "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1), - "::", - stringify!(Reserved) - ) - ); - } - test_field_Reserved(); - fn test_field_Flags() { - assert_eq!( - unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1), - "::", - stringify!(Flags) - ) - ); - } - test_field_Flags(); - fn test_field_ValueCount() { - assert_eq!( - unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ValueCount) as usize - ptr as usize - }, - 12usize, - concat!( - "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1), - "::", - stringify!(ValueCount) - ) - ); - } - test_field_ValueCount(); - fn test_field_Values() { - assert_eq!( - unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Values) as usize - ptr as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1), + stringify!(_RATE_QUOTA_LIMIT), "::", - stringify!(Values) + stringify!(RateData) ) ); } - test_field_Values(); -} -pub type CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 = _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1; -pub type PCLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 = *mut _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _CLAIM_SECURITY_ATTRIBUTES_INFORMATION { - pub Version: WORD, - pub Reserved: WORD, - pub AttributeCount: DWORD, - pub Attribute: _CLAIM_SECURITY_ATTRIBUTES_INFORMATION__bindgen_ty_1, + test_field_RateData(); } +pub type RATE_QUOTA_LIMIT = _RATE_QUOTA_LIMIT; +pub type PRATE_QUOTA_LIMIT = *mut _RATE_QUOTA_LIMIT; #[repr(C)] #[derive(Copy, Clone)] -pub union _CLAIM_SECURITY_ATTRIBUTES_INFORMATION__bindgen_ty_1 { - pub pAttributeV1: PCLAIM_SECURITY_ATTRIBUTE_V1, -} -#[test] -fn bindgen_test_layout__CLAIM_SECURITY_ATTRIBUTES_INFORMATION__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_CLAIM_SECURITY_ATTRIBUTES_INFORMATION__bindgen_ty_1>(), - 8usize, - concat!( - "Size of: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTES_INFORMATION__bindgen_ty_1) - ) - ); - assert_eq!( - ::std::mem::align_of::<_CLAIM_SECURITY_ATTRIBUTES_INFORMATION__bindgen_ty_1>(), - 8usize, - concat!( - "Alignment of ", - stringify!(_CLAIM_SECURITY_ATTRIBUTES_INFORMATION__bindgen_ty_1) - ) - ); - fn test_field_pAttributeV1() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _CLAIM_SECURITY_ATTRIBUTES_INFORMATION__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).pAttributeV1) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTES_INFORMATION__bindgen_ty_1), - "::", - stringify!(pAttributeV1) - ) - ); - } - test_field_pAttributeV1(); +pub struct _QUOTA_LIMITS_EX { + pub PagedPoolLimit: SIZE_T, + pub NonPagedPoolLimit: SIZE_T, + pub MinimumWorkingSetSize: SIZE_T, + pub MaximumWorkingSetSize: SIZE_T, + pub PagefileLimit: SIZE_T, + pub TimeLimit: LARGE_INTEGER, + pub WorkingSetLimit: SIZE_T, + pub Reserved2: SIZE_T, + pub Reserved3: SIZE_T, + pub Reserved4: SIZE_T, + pub Flags: DWORD, + pub CpuRateLimit: RATE_QUOTA_LIMIT, } #[test] -fn bindgen_test_layout__CLAIM_SECURITY_ATTRIBUTES_INFORMATION() { +fn bindgen_test_layout__QUOTA_LIMITS_EX() { assert_eq!( - ::std::mem::size_of::<_CLAIM_SECURITY_ATTRIBUTES_INFORMATION>(), - 16usize, - concat!( - "Size of: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTES_INFORMATION) - ) + ::std::mem::size_of::<_QUOTA_LIMITS_EX>(), + 88usize, + concat!("Size of: ", stringify!(_QUOTA_LIMITS_EX)) ); assert_eq!( - ::std::mem::align_of::<_CLAIM_SECURITY_ATTRIBUTES_INFORMATION>(), + ::std::mem::align_of::<_QUOTA_LIMITS_EX>(), 8usize, - concat!( - "Alignment of ", - stringify!(_CLAIM_SECURITY_ATTRIBUTES_INFORMATION) - ) + concat!("Alignment of ", stringify!(_QUOTA_LIMITS_EX)) ); - fn test_field_Version() { + fn test_field_PagedPoolLimit() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTES_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Version) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).PagedPoolLimit) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTES_INFORMATION), + stringify!(_QUOTA_LIMITS_EX), "::", - stringify!(Version) + stringify!(PagedPoolLimit) ) ); } - test_field_Version(); - fn test_field_Reserved() { + test_field_PagedPoolLimit(); + fn test_field_NonPagedPoolLimit() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTES_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).NonPagedPoolLimit) as usize - ptr as usize }, - 2usize, + 8usize, concat!( "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTES_INFORMATION), + stringify!(_QUOTA_LIMITS_EX), "::", - stringify!(Reserved) + stringify!(NonPagedPoolLimit) ) ); } - test_field_Reserved(); - fn test_field_AttributeCount() { + test_field_NonPagedPoolLimit(); + fn test_field_MinimumWorkingSetSize() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTES_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AttributeCount) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).MinimumWorkingSetSize) as usize - ptr as usize }, - 4usize, + 16usize, concat!( "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTES_INFORMATION), + stringify!(_QUOTA_LIMITS_EX), "::", - stringify!(AttributeCount) + stringify!(MinimumWorkingSetSize) ) ); } - test_field_AttributeCount(); - fn test_field_Attribute() { + test_field_MinimumWorkingSetSize(); + fn test_field_MaximumWorkingSetSize() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_CLAIM_SECURITY_ATTRIBUTES_INFORMATION>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Attribute) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).MaximumWorkingSetSize) as usize - ptr as usize }, - 8usize, + 24usize, concat!( "Offset of field: ", - stringify!(_CLAIM_SECURITY_ATTRIBUTES_INFORMATION), + stringify!(_QUOTA_LIMITS_EX), "::", - stringify!(Attribute) + stringify!(MaximumWorkingSetSize) ) ); } - test_field_Attribute(); -} -pub type CLAIM_SECURITY_ATTRIBUTES_INFORMATION = _CLAIM_SECURITY_ATTRIBUTES_INFORMATION; -pub type PCLAIM_SECURITY_ATTRIBUTES_INFORMATION = *mut _CLAIM_SECURITY_ATTRIBUTES_INFORMATION; -pub type SECURITY_CONTEXT_TRACKING_MODE = BOOLEAN; -pub type PSECURITY_CONTEXT_TRACKING_MODE = *mut BOOLEAN; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SECURITY_QUALITY_OF_SERVICE { - pub Length: DWORD, - pub ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL, - pub ContextTrackingMode: SECURITY_CONTEXT_TRACKING_MODE, - pub EffectiveOnly: BOOLEAN, -} -#[test] -fn bindgen_test_layout__SECURITY_QUALITY_OF_SERVICE() { - assert_eq!( - ::std::mem::size_of::<_SECURITY_QUALITY_OF_SERVICE>(), - 12usize, - concat!("Size of: ", stringify!(_SECURITY_QUALITY_OF_SERVICE)) - ); - assert_eq!( - ::std::mem::align_of::<_SECURITY_QUALITY_OF_SERVICE>(), - 4usize, - concat!("Alignment of ", stringify!(_SECURITY_QUALITY_OF_SERVICE)) - ); - fn test_field_Length() { + test_field_MaximumWorkingSetSize(); + fn test_field_PagefileLimit() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_QUALITY_OF_SERVICE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Length) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).PagefileLimit) as usize - ptr as usize }, - 0usize, + 32usize, concat!( "Offset of field: ", - stringify!(_SECURITY_QUALITY_OF_SERVICE), + stringify!(_QUOTA_LIMITS_EX), "::", - stringify!(Length) + stringify!(PagefileLimit) ) ); } - test_field_Length(); - fn test_field_ImpersonationLevel() { + test_field_PagefileLimit(); + fn test_field_TimeLimit() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_QUALITY_OF_SERVICE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ImpersonationLevel) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).TimeLimit) as usize - ptr as usize }, - 4usize, + 40usize, concat!( "Offset of field: ", - stringify!(_SECURITY_QUALITY_OF_SERVICE), + stringify!(_QUOTA_LIMITS_EX), "::", - stringify!(ImpersonationLevel) + stringify!(TimeLimit) ) ); } - test_field_ImpersonationLevel(); - fn test_field_ContextTrackingMode() { + test_field_TimeLimit(); + fn test_field_WorkingSetLimit() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_QUALITY_OF_SERVICE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ContextTrackingMode) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).WorkingSetLimit) as usize - ptr as usize }, - 8usize, + 48usize, concat!( "Offset of field: ", - stringify!(_SECURITY_QUALITY_OF_SERVICE), + stringify!(_QUOTA_LIMITS_EX), "::", - stringify!(ContextTrackingMode) + stringify!(WorkingSetLimit) ) ); } - test_field_ContextTrackingMode(); - fn test_field_EffectiveOnly() { + test_field_WorkingSetLimit(); + fn test_field_Reserved2() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_QUALITY_OF_SERVICE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).EffectiveOnly) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Reserved2) as usize - ptr as usize }, - 9usize, + 56usize, concat!( "Offset of field: ", - stringify!(_SECURITY_QUALITY_OF_SERVICE), + stringify!(_QUOTA_LIMITS_EX), "::", - stringify!(EffectiveOnly) + stringify!(Reserved2) ) ); } - test_field_EffectiveOnly(); -} -pub type SECURITY_QUALITY_OF_SERVICE = _SECURITY_QUALITY_OF_SERVICE; -pub type PSECURITY_QUALITY_OF_SERVICE = *mut _SECURITY_QUALITY_OF_SERVICE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _SE_IMPERSONATION_STATE { - pub Token: PACCESS_TOKEN, - pub CopyOnOpen: BOOLEAN, - pub EffectiveOnly: BOOLEAN, - pub Level: SECURITY_IMPERSONATION_LEVEL, -} -#[test] -fn bindgen_test_layout__SE_IMPERSONATION_STATE() { - assert_eq!( - ::std::mem::size_of::<_SE_IMPERSONATION_STATE>(), - 16usize, - concat!("Size of: ", stringify!(_SE_IMPERSONATION_STATE)) - ); - assert_eq!( - ::std::mem::align_of::<_SE_IMPERSONATION_STATE>(), - 8usize, - concat!("Alignment of ", stringify!(_SE_IMPERSONATION_STATE)) - ); - fn test_field_Token() { + test_field_Reserved2(); + fn test_field_Reserved3() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_IMPERSONATION_STATE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Token) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Reserved3) as usize - ptr as usize }, - 0usize, + 64usize, concat!( "Offset of field: ", - stringify!(_SE_IMPERSONATION_STATE), + stringify!(_QUOTA_LIMITS_EX), "::", - stringify!(Token) + stringify!(Reserved3) ) ); } - test_field_Token(); - fn test_field_CopyOnOpen() { + test_field_Reserved3(); + fn test_field_Reserved4() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_IMPERSONATION_STATE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).CopyOnOpen) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Reserved4) as usize - ptr as usize }, - 8usize, + 72usize, concat!( "Offset of field: ", - stringify!(_SE_IMPERSONATION_STATE), + stringify!(_QUOTA_LIMITS_EX), "::", - stringify!(CopyOnOpen) + stringify!(Reserved4) ) ); } - test_field_CopyOnOpen(); - fn test_field_EffectiveOnly() { + test_field_Reserved4(); + fn test_field_Flags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_IMPERSONATION_STATE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).EffectiveOnly) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, - 9usize, + 80usize, concat!( "Offset of field: ", - stringify!(_SE_IMPERSONATION_STATE), + stringify!(_QUOTA_LIMITS_EX), "::", - stringify!(EffectiveOnly) + stringify!(Flags) ) ); } - test_field_EffectiveOnly(); - fn test_field_Level() { + test_field_Flags(); + fn test_field_CpuRateLimit() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SE_IMPERSONATION_STATE>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Level) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).CpuRateLimit) as usize - ptr as usize }, - 12usize, + 84usize, concat!( "Offset of field: ", - stringify!(_SE_IMPERSONATION_STATE), + stringify!(_QUOTA_LIMITS_EX), "::", - stringify!(Level) + stringify!(CpuRateLimit) ) ); } - test_field_Level(); -} -pub type SE_IMPERSONATION_STATE = _SE_IMPERSONATION_STATE; -pub type PSE_IMPERSONATION_STATE = *mut _SE_IMPERSONATION_STATE; -pub type SECURITY_INFORMATION = DWORD; -pub type PSECURITY_INFORMATION = *mut DWORD; -pub type SE_SIGNING_LEVEL = BYTE; -pub type PSE_SIGNING_LEVEL = *mut BYTE; -#[repr(i32)] -#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] -pub enum _SE_IMAGE_SIGNATURE_TYPE { - SeImageSignatureNone = 0, - SeImageSignatureEmbedded = 1, - SeImageSignatureCache = 2, - SeImageSignatureCatalogCached = 3, - SeImageSignatureCatalogNotCached = 4, - SeImageSignatureCatalogHint = 5, - SeImageSignaturePackageCatalog = 6, - SeImageSignaturePplMitigated = 7, + test_field_CpuRateLimit(); } -pub use self::_SE_IMAGE_SIGNATURE_TYPE as SE_IMAGE_SIGNATURE_TYPE; -pub type PSE_IMAGE_SIGNATURE_TYPE = *mut _SE_IMAGE_SIGNATURE_TYPE; +pub type QUOTA_LIMITS_EX = _QUOTA_LIMITS_EX; +pub type PQUOTA_LIMITS_EX = *mut _QUOTA_LIMITS_EX; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _SECURITY_CAPABILITIES { - pub AppContainerSid: PSID, - pub Capabilities: PSID_AND_ATTRIBUTES, - pub CapabilityCount: DWORD, - pub Reserved: DWORD, +pub struct _IO_COUNTERS { + pub ReadOperationCount: ULONGLONG, + pub WriteOperationCount: ULONGLONG, + pub OtherOperationCount: ULONGLONG, + pub ReadTransferCount: ULONGLONG, + pub WriteTransferCount: ULONGLONG, + pub OtherTransferCount: ULONGLONG, } #[test] -fn bindgen_test_layout__SECURITY_CAPABILITIES() { +fn bindgen_test_layout__IO_COUNTERS() { assert_eq!( - ::std::mem::size_of::<_SECURITY_CAPABILITIES>(), - 24usize, - concat!("Size of: ", stringify!(_SECURITY_CAPABILITIES)) + ::std::mem::size_of::<_IO_COUNTERS>(), + 48usize, + concat!("Size of: ", stringify!(_IO_COUNTERS)) ); assert_eq!( - ::std::mem::align_of::<_SECURITY_CAPABILITIES>(), + ::std::mem::align_of::<_IO_COUNTERS>(), 8usize, - concat!("Alignment of ", stringify!(_SECURITY_CAPABILITIES)) + concat!("Alignment of ", stringify!(_IO_COUNTERS)) ); - fn test_field_AppContainerSid() { + fn test_field_ReadOperationCount() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_CAPABILITIES>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_IO_COUNTERS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).AppContainerSid) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ReadOperationCount) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_SECURITY_CAPABILITIES), + stringify!(_IO_COUNTERS), "::", - stringify!(AppContainerSid) + stringify!(ReadOperationCount) ) ); } - test_field_AppContainerSid(); - fn test_field_Capabilities() { + test_field_ReadOperationCount(); + fn test_field_WriteOperationCount() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_CAPABILITIES>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_IO_COUNTERS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Capabilities) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).WriteOperationCount) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_SECURITY_CAPABILITIES), + stringify!(_IO_COUNTERS), "::", - stringify!(Capabilities) + stringify!(WriteOperationCount) ) ); } - test_field_Capabilities(); - fn test_field_CapabilityCount() { + test_field_WriteOperationCount(); + fn test_field_OtherOperationCount() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_CAPABILITIES>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_IO_COUNTERS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).CapabilityCount) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).OtherOperationCount) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", - stringify!(_SECURITY_CAPABILITIES), - "::", - stringify!(CapabilityCount) - ) - ); - } - test_field_CapabilityCount(); - fn test_field_Reserved() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_SECURITY_CAPABILITIES>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize - }, - 20usize, - concat!( - "Offset of field: ", - stringify!(_SECURITY_CAPABILITIES), + stringify!(_IO_COUNTERS), "::", - stringify!(Reserved) + stringify!(OtherOperationCount) ) ); } - test_field_Reserved(); -} -pub type SECURITY_CAPABILITIES = _SECURITY_CAPABILITIES; -pub type PSECURITY_CAPABILITIES = *mut _SECURITY_CAPABILITIES; -pub type LPSECURITY_CAPABILITIES = *mut _SECURITY_CAPABILITIES; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _JOB_SET_ARRAY { - pub JobHandle: HANDLE, - pub MemberLevel: DWORD, - pub Flags: DWORD, -} -#[test] -fn bindgen_test_layout__JOB_SET_ARRAY() { - assert_eq!( - ::std::mem::size_of::<_JOB_SET_ARRAY>(), - 16usize, - concat!("Size of: ", stringify!(_JOB_SET_ARRAY)) - ); - assert_eq!( - ::std::mem::align_of::<_JOB_SET_ARRAY>(), - 8usize, - concat!("Alignment of ", stringify!(_JOB_SET_ARRAY)) - ); - fn test_field_JobHandle() { + test_field_OtherOperationCount(); + fn test_field_ReadTransferCount() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JOB_SET_ARRAY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_IO_COUNTERS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).JobHandle) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ReadTransferCount) as usize - ptr as usize }, - 0usize, + 24usize, concat!( "Offset of field: ", - stringify!(_JOB_SET_ARRAY), + stringify!(_IO_COUNTERS), "::", - stringify!(JobHandle) + stringify!(ReadTransferCount) ) ); } - test_field_JobHandle(); - fn test_field_MemberLevel() { + test_field_ReadTransferCount(); + fn test_field_WriteTransferCount() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JOB_SET_ARRAY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_IO_COUNTERS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).MemberLevel) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).WriteTransferCount) as usize - ptr as usize }, - 8usize, + 32usize, concat!( "Offset of field: ", - stringify!(_JOB_SET_ARRAY), + stringify!(_IO_COUNTERS), "::", - stringify!(MemberLevel) + stringify!(WriteTransferCount) ) ); } - test_field_MemberLevel(); - fn test_field_Flags() { + test_field_WriteTransferCount(); + fn test_field_OtherTransferCount() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_JOB_SET_ARRAY>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_IO_COUNTERS>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).OtherTransferCount) as usize - ptr as usize }, - 12usize, + 40usize, concat!( "Offset of field: ", - stringify!(_JOB_SET_ARRAY), + stringify!(_IO_COUNTERS), "::", - stringify!(Flags) + stringify!(OtherTransferCount) ) ); } - test_field_Flags(); + test_field_OtherTransferCount(); } -pub type JOB_SET_ARRAY = _JOB_SET_ARRAY; -pub type PJOB_SET_ARRAY = *mut _JOB_SET_ARRAY; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _EXCEPTION_REGISTRATION_RECORD { - pub Next: *mut _EXCEPTION_REGISTRATION_RECORD, - pub Handler: PEXCEPTION_ROUTINE, +pub type IO_COUNTERS = _IO_COUNTERS; +pub type PIO_COUNTERS = *mut IO_COUNTERS; +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _HARDWARE_COUNTER_TYPE { + PMCCounter = 0, + MaxHardwareCounterType = 1, } -#[test] -fn bindgen_test_layout__EXCEPTION_REGISTRATION_RECORD() { - assert_eq!( - ::std::mem::size_of::<_EXCEPTION_REGISTRATION_RECORD>(), - 16usize, - concat!("Size of: ", stringify!(_EXCEPTION_REGISTRATION_RECORD)) - ); - assert_eq!( - ::std::mem::align_of::<_EXCEPTION_REGISTRATION_RECORD>(), - 8usize, - concat!("Alignment of ", stringify!(_EXCEPTION_REGISTRATION_RECORD)) - ); - fn test_field_Next() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_REGISTRATION_RECORD>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Next) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_EXCEPTION_REGISTRATION_RECORD), - "::", - stringify!(Next) - ) - ); - } - test_field_Next(); - fn test_field_Handler() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_EXCEPTION_REGISTRATION_RECORD>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Handler) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(_EXCEPTION_REGISTRATION_RECORD), - "::", - stringify!(Handler) - ) - ); - } - test_field_Handler(); +pub use self::_HARDWARE_COUNTER_TYPE as HARDWARE_COUNTER_TYPE; +pub type PHARDWARE_COUNTER_TYPE = *mut _HARDWARE_COUNTER_TYPE; +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _PROCESS_MITIGATION_POLICY { + ProcessDEPPolicy = 0, + ProcessASLRPolicy = 1, + ProcessDynamicCodePolicy = 2, + ProcessStrictHandleCheckPolicy = 3, + ProcessSystemCallDisablePolicy = 4, + ProcessMitigationOptionsMask = 5, + ProcessExtensionPointDisablePolicy = 6, + ProcessControlFlowGuardPolicy = 7, + ProcessSignaturePolicy = 8, + ProcessFontDisablePolicy = 9, + ProcessImageLoadPolicy = 10, + ProcessSystemCallFilterPolicy = 11, + ProcessPayloadRestrictionPolicy = 12, + ProcessChildProcessPolicy = 13, + ProcessSideChannelIsolationPolicy = 14, + ProcessUserShadowStackPolicy = 15, + ProcessRedirectionTrustPolicy = 16, + ProcessUserPointerAuthPolicy = 17, + ProcessSEHOPPolicy = 18, + MaxProcessMitigationPolicy = 19, } -pub type EXCEPTION_REGISTRATION_RECORD = _EXCEPTION_REGISTRATION_RECORD; -pub type PEXCEPTION_REGISTRATION_RECORD = *mut EXCEPTION_REGISTRATION_RECORD; +pub use self::_PROCESS_MITIGATION_POLICY as PROCESS_MITIGATION_POLICY; +pub type PPROCESS_MITIGATION_POLICY = *mut _PROCESS_MITIGATION_POLICY; #[repr(C)] #[derive(Copy, Clone)] -pub struct _NT_TIB { - pub ExceptionList: *mut _EXCEPTION_REGISTRATION_RECORD, - pub StackBase: PVOID, - pub StackLimit: PVOID, - pub SubSystemTib: PVOID, - pub __bindgen_anon_1: _NT_TIB__bindgen_ty_1, - pub ArbitraryUserPointer: PVOID, - pub Self_: *mut _NT_TIB, +pub struct _PROCESS_MITIGATION_ASLR_POLICY { + pub __bindgen_anon_1: _PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] -pub union _NT_TIB__bindgen_ty_1 { - pub FiberData: PVOID, - pub Version: DWORD, +pub union _PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1 { + pub Flags: DWORD, + pub __bindgen_anon_1: _PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1__bindgen_ty_1, +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct _PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1__bindgen_ty_1 { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } #[test] -fn bindgen_test_layout__NT_TIB__bindgen_ty_1() { +fn bindgen_test_layout__PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_NT_TIB__bindgen_ty_1>(), - 8usize, - concat!("Size of: ", stringify!(_NT_TIB__bindgen_ty_1)) + ::std::mem::size_of::<_PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1__bindgen_ty_1>(), + 4usize, + concat!( + "Size of: ", + stringify!(_PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1__bindgen_ty_1) + ) ); assert_eq!( - ::std::mem::align_of::<_NT_TIB__bindgen_ty_1>(), - 8usize, - concat!("Alignment of ", stringify!(_NT_TIB__bindgen_ty_1)) - ); - fn test_field_FiberData() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB__bindgen_ty_1>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).FiberData) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_NT_TIB__bindgen_ty_1), - "::", - stringify!(FiberData) - ) - ); + ::std::mem::align_of::<_PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1__bindgen_ty_1>(), + 4usize, + concat!( + "Alignment of ", + stringify!(_PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1__bindgen_ty_1) + ) + ); +} +impl _PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1__bindgen_ty_1 { + #[inline] + pub fn EnableBottomUpRandomization(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } } - test_field_FiberData(); - fn test_field_Version() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB__bindgen_ty_1>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Version) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_NT_TIB__bindgen_ty_1), - "::", - stringify!(Version) - ) - ); + #[inline] + pub fn set_EnableBottomUpRandomization(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn EnableForceRelocateImages(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_EnableForceRelocateImages(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn EnableHighEntropy(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_EnableHighEntropy(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn DisallowStrippedImages(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_DisallowStrippedImages(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn ReservedFlags(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 28u8) as u32) } + } + #[inline] + pub fn set_ReservedFlags(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 28u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + EnableBottomUpRandomization: DWORD, + EnableForceRelocateImages: DWORD, + EnableHighEntropy: DWORD, + DisallowStrippedImages: DWORD, + ReservedFlags: DWORD, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let EnableBottomUpRandomization: u32 = + unsafe { ::std::mem::transmute(EnableBottomUpRandomization) }; + EnableBottomUpRandomization as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let EnableForceRelocateImages: u32 = + unsafe { ::std::mem::transmute(EnableForceRelocateImages) }; + EnableForceRelocateImages as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let EnableHighEntropy: u32 = unsafe { ::std::mem::transmute(EnableHighEntropy) }; + EnableHighEntropy as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let DisallowStrippedImages: u32 = + unsafe { ::std::mem::transmute(DisallowStrippedImages) }; + DisallowStrippedImages as u64 + }); + __bindgen_bitfield_unit.set(4usize, 28u8, { + let ReservedFlags: u32 = unsafe { ::std::mem::transmute(ReservedFlags) }; + ReservedFlags as u64 + }); + __bindgen_bitfield_unit } - test_field_Version(); } #[test] -fn bindgen_test_layout__NT_TIB() { +fn bindgen_test_layout__PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_NT_TIB>(), - 56usize, - concat!("Size of: ", stringify!(_NT_TIB)) + ::std::mem::size_of::<_PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1>(), + 4usize, + concat!( + "Size of: ", + stringify!(_PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1) + ) ); assert_eq!( - ::std::mem::align_of::<_NT_TIB>(), - 8usize, - concat!("Alignment of ", stringify!(_NT_TIB)) + ::std::mem::align_of::<_PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1>(), + 4usize, + concat!( + "Alignment of ", + stringify!(_PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1) + ) ); - fn test_field_ExceptionList() { + fn test_field_Flags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB>::uninit(); + let uninit = :: std :: mem :: MaybeUninit :: < _PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1 > :: uninit () ; let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExceptionList) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_NT_TIB), - "::", - stringify!(ExceptionList) - ) - ); - } - test_field_ExceptionList(); - fn test_field_StackBase() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).StackBase) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(_NT_TIB), - "::", - stringify!(StackBase) - ) - ); - } - test_field_StackBase(); - fn test_field_StackLimit() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).StackLimit) as usize - ptr as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(_NT_TIB), - "::", - stringify!(StackLimit) - ) - ); - } - test_field_StackLimit(); - fn test_field_SubSystemTib() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SubSystemTib) as usize - ptr as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(_NT_TIB), - "::", - stringify!(SubSystemTib) - ) - ); - } - test_field_SubSystemTib(); - fn test_field_ArbitraryUserPointer() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ArbitraryUserPointer) as usize - ptr as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(_NT_TIB), - "::", - stringify!(ArbitraryUserPointer) - ) - ); - } - test_field_ArbitraryUserPointer(); - fn test_field_Self() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Self_) as usize - ptr as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(_NT_TIB), + stringify!(_PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1), "::", - stringify!(Self_) + stringify!(Flags) ) ); } - test_field_Self(); + test_field_Flags(); } -pub type NT_TIB = _NT_TIB; -pub type PNT_TIB = *mut NT_TIB; +#[test] +fn bindgen_test_layout__PROCESS_MITIGATION_ASLR_POLICY() { + assert_eq!( + ::std::mem::size_of::<_PROCESS_MITIGATION_ASLR_POLICY>(), + 4usize, + concat!("Size of: ", stringify!(_PROCESS_MITIGATION_ASLR_POLICY)) + ); + assert_eq!( + ::std::mem::align_of::<_PROCESS_MITIGATION_ASLR_POLICY>(), + 4usize, + concat!("Alignment of ", stringify!(_PROCESS_MITIGATION_ASLR_POLICY)) + ); +} +pub type PROCESS_MITIGATION_ASLR_POLICY = _PROCESS_MITIGATION_ASLR_POLICY; +pub type PPROCESS_MITIGATION_ASLR_POLICY = *mut _PROCESS_MITIGATION_ASLR_POLICY; #[repr(C)] #[derive(Copy, Clone)] -pub struct _NT_TIB32 { - pub ExceptionList: DWORD, - pub StackBase: DWORD, - pub StackLimit: DWORD, - pub SubSystemTib: DWORD, - pub __bindgen_anon_1: _NT_TIB32__bindgen_ty_1, - pub ArbitraryUserPointer: DWORD, - pub Self_: DWORD, +pub struct _PROCESS_MITIGATION_DEP_POLICY { + pub __bindgen_anon_1: _PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1, + pub Permanent: BOOLEAN, } #[repr(C)] #[derive(Copy, Clone)] -pub union _NT_TIB32__bindgen_ty_1 { - pub FiberData: DWORD, - pub Version: DWORD, +pub union _PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1 { + pub Flags: DWORD, + pub __bindgen_anon_1: _PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1__bindgen_ty_1, +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct _PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1__bindgen_ty_1 { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } #[test] -fn bindgen_test_layout__NT_TIB32__bindgen_ty_1() { +fn bindgen_test_layout__PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_NT_TIB32__bindgen_ty_1>(), + ::std::mem::size_of::<_PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1__bindgen_ty_1>(), 4usize, - concat!("Size of: ", stringify!(_NT_TIB32__bindgen_ty_1)) + concat!( + "Size of: ", + stringify!(_PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1__bindgen_ty_1) + ) ); assert_eq!( - ::std::mem::align_of::<_NT_TIB32__bindgen_ty_1>(), + ::std::mem::align_of::<_PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1__bindgen_ty_1>(), 4usize, - concat!("Alignment of ", stringify!(_NT_TIB32__bindgen_ty_1)) + concat!( + "Alignment of ", + stringify!(_PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1__bindgen_ty_1) + ) ); - fn test_field_FiberData() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB32__bindgen_ty_1>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).FiberData) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_NT_TIB32__bindgen_ty_1), - "::", - stringify!(FiberData) - ) - ); +} +impl _PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1__bindgen_ty_1 { + #[inline] + pub fn Enable(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } } - test_field_FiberData(); - fn test_field_Version() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB32__bindgen_ty_1>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Version) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_NT_TIB32__bindgen_ty_1), - "::", - stringify!(Version) - ) - ); + #[inline] + pub fn set_Enable(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn DisableAtlThunkEmulation(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_DisableAtlThunkEmulation(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn ReservedFlags(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_ReservedFlags(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + Enable: DWORD, + DisableAtlThunkEmulation: DWORD, + ReservedFlags: DWORD, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let Enable: u32 = unsafe { ::std::mem::transmute(Enable) }; + Enable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let DisableAtlThunkEmulation: u32 = + unsafe { ::std::mem::transmute(DisableAtlThunkEmulation) }; + DisableAtlThunkEmulation as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let ReservedFlags: u32 = unsafe { ::std::mem::transmute(ReservedFlags) }; + ReservedFlags as u64 + }); + __bindgen_bitfield_unit } - test_field_Version(); } #[test] -fn bindgen_test_layout__NT_TIB32() { +fn bindgen_test_layout__PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_NT_TIB32>(), - 28usize, - concat!("Size of: ", stringify!(_NT_TIB32)) + ::std::mem::size_of::<_PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1>(), + 4usize, + concat!( + "Size of: ", + stringify!(_PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1) + ) ); assert_eq!( - ::std::mem::align_of::<_NT_TIB32>(), + ::std::mem::align_of::<_PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1>(), 4usize, - concat!("Alignment of ", stringify!(_NT_TIB32)) + concat!( + "Alignment of ", + stringify!(_PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1) + ) ); - fn test_field_ExceptionList() { + fn test_field_Flags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB32>::uninit(); + let uninit = + ::std::mem::MaybeUninit::<_PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1>::uninit( + ); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExceptionList) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_NT_TIB32), + stringify!(_PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1), "::", - stringify!(ExceptionList) + stringify!(Flags) ) ); } - test_field_ExceptionList(); - fn test_field_StackBase() { + test_field_Flags(); +} +#[test] +fn bindgen_test_layout__PROCESS_MITIGATION_DEP_POLICY() { + assert_eq!( + ::std::mem::size_of::<_PROCESS_MITIGATION_DEP_POLICY>(), + 8usize, + concat!("Size of: ", stringify!(_PROCESS_MITIGATION_DEP_POLICY)) + ); + assert_eq!( + ::std::mem::align_of::<_PROCESS_MITIGATION_DEP_POLICY>(), + 4usize, + concat!("Alignment of ", stringify!(_PROCESS_MITIGATION_DEP_POLICY)) + ); + fn test_field_Permanent() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB32>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_PROCESS_MITIGATION_DEP_POLICY>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).StackBase) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Permanent) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", - stringify!(_NT_TIB32), - "::", - stringify!(StackBase) - ) - ); - } - test_field_StackBase(); - fn test_field_StackLimit() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB32>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).StackLimit) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(_NT_TIB32), - "::", - stringify!(StackLimit) - ) - ); - } - test_field_StackLimit(); - fn test_field_SubSystemTib() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB32>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SubSystemTib) as usize - ptr as usize - }, - 12usize, - concat!( - "Offset of field: ", - stringify!(_NT_TIB32), - "::", - stringify!(SubSystemTib) - ) - ); - } - test_field_SubSystemTib(); - fn test_field_ArbitraryUserPointer() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB32>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ArbitraryUserPointer) as usize - ptr as usize - }, - 20usize, - concat!( - "Offset of field: ", - stringify!(_NT_TIB32), - "::", - stringify!(ArbitraryUserPointer) - ) - ); - } - test_field_ArbitraryUserPointer(); - fn test_field_Self() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB32>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Self_) as usize - ptr as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(_NT_TIB32), + stringify!(_PROCESS_MITIGATION_DEP_POLICY), "::", - stringify!(Self_) + stringify!(Permanent) ) ); } - test_field_Self(); + test_field_Permanent(); } -pub type NT_TIB32 = _NT_TIB32; -pub type PNT_TIB32 = *mut _NT_TIB32; +pub type PROCESS_MITIGATION_DEP_POLICY = _PROCESS_MITIGATION_DEP_POLICY; +pub type PPROCESS_MITIGATION_DEP_POLICY = *mut _PROCESS_MITIGATION_DEP_POLICY; #[repr(C)] #[derive(Copy, Clone)] -pub struct _NT_TIB64 { - pub ExceptionList: DWORD64, - pub StackBase: DWORD64, - pub StackLimit: DWORD64, - pub SubSystemTib: DWORD64, - pub __bindgen_anon_1: _NT_TIB64__bindgen_ty_1, - pub ArbitraryUserPointer: DWORD64, - pub Self_: DWORD64, +pub struct _PROCESS_MITIGATION_SEHOP_POLICY { + pub __bindgen_anon_1: _PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] -pub union _NT_TIB64__bindgen_ty_1 { - pub FiberData: DWORD64, - pub Version: DWORD, +pub union _PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1 { + pub Flags: DWORD, + pub __bindgen_anon_1: _PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1__bindgen_ty_1, +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct _PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1__bindgen_ty_1 { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } #[test] -fn bindgen_test_layout__NT_TIB64__bindgen_ty_1() { +fn bindgen_test_layout__PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_NT_TIB64__bindgen_ty_1>(), - 8usize, - concat!("Size of: ", stringify!(_NT_TIB64__bindgen_ty_1)) + ::std::mem::size_of::<_PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1__bindgen_ty_1>(), + 4usize, + concat!( + "Size of: ", + stringify!(_PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1__bindgen_ty_1) + ) ); assert_eq!( - ::std::mem::align_of::<_NT_TIB64__bindgen_ty_1>(), - 8usize, - concat!("Alignment of ", stringify!(_NT_TIB64__bindgen_ty_1)) + ::std::mem::align_of::<_PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1__bindgen_ty_1>(), + 4usize, + concat!( + "Alignment of ", + stringify!(_PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1__bindgen_ty_1) + ) ); - fn test_field_FiberData() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB64__bindgen_ty_1>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).FiberData) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_NT_TIB64__bindgen_ty_1), - "::", - stringify!(FiberData) - ) - ); +} +impl _PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1__bindgen_ty_1 { + #[inline] + pub fn EnableSehop(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } } - test_field_FiberData(); - fn test_field_Version() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB64__bindgen_ty_1>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Version) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_NT_TIB64__bindgen_ty_1), - "::", - stringify!(Version) - ) - ); + #[inline] + pub fn set_EnableSehop(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn ReservedFlags(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_ReservedFlags(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + EnableSehop: DWORD, + ReservedFlags: DWORD, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let EnableSehop: u32 = unsafe { ::std::mem::transmute(EnableSehop) }; + EnableSehop as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let ReservedFlags: u32 = unsafe { ::std::mem::transmute(ReservedFlags) }; + ReservedFlags as u64 + }); + __bindgen_bitfield_unit } - test_field_Version(); } #[test] -fn bindgen_test_layout__NT_TIB64() { +fn bindgen_test_layout__PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_NT_TIB64>(), - 56usize, - concat!("Size of: ", stringify!(_NT_TIB64)) + ::std::mem::size_of::<_PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1>(), + 4usize, + concat!( + "Size of: ", + stringify!(_PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1) + ) ); assert_eq!( - ::std::mem::align_of::<_NT_TIB64>(), - 8usize, - concat!("Alignment of ", stringify!(_NT_TIB64)) + ::std::mem::align_of::<_PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1>(), + 4usize, + concat!( + "Alignment of ", + stringify!(_PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1) + ) ); - fn test_field_ExceptionList() { + fn test_field_Flags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB64>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ExceptionList) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_NT_TIB64), - "::", - stringify!(ExceptionList) - ) - ); - } - test_field_ExceptionList(); - fn test_field_StackBase() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB64>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).StackBase) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(_NT_TIB64), - "::", - stringify!(StackBase) - ) - ); - } - test_field_StackBase(); - fn test_field_StackLimit() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB64>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).StackLimit) as usize - ptr as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(_NT_TIB64), - "::", - stringify!(StackLimit) - ) - ); - } - test_field_StackLimit(); - fn test_field_SubSystemTib() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB64>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).SubSystemTib) as usize - ptr as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(_NT_TIB64), - "::", - stringify!(SubSystemTib) - ) - ); - } - test_field_SubSystemTib(); - fn test_field_ArbitraryUserPointer() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB64>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ArbitraryUserPointer) as usize - ptr as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(_NT_TIB64), - "::", - stringify!(ArbitraryUserPointer) - ) - ); - } - test_field_ArbitraryUserPointer(); - fn test_field_Self() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_NT_TIB64>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Self_) as usize - ptr as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(_NT_TIB64), + stringify!(_PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1), "::", - stringify!(Self_) + stringify!(Flags) ) ); } - test_field_Self(); -} -pub type NT_TIB64 = _NT_TIB64; -pub type PNT_TIB64 = *mut _NT_TIB64; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _UMS_CREATE_THREAD_ATTRIBUTES { - pub UmsVersion: DWORD, - pub UmsContext: PVOID, - pub UmsCompletionList: PVOID, + test_field_Flags(); } #[test] -fn bindgen_test_layout__UMS_CREATE_THREAD_ATTRIBUTES() { +fn bindgen_test_layout__PROCESS_MITIGATION_SEHOP_POLICY() { assert_eq!( - ::std::mem::size_of::<_UMS_CREATE_THREAD_ATTRIBUTES>(), - 24usize, - concat!("Size of: ", stringify!(_UMS_CREATE_THREAD_ATTRIBUTES)) + ::std::mem::size_of::<_PROCESS_MITIGATION_SEHOP_POLICY>(), + 4usize, + concat!("Size of: ", stringify!(_PROCESS_MITIGATION_SEHOP_POLICY)) ); assert_eq!( - ::std::mem::align_of::<_UMS_CREATE_THREAD_ATTRIBUTES>(), - 8usize, - concat!("Alignment of ", stringify!(_UMS_CREATE_THREAD_ATTRIBUTES)) + ::std::mem::align_of::<_PROCESS_MITIGATION_SEHOP_POLICY>(), + 4usize, + concat!( + "Alignment of ", + stringify!(_PROCESS_MITIGATION_SEHOP_POLICY) + ) ); - fn test_field_UmsVersion() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_UMS_CREATE_THREAD_ATTRIBUTES>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).UmsVersion) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_UMS_CREATE_THREAD_ATTRIBUTES), - "::", - stringify!(UmsVersion) - ) - ); - } - test_field_UmsVersion(); - fn test_field_UmsContext() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_UMS_CREATE_THREAD_ATTRIBUTES>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).UmsContext) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(_UMS_CREATE_THREAD_ATTRIBUTES), - "::", - stringify!(UmsContext) - ) - ); - } - test_field_UmsContext(); - fn test_field_UmsCompletionList() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_UMS_CREATE_THREAD_ATTRIBUTES>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).UmsCompletionList) as usize - ptr as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(_UMS_CREATE_THREAD_ATTRIBUTES), - "::", - stringify!(UmsCompletionList) - ) - ); - } - test_field_UmsCompletionList(); } -pub type UMS_CREATE_THREAD_ATTRIBUTES = _UMS_CREATE_THREAD_ATTRIBUTES; -pub type PUMS_CREATE_THREAD_ATTRIBUTES = *mut _UMS_CREATE_THREAD_ATTRIBUTES; +pub type PROCESS_MITIGATION_SEHOP_POLICY = _PROCESS_MITIGATION_SEHOP_POLICY; +pub type PPROCESS_MITIGATION_SEHOP_POLICY = *mut _PROCESS_MITIGATION_SEHOP_POLICY; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY { + pub __bindgen_anon_1: _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1, +} #[repr(C)] +#[derive(Copy, Clone)] +pub union _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1 { + pub Flags: DWORD, + pub __bindgen_anon_1: + _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1__bindgen_ty_1, +} +#[repr(C)] +#[repr(align(4))] #[derive(Debug, Copy, Clone)] -pub struct _COMPONENT_FILTER { - pub ComponentFlags: DWORD, +pub struct _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1__bindgen_ty_1 { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } #[test] -fn bindgen_test_layout__COMPONENT_FILTER() { +fn bindgen_test_layout__PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1__bindgen_ty_1() +{ assert_eq!( - ::std::mem::size_of::<_COMPONENT_FILTER>(), + ::std::mem::size_of::< + _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1__bindgen_ty_1, + >(), 4usize, - concat!("Size of: ", stringify!(_COMPONENT_FILTER)) + concat!( + "Size of: ", + stringify!(_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1__bindgen_ty_1) + ) ); assert_eq!( - ::std::mem::align_of::<_COMPONENT_FILTER>(), + ::std::mem::align_of::< + _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1__bindgen_ty_1, + >(), 4usize, - concat!("Alignment of ", stringify!(_COMPONENT_FILTER)) + concat!( + "Alignment of ", + stringify!(_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1__bindgen_ty_1) + ) ); - fn test_field_ComponentFlags() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_COMPONENT_FILTER>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ComponentFlags) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_COMPONENT_FILTER), - "::", - stringify!(ComponentFlags) - ) - ); - } - test_field_ComponentFlags(); } -pub type COMPONENT_FILTER = _COMPONENT_FILTER; -pub type PCOMPONENT_FILTER = *mut _COMPONENT_FILTER; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _PROCESS_DYNAMIC_EH_CONTINUATION_TARGET { - pub TargetAddress: ULONG_PTR, - pub Flags: ULONG_PTR, +impl _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1__bindgen_ty_1 { + #[inline] + pub fn RaiseExceptionOnInvalidHandleReference(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_RaiseExceptionOnInvalidHandleReference(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn HandleExceptionsPermanentlyEnabled(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_HandleExceptionsPermanentlyEnabled(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn ReservedFlags(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_ReservedFlags(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + RaiseExceptionOnInvalidHandleReference: DWORD, + HandleExceptionsPermanentlyEnabled: DWORD, + ReservedFlags: DWORD, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let RaiseExceptionOnInvalidHandleReference: u32 = + unsafe { ::std::mem::transmute(RaiseExceptionOnInvalidHandleReference) }; + RaiseExceptionOnInvalidHandleReference as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let HandleExceptionsPermanentlyEnabled: u32 = + unsafe { ::std::mem::transmute(HandleExceptionsPermanentlyEnabled) }; + HandleExceptionsPermanentlyEnabled as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let ReservedFlags: u32 = unsafe { ::std::mem::transmute(ReservedFlags) }; + ReservedFlags as u64 + }); + __bindgen_bitfield_unit + } } #[test] -fn bindgen_test_layout__PROCESS_DYNAMIC_EH_CONTINUATION_TARGET() { +fn bindgen_test_layout__PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_PROCESS_DYNAMIC_EH_CONTINUATION_TARGET>(), - 16usize, + ::std::mem::size_of::<_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1>(), + 4usize, concat!( "Size of: ", - stringify!(_PROCESS_DYNAMIC_EH_CONTINUATION_TARGET) + stringify!(_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1) ) ); assert_eq!( - ::std::mem::align_of::<_PROCESS_DYNAMIC_EH_CONTINUATION_TARGET>(), - 8usize, + ::std::mem::align_of::<_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1>(), + 4usize, concat!( "Alignment of ", - stringify!(_PROCESS_DYNAMIC_EH_CONTINUATION_TARGET) + stringify!(_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1) ) ); - fn test_field_TargetAddress() { - assert_eq!( - unsafe { - let uninit = - ::std::mem::MaybeUninit::<_PROCESS_DYNAMIC_EH_CONTINUATION_TARGET>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).TargetAddress) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_PROCESS_DYNAMIC_EH_CONTINUATION_TARGET), - "::", - stringify!(TargetAddress) - ) - ); - } - test_field_TargetAddress(); fn test_field_Flags() { assert_eq!( unsafe { - let uninit = - ::std::mem::MaybeUninit::<_PROCESS_DYNAMIC_EH_CONTINUATION_TARGET>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, - 8usize, + 0usize, concat!( "Offset of field: ", - stringify!(_PROCESS_DYNAMIC_EH_CONTINUATION_TARGET), + stringify!(_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1), "::", stringify!(Flags) ) @@ -42876,1002 +43187,419 @@ fn bindgen_test_layout__PROCESS_DYNAMIC_EH_CONTINUATION_TARGET() { } test_field_Flags(); } -pub type PROCESS_DYNAMIC_EH_CONTINUATION_TARGET = _PROCESS_DYNAMIC_EH_CONTINUATION_TARGET; -pub type PPROCESS_DYNAMIC_EH_CONTINUATION_TARGET = *mut _PROCESS_DYNAMIC_EH_CONTINUATION_TARGET; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION { - pub NumberOfTargets: WORD, - pub Reserved: WORD, - pub Reserved2: DWORD, - pub Targets: PPROCESS_DYNAMIC_EH_CONTINUATION_TARGET, -} #[test] -fn bindgen_test_layout__PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION() { +fn bindgen_test_layout__PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY() { assert_eq!( - ::std::mem::size_of::<_PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION>(), - 16usize, + ::std::mem::size_of::<_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY>(), + 4usize, concat!( "Size of: ", - stringify!(_PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION) + stringify!(_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY) ) ); assert_eq!( - ::std::mem::align_of::<_PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION>(), - 8usize, + ::std::mem::align_of::<_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY>(), + 4usize, concat!( "Alignment of ", - stringify!(_PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION) + stringify!(_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY) ) ); - fn test_field_NumberOfTargets() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).NumberOfTargets) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION), - "::", - stringify!(NumberOfTargets) - ) - ); - } - test_field_NumberOfTargets(); - fn test_field_Reserved() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize - }, - 2usize, - concat!( - "Offset of field: ", - stringify!(_PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION), - "::", - stringify!(Reserved) - ) - ); - } - test_field_Reserved(); - fn test_field_Reserved2() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Reserved2) as usize - ptr as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(_PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION), - "::", - stringify!(Reserved2) - ) - ); - } - test_field_Reserved2(); - fn test_field_Targets() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Targets) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(_PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION), - "::", - stringify!(Targets) - ) - ); - } - test_field_Targets(); } -pub type PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION = - _PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION; -pub type PPROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION = - *mut _PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION; +pub type PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY = + _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY; +pub type PPROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY = + *mut _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY; #[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE { - pub BaseAddress: ULONG_PTR, - pub Size: SIZE_T, +#[derive(Copy, Clone)] +pub struct _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY { + pub __bindgen_anon_1: _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1 { pub Flags: DWORD, + pub __bindgen_anon_1: + _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1, +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1 { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } #[test] -fn bindgen_test_layout__PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE() { +fn bindgen_test_layout__PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1() +{ assert_eq!( - ::std::mem::size_of::<_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE>(), - 24usize, + ::std::mem::size_of::< + _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1, + >(), + 4usize, concat!( "Size of: ", - stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE) + stringify!(_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1) ) ); assert_eq!( - ::std::mem::align_of::<_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE>(), - 8usize, + ::std::mem::align_of::< + _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1, + >(), + 4usize, concat!( "Alignment of ", - stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE) + stringify!(_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1) ) ); - fn test_field_BaseAddress() { - assert_eq!( - unsafe { - let uninit = - ::std::mem::MaybeUninit::<_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).BaseAddress) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE), - "::", - stringify!(BaseAddress) - ) - ); +} +impl _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1 { + #[inline] + pub fn DisallowWin32kSystemCalls(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } } - test_field_BaseAddress(); - fn test_field_Size() { - assert_eq!( - unsafe { - let uninit = - ::std::mem::MaybeUninit::<_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Size) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE), - "::", - stringify!(Size) - ) - ); + #[inline] + pub fn set_DisallowWin32kSystemCalls(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } } - test_field_Size(); - fn test_field_Flags() { - assert_eq!( - unsafe { - let uninit = - ::std::mem::MaybeUninit::<_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE), - "::", - stringify!(Flags) - ) - ); + #[inline] + pub fn AuditDisallowWin32kSystemCalls(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_AuditDisallowWin32kSystemCalls(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn ReservedFlags(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_ReservedFlags(&mut self, val: DWORD) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + DisallowWin32kSystemCalls: DWORD, + AuditDisallowWin32kSystemCalls: DWORD, + ReservedFlags: DWORD, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let DisallowWin32kSystemCalls: u32 = + unsafe { ::std::mem::transmute(DisallowWin32kSystemCalls) }; + DisallowWin32kSystemCalls as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let AuditDisallowWin32kSystemCalls: u32 = + unsafe { ::std::mem::transmute(AuditDisallowWin32kSystemCalls) }; + AuditDisallowWin32kSystemCalls as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let ReservedFlags: u32 = unsafe { ::std::mem::transmute(ReservedFlags) }; + ReservedFlags as u64 + }); + __bindgen_bitfield_unit } - test_field_Flags(); -} -pub type PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE = _PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE; -pub type PPROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE = *mut _PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION { - pub NumberOfRanges: WORD, - pub Reserved: WORD, - pub Reserved2: DWORD, - pub Ranges: PPROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE, } #[test] -fn bindgen_test_layout__PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION() { +fn bindgen_test_layout__PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION>(), - 16usize, + ::std::mem::size_of::<_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1>(), + 4usize, concat!( "Size of: ", - stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION) + stringify!(_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1) ) ); assert_eq!( - ::std::mem::align_of::<_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION>(), - 8usize, + ::std::mem::align_of::<_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1>(), + 4usize, concat!( "Alignment of ", - stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION) + stringify!(_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1) ) ); - fn test_field_NumberOfRanges() { + fn test_field_Flags() { assert_eq!( unsafe { let uninit = ::std::mem::MaybeUninit::< - _PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION, + _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1, >::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).NumberOfRanges) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION), - "::", - stringify!(NumberOfRanges) - ) - ); - } - test_field_NumberOfRanges(); - fn test_field_Reserved() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize - }, - 2usize, - concat!( - "Offset of field: ", - stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION), - "::", - stringify!(Reserved) - ) - ); - } - test_field_Reserved(); - fn test_field_Reserved2() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Reserved2) as usize - ptr as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION), - "::", - stringify!(Reserved2) - ) - ); - } - test_field_Reserved2(); - fn test_field_Ranges() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Ranges) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION), + stringify!(_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1), "::", - stringify!(Ranges) + stringify!(Flags) ) ); } - test_field_Ranges(); -} -pub type PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION = - _PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION; -pub type PPROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION = - *mut _PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _QUOTA_LIMITS { - pub PagedPoolLimit: SIZE_T, - pub NonPagedPoolLimit: SIZE_T, - pub MinimumWorkingSetSize: SIZE_T, - pub MaximumWorkingSetSize: SIZE_T, - pub PagefileLimit: SIZE_T, - pub TimeLimit: LARGE_INTEGER, + test_field_Flags(); } #[test] -fn bindgen_test_layout__QUOTA_LIMITS() { +fn bindgen_test_layout__PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY() { assert_eq!( - ::std::mem::size_of::<_QUOTA_LIMITS>(), - 48usize, - concat!("Size of: ", stringify!(_QUOTA_LIMITS)) + ::std::mem::size_of::<_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY>(), + 4usize, + concat!( + "Size of: ", + stringify!(_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY) + ) ); assert_eq!( - ::std::mem::align_of::<_QUOTA_LIMITS>(), - 8usize, - concat!("Alignment of ", stringify!(_QUOTA_LIMITS)) + ::std::mem::align_of::<_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY>(), + 4usize, + concat!( + "Alignment of ", + stringify!(_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY) + ) ); - fn test_field_PagedPoolLimit() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).PagedPoolLimit) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_QUOTA_LIMITS), - "::", - stringify!(PagedPoolLimit) - ) - ); - } - test_field_PagedPoolLimit(); - fn test_field_NonPagedPoolLimit() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).NonPagedPoolLimit) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(_QUOTA_LIMITS), - "::", - stringify!(NonPagedPoolLimit) - ) - ); - } - test_field_NonPagedPoolLimit(); - fn test_field_MinimumWorkingSetSize() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).MinimumWorkingSetSize) as usize - ptr as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(_QUOTA_LIMITS), - "::", - stringify!(MinimumWorkingSetSize) - ) - ); - } - test_field_MinimumWorkingSetSize(); - fn test_field_MaximumWorkingSetSize() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).MaximumWorkingSetSize) as usize - ptr as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(_QUOTA_LIMITS), - "::", - stringify!(MaximumWorkingSetSize) - ) - ); - } - test_field_MaximumWorkingSetSize(); - fn test_field_PagefileLimit() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).PagefileLimit) as usize - ptr as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(_QUOTA_LIMITS), - "::", - stringify!(PagefileLimit) - ) - ); - } - test_field_PagefileLimit(); - fn test_field_TimeLimit() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).TimeLimit) as usize - ptr as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(_QUOTA_LIMITS), - "::", - stringify!(TimeLimit) - ) - ); - } - test_field_TimeLimit(); } -pub type QUOTA_LIMITS = _QUOTA_LIMITS; -pub type PQUOTA_LIMITS = *mut _QUOTA_LIMITS; +pub type PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY = + _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY; +pub type PPROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY = + *mut _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY; #[repr(C)] #[derive(Copy, Clone)] -pub union _RATE_QUOTA_LIMIT { - pub RateData: DWORD, - pub __bindgen_anon_1: _RATE_QUOTA_LIMIT__bindgen_ty_1, +pub struct _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY { + pub __bindgen_anon_1: _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1 { + pub Flags: DWORD, + pub __bindgen_anon_1: + _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1, } #[repr(C)] #[repr(align(4))] #[derive(Debug, Copy, Clone)] -pub struct _RATE_QUOTA_LIMIT__bindgen_ty_1 { +pub struct _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1 { pub _bitfield_align_1: [u32; 0], pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } #[test] -fn bindgen_test_layout__RATE_QUOTA_LIMIT__bindgen_ty_1() { +fn bindgen_test_layout__PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1( +) { assert_eq!( - ::std::mem::size_of::<_RATE_QUOTA_LIMIT__bindgen_ty_1>(), + ::std::mem::size_of::< + _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1, + >(), 4usize, - concat!("Size of: ", stringify!(_RATE_QUOTA_LIMIT__bindgen_ty_1)) + concat!( + "Size of: ", + stringify!( + _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1 + ) + ) ); assert_eq!( - ::std::mem::align_of::<_RATE_QUOTA_LIMIT__bindgen_ty_1>(), + ::std::mem::align_of::< + _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1, + >(), 4usize, - concat!("Alignment of ", stringify!(_RATE_QUOTA_LIMIT__bindgen_ty_1)) + concat!( + "Alignment of ", + stringify!( + _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1 + ) + ) ); } -impl _RATE_QUOTA_LIMIT__bindgen_ty_1 { +impl _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1 { #[inline] - pub fn RatePercent(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 7u8) as u32) } + pub fn DisableExtensionPoints(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } } #[inline] - pub fn set_RatePercent(&mut self, val: DWORD) { + pub fn set_DisableExtensionPoints(&mut self, val: DWORD) { unsafe { let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 7u8, val as u64) + self._bitfield_1.set(0usize, 1u8, val as u64) } } #[inline] - pub fn Reserved0(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 25u8) as u32) } + pub fn ReservedFlags(&self) -> DWORD { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } } #[inline] - pub fn set_Reserved0(&mut self, val: DWORD) { + pub fn set_ReservedFlags(&mut self, val: DWORD) { unsafe { let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(7usize, 25u8, val as u64) + self._bitfield_1.set(1usize, 31u8, val as u64) } } #[inline] pub fn new_bitfield_1( - RatePercent: DWORD, - Reserved0: DWORD, + DisableExtensionPoints: DWORD, + ReservedFlags: DWORD, ) -> __BindgenBitfieldUnit<[u8; 4usize]> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 7u8, { - let RatePercent: u32 = unsafe { ::std::mem::transmute(RatePercent) }; - RatePercent as u64 + __bindgen_bitfield_unit.set(0usize, 1u8, { + let DisableExtensionPoints: u32 = + unsafe { ::std::mem::transmute(DisableExtensionPoints) }; + DisableExtensionPoints as u64 }); - __bindgen_bitfield_unit.set(7usize, 25u8, { - let Reserved0: u32 = unsafe { ::std::mem::transmute(Reserved0) }; - Reserved0 as u64 + __bindgen_bitfield_unit.set(1usize, 31u8, { + let ReservedFlags: u32 = unsafe { ::std::mem::transmute(ReservedFlags) }; + ReservedFlags as u64 }); __bindgen_bitfield_unit } } #[test] -fn bindgen_test_layout__RATE_QUOTA_LIMIT() { +fn bindgen_test_layout__PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_RATE_QUOTA_LIMIT>(), + ::std::mem::size_of::<_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1>(), 4usize, - concat!("Size of: ", stringify!(_RATE_QUOTA_LIMIT)) + concat!( + "Size of: ", + stringify!(_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1) + ) ); assert_eq!( - ::std::mem::align_of::<_RATE_QUOTA_LIMIT>(), + ::std::mem::align_of::<_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1>(), 4usize, - concat!("Alignment of ", stringify!(_RATE_QUOTA_LIMIT)) - ); - fn test_field_RateData() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_RATE_QUOTA_LIMIT>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).RateData) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_RATE_QUOTA_LIMIT), - "::", - stringify!(RateData) - ) - ); - } - test_field_RateData(); -} -pub type RATE_QUOTA_LIMIT = _RATE_QUOTA_LIMIT; -pub type PRATE_QUOTA_LIMIT = *mut _RATE_QUOTA_LIMIT; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _QUOTA_LIMITS_EX { - pub PagedPoolLimit: SIZE_T, - pub NonPagedPoolLimit: SIZE_T, - pub MinimumWorkingSetSize: SIZE_T, - pub MaximumWorkingSetSize: SIZE_T, - pub PagefileLimit: SIZE_T, - pub TimeLimit: LARGE_INTEGER, - pub WorkingSetLimit: SIZE_T, - pub Reserved2: SIZE_T, - pub Reserved3: SIZE_T, - pub Reserved4: SIZE_T, - pub Flags: DWORD, - pub CpuRateLimit: RATE_QUOTA_LIMIT, -} -#[test] -fn bindgen_test_layout__QUOTA_LIMITS_EX() { - assert_eq!( - ::std::mem::size_of::<_QUOTA_LIMITS_EX>(), - 88usize, - concat!("Size of: ", stringify!(_QUOTA_LIMITS_EX)) - ); - assert_eq!( - ::std::mem::align_of::<_QUOTA_LIMITS_EX>(), - 8usize, - concat!("Alignment of ", stringify!(_QUOTA_LIMITS_EX)) + concat!( + "Alignment of ", + stringify!(_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1) + ) ); - fn test_field_PagedPoolLimit() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).PagedPoolLimit) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_QUOTA_LIMITS_EX), - "::", - stringify!(PagedPoolLimit) - ) - ); - } - test_field_PagedPoolLimit(); - fn test_field_NonPagedPoolLimit() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).NonPagedPoolLimit) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(_QUOTA_LIMITS_EX), - "::", - stringify!(NonPagedPoolLimit) - ) - ); - } - test_field_NonPagedPoolLimit(); - fn test_field_MinimumWorkingSetSize() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).MinimumWorkingSetSize) as usize - ptr as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(_QUOTA_LIMITS_EX), - "::", - stringify!(MinimumWorkingSetSize) - ) - ); - } - test_field_MinimumWorkingSetSize(); - fn test_field_MaximumWorkingSetSize() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).MaximumWorkingSetSize) as usize - ptr as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(_QUOTA_LIMITS_EX), - "::", - stringify!(MaximumWorkingSetSize) - ) - ); - } - test_field_MaximumWorkingSetSize(); - fn test_field_PagefileLimit() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).PagefileLimit) as usize - ptr as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(_QUOTA_LIMITS_EX), - "::", - stringify!(PagefileLimit) - ) - ); - } - test_field_PagefileLimit(); - fn test_field_TimeLimit() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).TimeLimit) as usize - ptr as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(_QUOTA_LIMITS_EX), - "::", - stringify!(TimeLimit) - ) - ); - } - test_field_TimeLimit(); - fn test_field_WorkingSetLimit() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).WorkingSetLimit) as usize - ptr as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(_QUOTA_LIMITS_EX), - "::", - stringify!(WorkingSetLimit) - ) - ); - } - test_field_WorkingSetLimit(); - fn test_field_Reserved2() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Reserved2) as usize - ptr as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(_QUOTA_LIMITS_EX), - "::", - stringify!(Reserved2) - ) - ); - } - test_field_Reserved2(); - fn test_field_Reserved3() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Reserved3) as usize - ptr as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(_QUOTA_LIMITS_EX), - "::", - stringify!(Reserved3) - ) - ); - } - test_field_Reserved3(); - fn test_field_Reserved4() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Reserved4) as usize - ptr as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(_QUOTA_LIMITS_EX), - "::", - stringify!(Reserved4) - ) - ); - } - test_field_Reserved4(); fn test_field_Flags() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); + let uninit = ::std::mem::MaybeUninit::< + _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1, + >::uninit(); let ptr = uninit.as_ptr(); ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, - 80usize, + 0usize, concat!( "Offset of field: ", - stringify!(_QUOTA_LIMITS_EX), + stringify!(_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1), "::", stringify!(Flags) ) ); } test_field_Flags(); - fn test_field_CpuRateLimit() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_QUOTA_LIMITS_EX>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).CpuRateLimit) as usize - ptr as usize - }, - 84usize, - concat!( - "Offset of field: ", - stringify!(_QUOTA_LIMITS_EX), - "::", - stringify!(CpuRateLimit) - ) - ); - } - test_field_CpuRateLimit(); -} -pub type QUOTA_LIMITS_EX = _QUOTA_LIMITS_EX; -pub type PQUOTA_LIMITS_EX = *mut _QUOTA_LIMITS_EX; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _IO_COUNTERS { - pub ReadOperationCount: ULONGLONG, - pub WriteOperationCount: ULONGLONG, - pub OtherOperationCount: ULONGLONG, - pub ReadTransferCount: ULONGLONG, - pub WriteTransferCount: ULONGLONG, - pub OtherTransferCount: ULONGLONG, } #[test] -fn bindgen_test_layout__IO_COUNTERS() { +fn bindgen_test_layout__PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY() { assert_eq!( - ::std::mem::size_of::<_IO_COUNTERS>(), - 48usize, - concat!("Size of: ", stringify!(_IO_COUNTERS)) + ::std::mem::size_of::<_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY>(), + 4usize, + concat!( + "Size of: ", + stringify!(_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY) + ) ); assert_eq!( - ::std::mem::align_of::<_IO_COUNTERS>(), - 8usize, - concat!("Alignment of ", stringify!(_IO_COUNTERS)) + ::std::mem::align_of::<_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY>(), + 4usize, + concat!( + "Alignment of ", + stringify!(_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY) + ) ); - fn test_field_ReadOperationCount() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_IO_COUNTERS>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ReadOperationCount) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_IO_COUNTERS), - "::", - stringify!(ReadOperationCount) - ) - ); - } - test_field_ReadOperationCount(); - fn test_field_WriteOperationCount() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_IO_COUNTERS>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).WriteOperationCount) as usize - ptr as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(_IO_COUNTERS), - "::", - stringify!(WriteOperationCount) - ) - ); - } - test_field_WriteOperationCount(); - fn test_field_OtherOperationCount() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_IO_COUNTERS>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).OtherOperationCount) as usize - ptr as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(_IO_COUNTERS), - "::", - stringify!(OtherOperationCount) - ) - ); - } - test_field_OtherOperationCount(); - fn test_field_ReadTransferCount() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_IO_COUNTERS>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ReadTransferCount) as usize - ptr as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(_IO_COUNTERS), - "::", - stringify!(ReadTransferCount) - ) - ); - } - test_field_ReadTransferCount(); - fn test_field_WriteTransferCount() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_IO_COUNTERS>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).WriteTransferCount) as usize - ptr as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(_IO_COUNTERS), - "::", - stringify!(WriteTransferCount) - ) - ); - } - test_field_WriteTransferCount(); - fn test_field_OtherTransferCount() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_IO_COUNTERS>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).OtherTransferCount) as usize - ptr as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(_IO_COUNTERS), - "::", - stringify!(OtherTransferCount) - ) - ); - } - test_field_OtherTransferCount(); -} -pub type IO_COUNTERS = _IO_COUNTERS; -pub type PIO_COUNTERS = *mut IO_COUNTERS; -#[repr(i32)] -#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] -pub enum _HARDWARE_COUNTER_TYPE { - PMCCounter = 0, - MaxHardwareCounterType = 1, -} -pub use self::_HARDWARE_COUNTER_TYPE as HARDWARE_COUNTER_TYPE; -pub type PHARDWARE_COUNTER_TYPE = *mut _HARDWARE_COUNTER_TYPE; -#[repr(i32)] -#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] -pub enum _PROCESS_MITIGATION_POLICY { - ProcessDEPPolicy = 0, - ProcessASLRPolicy = 1, - ProcessDynamicCodePolicy = 2, - ProcessStrictHandleCheckPolicy = 3, - ProcessSystemCallDisablePolicy = 4, - ProcessMitigationOptionsMask = 5, - ProcessExtensionPointDisablePolicy = 6, - ProcessControlFlowGuardPolicy = 7, - ProcessSignaturePolicy = 8, - ProcessFontDisablePolicy = 9, - ProcessImageLoadPolicy = 10, - ProcessSystemCallFilterPolicy = 11, - ProcessPayloadRestrictionPolicy = 12, - ProcessChildProcessPolicy = 13, - ProcessSideChannelIsolationPolicy = 14, - ProcessUserShadowStackPolicy = 15, - ProcessRedirectionTrustPolicy = 16, - ProcessUserPointerAuthPolicy = 17, - ProcessSEHOPPolicy = 18, - MaxProcessMitigationPolicy = 19, } -pub use self::_PROCESS_MITIGATION_POLICY as PROCESS_MITIGATION_POLICY; -pub type PPROCESS_MITIGATION_POLICY = *mut _PROCESS_MITIGATION_POLICY; +pub type PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY = + _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY; +pub type PPROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY = + *mut _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY; #[repr(C)] #[derive(Copy, Clone)] -pub struct _PROCESS_MITIGATION_ASLR_POLICY { - pub __bindgen_anon_1: _PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1, +pub struct _PROCESS_MITIGATION_DYNAMIC_CODE_POLICY { + pub __bindgen_anon_1: _PROCESS_MITIGATION_DYNAMIC_CODE_POLICY__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] -pub union _PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1 { +pub union _PROCESS_MITIGATION_DYNAMIC_CODE_POLICY__bindgen_ty_1 { pub Flags: DWORD, - pub __bindgen_anon_1: _PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1__bindgen_ty_1, + pub __bindgen_anon_1: _PROCESS_MITIGATION_DYNAMIC_CODE_POLICY__bindgen_ty_1__bindgen_ty_1, } #[repr(C)] #[repr(align(4))] #[derive(Debug, Copy, Clone)] -pub struct _PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1__bindgen_ty_1 { +pub struct _PROCESS_MITIGATION_DYNAMIC_CODE_POLICY__bindgen_ty_1__bindgen_ty_1 { pub _bitfield_align_1: [u32; 0], pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } #[test] -fn bindgen_test_layout__PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1__bindgen_ty_1() { +fn bindgen_test_layout__PROCESS_MITIGATION_DYNAMIC_CODE_POLICY__bindgen_ty_1__bindgen_ty_1() { assert_eq!( - ::std::mem::size_of::<_PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1__bindgen_ty_1>(), + ::std::mem::size_of::<_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY__bindgen_ty_1__bindgen_ty_1>( + ), 4usize, concat!( "Size of: ", - stringify!(_PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1__bindgen_ty_1) + stringify!(_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY__bindgen_ty_1__bindgen_ty_1) ) ); assert_eq!( - ::std::mem::align_of::<_PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1__bindgen_ty_1>(), + ::std::mem::align_of::<_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY__bindgen_ty_1__bindgen_ty_1>( + ), 4usize, concat!( "Alignment of ", - stringify!(_PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1__bindgen_ty_1) + stringify!(_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY__bindgen_ty_1__bindgen_ty_1) ) ); } -impl _PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1__bindgen_ty_1 { +impl _PROCESS_MITIGATION_DYNAMIC_CODE_POLICY__bindgen_ty_1__bindgen_ty_1 { #[inline] - pub fn EnableBottomUpRandomization(&self) -> DWORD { + pub fn ProhibitDynamicCode(&self) -> DWORD { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } } #[inline] - pub fn set_EnableBottomUpRandomization(&mut self, val: DWORD) { + pub fn set_ProhibitDynamicCode(&mut self, val: DWORD) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 1u8, val as u64) } } #[inline] - pub fn EnableForceRelocateImages(&self) -> DWORD { + pub fn AllowThreadOptOut(&self) -> DWORD { unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } } #[inline] - pub fn set_EnableForceRelocateImages(&mut self, val: DWORD) { + pub fn set_AllowThreadOptOut(&mut self, val: DWORD) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(1usize, 1u8, val as u64) } } #[inline] - pub fn EnableHighEntropy(&self) -> DWORD { + pub fn AllowRemoteDowngrade(&self) -> DWORD { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } } #[inline] - pub fn set_EnableHighEntropy(&mut self, val: DWORD) { + pub fn set_AllowRemoteDowngrade(&mut self, val: DWORD) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(2usize, 1u8, val as u64) } } #[inline] - pub fn DisallowStrippedImages(&self) -> DWORD { + pub fn AuditProhibitDynamicCode(&self) -> DWORD { unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } } #[inline] - pub fn set_DisallowStrippedImages(&mut self, val: DWORD) { + pub fn set_AuditProhibitDynamicCode(&mut self, val: DWORD) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(3usize, 1u8, val as u64) @@ -43890,976 +43618,24 @@ impl _PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1__bindgen_ty_1 { } #[inline] pub fn new_bitfield_1( - EnableBottomUpRandomization: DWORD, - EnableForceRelocateImages: DWORD, - EnableHighEntropy: DWORD, - DisallowStrippedImages: DWORD, + ProhibitDynamicCode: DWORD, + AllowThreadOptOut: DWORD, + AllowRemoteDowngrade: DWORD, + AuditProhibitDynamicCode: DWORD, ReservedFlags: DWORD, ) -> __BindgenBitfieldUnit<[u8; 4usize]> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { - let EnableBottomUpRandomization: u32 = - unsafe { ::std::mem::transmute(EnableBottomUpRandomization) }; - EnableBottomUpRandomization as u64 + let ProhibitDynamicCode: u32 = unsafe { ::std::mem::transmute(ProhibitDynamicCode) }; + ProhibitDynamicCode as u64 }); __bindgen_bitfield_unit.set(1usize, 1u8, { - let EnableForceRelocateImages: u32 = - unsafe { ::std::mem::transmute(EnableForceRelocateImages) }; - EnableForceRelocateImages as u64 + let AllowThreadOptOut: u32 = unsafe { ::std::mem::transmute(AllowThreadOptOut) }; + AllowThreadOptOut as u64 }); __bindgen_bitfield_unit.set(2usize, 1u8, { - let EnableHighEntropy: u32 = unsafe { ::std::mem::transmute(EnableHighEntropy) }; - EnableHighEntropy as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let DisallowStrippedImages: u32 = - unsafe { ::std::mem::transmute(DisallowStrippedImages) }; - DisallowStrippedImages as u64 - }); - __bindgen_bitfield_unit.set(4usize, 28u8, { - let ReservedFlags: u32 = unsafe { ::std::mem::transmute(ReservedFlags) }; - ReservedFlags as u64 - }); - __bindgen_bitfield_unit - } -} -#[test] -fn bindgen_test_layout__PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1>(), - 4usize, - concat!( - "Size of: ", - stringify!(_PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1) - ) - ); - assert_eq!( - ::std::mem::align_of::<_PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1>(), - 4usize, - concat!( - "Alignment of ", - stringify!(_PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1) - ) - ); - fn test_field_Flags() { - assert_eq!( - unsafe { - let uninit = :: std :: mem :: MaybeUninit :: < _PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1 > :: uninit () ; - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_PROCESS_MITIGATION_ASLR_POLICY__bindgen_ty_1), - "::", - stringify!(Flags) - ) - ); - } - test_field_Flags(); -} -#[test] -fn bindgen_test_layout__PROCESS_MITIGATION_ASLR_POLICY() { - assert_eq!( - ::std::mem::size_of::<_PROCESS_MITIGATION_ASLR_POLICY>(), - 4usize, - concat!("Size of: ", stringify!(_PROCESS_MITIGATION_ASLR_POLICY)) - ); - assert_eq!( - ::std::mem::align_of::<_PROCESS_MITIGATION_ASLR_POLICY>(), - 4usize, - concat!("Alignment of ", stringify!(_PROCESS_MITIGATION_ASLR_POLICY)) - ); -} -pub type PROCESS_MITIGATION_ASLR_POLICY = _PROCESS_MITIGATION_ASLR_POLICY; -pub type PPROCESS_MITIGATION_ASLR_POLICY = *mut _PROCESS_MITIGATION_ASLR_POLICY; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _PROCESS_MITIGATION_DEP_POLICY { - pub __bindgen_anon_1: _PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1, - pub Permanent: BOOLEAN, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1 { - pub Flags: DWORD, - pub __bindgen_anon_1: _PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1__bindgen_ty_1, -} -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct _PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1__bindgen_ty_1 { - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -#[test] -fn bindgen_test_layout__PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - concat!( - "Size of: ", - stringify!(_PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1__bindgen_ty_1) - ) - ); - assert_eq!( - ::std::mem::align_of::<_PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - concat!( - "Alignment of ", - stringify!(_PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1__bindgen_ty_1) - ) - ); -} -impl _PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1__bindgen_ty_1 { - #[inline] - pub fn Enable(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_Enable(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub fn DisableAtlThunkEmulation(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_DisableAtlThunkEmulation(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub fn ReservedFlags(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_ReservedFlags(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub fn new_bitfield_1( - Enable: DWORD, - DisableAtlThunkEmulation: DWORD, - ReservedFlags: DWORD, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let Enable: u32 = unsafe { ::std::mem::transmute(Enable) }; - Enable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let DisableAtlThunkEmulation: u32 = - unsafe { ::std::mem::transmute(DisableAtlThunkEmulation) }; - DisableAtlThunkEmulation as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let ReservedFlags: u32 = unsafe { ::std::mem::transmute(ReservedFlags) }; - ReservedFlags as u64 - }); - __bindgen_bitfield_unit - } -} -#[test] -fn bindgen_test_layout__PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1>(), - 4usize, - concat!( - "Size of: ", - stringify!(_PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1) - ) - ); - assert_eq!( - ::std::mem::align_of::<_PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1>(), - 4usize, - concat!( - "Alignment of ", - stringify!(_PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1) - ) - ); - fn test_field_Flags() { - assert_eq!( - unsafe { - let uninit = - ::std::mem::MaybeUninit::<_PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1>::uninit( - ); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_PROCESS_MITIGATION_DEP_POLICY__bindgen_ty_1), - "::", - stringify!(Flags) - ) - ); - } - test_field_Flags(); -} -#[test] -fn bindgen_test_layout__PROCESS_MITIGATION_DEP_POLICY() { - assert_eq!( - ::std::mem::size_of::<_PROCESS_MITIGATION_DEP_POLICY>(), - 8usize, - concat!("Size of: ", stringify!(_PROCESS_MITIGATION_DEP_POLICY)) - ); - assert_eq!( - ::std::mem::align_of::<_PROCESS_MITIGATION_DEP_POLICY>(), - 4usize, - concat!("Alignment of ", stringify!(_PROCESS_MITIGATION_DEP_POLICY)) - ); - fn test_field_Permanent() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::<_PROCESS_MITIGATION_DEP_POLICY>::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Permanent) as usize - ptr as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(_PROCESS_MITIGATION_DEP_POLICY), - "::", - stringify!(Permanent) - ) - ); - } - test_field_Permanent(); -} -pub type PROCESS_MITIGATION_DEP_POLICY = _PROCESS_MITIGATION_DEP_POLICY; -pub type PPROCESS_MITIGATION_DEP_POLICY = *mut _PROCESS_MITIGATION_DEP_POLICY; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _PROCESS_MITIGATION_SEHOP_POLICY { - pub __bindgen_anon_1: _PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1 { - pub Flags: DWORD, - pub __bindgen_anon_1: _PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1__bindgen_ty_1, -} -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct _PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1__bindgen_ty_1 { - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -#[test] -fn bindgen_test_layout__PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - concat!( - "Size of: ", - stringify!(_PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1__bindgen_ty_1) - ) - ); - assert_eq!( - ::std::mem::align_of::<_PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - concat!( - "Alignment of ", - stringify!(_PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1__bindgen_ty_1) - ) - ); -} -impl _PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1__bindgen_ty_1 { - #[inline] - pub fn EnableSehop(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_EnableSehop(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub fn ReservedFlags(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_ReservedFlags(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub fn new_bitfield_1( - EnableSehop: DWORD, - ReservedFlags: DWORD, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let EnableSehop: u32 = unsafe { ::std::mem::transmute(EnableSehop) }; - EnableSehop as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let ReservedFlags: u32 = unsafe { ::std::mem::transmute(ReservedFlags) }; - ReservedFlags as u64 - }); - __bindgen_bitfield_unit - } -} -#[test] -fn bindgen_test_layout__PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1>(), - 4usize, - concat!( - "Size of: ", - stringify!(_PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1) - ) - ); - assert_eq!( - ::std::mem::align_of::<_PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1>(), - 4usize, - concat!( - "Alignment of ", - stringify!(_PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1) - ) - ); - fn test_field_Flags() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_PROCESS_MITIGATION_SEHOP_POLICY__bindgen_ty_1), - "::", - stringify!(Flags) - ) - ); - } - test_field_Flags(); -} -#[test] -fn bindgen_test_layout__PROCESS_MITIGATION_SEHOP_POLICY() { - assert_eq!( - ::std::mem::size_of::<_PROCESS_MITIGATION_SEHOP_POLICY>(), - 4usize, - concat!("Size of: ", stringify!(_PROCESS_MITIGATION_SEHOP_POLICY)) - ); - assert_eq!( - ::std::mem::align_of::<_PROCESS_MITIGATION_SEHOP_POLICY>(), - 4usize, - concat!( - "Alignment of ", - stringify!(_PROCESS_MITIGATION_SEHOP_POLICY) - ) - ); -} -pub type PROCESS_MITIGATION_SEHOP_POLICY = _PROCESS_MITIGATION_SEHOP_POLICY; -pub type PPROCESS_MITIGATION_SEHOP_POLICY = *mut _PROCESS_MITIGATION_SEHOP_POLICY; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY { - pub __bindgen_anon_1: _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1 { - pub Flags: DWORD, - pub __bindgen_anon_1: - _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1__bindgen_ty_1, -} -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1__bindgen_ty_1 { - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -#[test] -fn bindgen_test_layout__PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1__bindgen_ty_1() -{ - assert_eq!( - ::std::mem::size_of::< - _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1__bindgen_ty_1, - >(), - 4usize, - concat!( - "Size of: ", - stringify!(_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1__bindgen_ty_1) - ) - ); - assert_eq!( - ::std::mem::align_of::< - _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1__bindgen_ty_1, - >(), - 4usize, - concat!( - "Alignment of ", - stringify!(_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1__bindgen_ty_1) - ) - ); -} -impl _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1__bindgen_ty_1 { - #[inline] - pub fn RaiseExceptionOnInvalidHandleReference(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_RaiseExceptionOnInvalidHandleReference(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub fn HandleExceptionsPermanentlyEnabled(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_HandleExceptionsPermanentlyEnabled(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub fn ReservedFlags(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_ReservedFlags(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub fn new_bitfield_1( - RaiseExceptionOnInvalidHandleReference: DWORD, - HandleExceptionsPermanentlyEnabled: DWORD, - ReservedFlags: DWORD, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let RaiseExceptionOnInvalidHandleReference: u32 = - unsafe { ::std::mem::transmute(RaiseExceptionOnInvalidHandleReference) }; - RaiseExceptionOnInvalidHandleReference as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let HandleExceptionsPermanentlyEnabled: u32 = - unsafe { ::std::mem::transmute(HandleExceptionsPermanentlyEnabled) }; - HandleExceptionsPermanentlyEnabled as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let ReservedFlags: u32 = unsafe { ::std::mem::transmute(ReservedFlags) }; - ReservedFlags as u64 - }); - __bindgen_bitfield_unit - } -} -#[test] -fn bindgen_test_layout__PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1>(), - 4usize, - concat!( - "Size of: ", - stringify!(_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1) - ) - ); - assert_eq!( - ::std::mem::align_of::<_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1>(), - 4usize, - concat!( - "Alignment of ", - stringify!(_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1) - ) - ); - fn test_field_Flags() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY__bindgen_ty_1), - "::", - stringify!(Flags) - ) - ); - } - test_field_Flags(); -} -#[test] -fn bindgen_test_layout__PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY() { - assert_eq!( - ::std::mem::size_of::<_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY>(), - 4usize, - concat!( - "Size of: ", - stringify!(_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY) - ) - ); - assert_eq!( - ::std::mem::align_of::<_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY>(), - 4usize, - concat!( - "Alignment of ", - stringify!(_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY) - ) - ); -} -pub type PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY = - _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY; -pub type PPROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY = - *mut _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY { - pub __bindgen_anon_1: _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1 { - pub Flags: DWORD, - pub __bindgen_anon_1: - _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1, -} -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1 { - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -#[test] -fn bindgen_test_layout__PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1() -{ - assert_eq!( - ::std::mem::size_of::< - _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1, - >(), - 4usize, - concat!( - "Size of: ", - stringify!(_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1) - ) - ); - assert_eq!( - ::std::mem::align_of::< - _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1, - >(), - 4usize, - concat!( - "Alignment of ", - stringify!(_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1) - ) - ); -} -impl _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1 { - #[inline] - pub fn DisallowWin32kSystemCalls(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_DisallowWin32kSystemCalls(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub fn AuditDisallowWin32kSystemCalls(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_AuditDisallowWin32kSystemCalls(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub fn ReservedFlags(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_ReservedFlags(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub fn new_bitfield_1( - DisallowWin32kSystemCalls: DWORD, - AuditDisallowWin32kSystemCalls: DWORD, - ReservedFlags: DWORD, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let DisallowWin32kSystemCalls: u32 = - unsafe { ::std::mem::transmute(DisallowWin32kSystemCalls) }; - DisallowWin32kSystemCalls as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let AuditDisallowWin32kSystemCalls: u32 = - unsafe { ::std::mem::transmute(AuditDisallowWin32kSystemCalls) }; - AuditDisallowWin32kSystemCalls as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let ReservedFlags: u32 = unsafe { ::std::mem::transmute(ReservedFlags) }; - ReservedFlags as u64 - }); - __bindgen_bitfield_unit - } -} -#[test] -fn bindgen_test_layout__PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1>(), - 4usize, - concat!( - "Size of: ", - stringify!(_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1) - ) - ); - assert_eq!( - ::std::mem::align_of::<_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1>(), - 4usize, - concat!( - "Alignment of ", - stringify!(_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1) - ) - ); - fn test_field_Flags() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1), - "::", - stringify!(Flags) - ) - ); - } - test_field_Flags(); -} -#[test] -fn bindgen_test_layout__PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY() { - assert_eq!( - ::std::mem::size_of::<_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY>(), - 4usize, - concat!( - "Size of: ", - stringify!(_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY) - ) - ); - assert_eq!( - ::std::mem::align_of::<_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY>(), - 4usize, - concat!( - "Alignment of ", - stringify!(_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY) - ) - ); -} -pub type PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY = - _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY; -pub type PPROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY = - *mut _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY { - pub __bindgen_anon_1: _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1 { - pub Flags: DWORD, - pub __bindgen_anon_1: - _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1, -} -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1 { - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -#[test] -fn bindgen_test_layout__PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1( -) { - assert_eq!( - ::std::mem::size_of::< - _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1, - >(), - 4usize, - concat!( - "Size of: ", - stringify!( - _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1 - ) - ) - ); - assert_eq!( - ::std::mem::align_of::< - _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1, - >(), - 4usize, - concat!( - "Alignment of ", - stringify!( - _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1 - ) - ) - ); -} -impl _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1 { - #[inline] - pub fn DisableExtensionPoints(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_DisableExtensionPoints(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub fn ReservedFlags(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_ReservedFlags(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub fn new_bitfield_1( - DisableExtensionPoints: DWORD, - ReservedFlags: DWORD, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let DisableExtensionPoints: u32 = - unsafe { ::std::mem::transmute(DisableExtensionPoints) }; - DisableExtensionPoints as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let ReservedFlags: u32 = unsafe { ::std::mem::transmute(ReservedFlags) }; - ReservedFlags as u64 - }); - __bindgen_bitfield_unit - } -} -#[test] -fn bindgen_test_layout__PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1>(), - 4usize, - concat!( - "Size of: ", - stringify!(_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1) - ) - ); - assert_eq!( - ::std::mem::align_of::<_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1>(), - 4usize, - concat!( - "Alignment of ", - stringify!(_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1) - ) - ); - fn test_field_Flags() { - assert_eq!( - unsafe { - let uninit = ::std::mem::MaybeUninit::< - _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1, - >::uninit(); - let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY__bindgen_ty_1), - "::", - stringify!(Flags) - ) - ); - } - test_field_Flags(); -} -#[test] -fn bindgen_test_layout__PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY() { - assert_eq!( - ::std::mem::size_of::<_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY>(), - 4usize, - concat!( - "Size of: ", - stringify!(_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY) - ) - ); - assert_eq!( - ::std::mem::align_of::<_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY>(), - 4usize, - concat!( - "Alignment of ", - stringify!(_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY) - ) - ); -} -pub type PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY = - _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY; -pub type PPROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY = - *mut _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _PROCESS_MITIGATION_DYNAMIC_CODE_POLICY { - pub __bindgen_anon_1: _PROCESS_MITIGATION_DYNAMIC_CODE_POLICY__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _PROCESS_MITIGATION_DYNAMIC_CODE_POLICY__bindgen_ty_1 { - pub Flags: DWORD, - pub __bindgen_anon_1: _PROCESS_MITIGATION_DYNAMIC_CODE_POLICY__bindgen_ty_1__bindgen_ty_1, -} -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct _PROCESS_MITIGATION_DYNAMIC_CODE_POLICY__bindgen_ty_1__bindgen_ty_1 { - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -#[test] -fn bindgen_test_layout__PROCESS_MITIGATION_DYNAMIC_CODE_POLICY__bindgen_ty_1__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::<_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY__bindgen_ty_1__bindgen_ty_1>( - ), - 4usize, - concat!( - "Size of: ", - stringify!(_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY__bindgen_ty_1__bindgen_ty_1) - ) - ); - assert_eq!( - ::std::mem::align_of::<_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY__bindgen_ty_1__bindgen_ty_1>( - ), - 4usize, - concat!( - "Alignment of ", - stringify!(_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY__bindgen_ty_1__bindgen_ty_1) - ) - ); -} -impl _PROCESS_MITIGATION_DYNAMIC_CODE_POLICY__bindgen_ty_1__bindgen_ty_1 { - #[inline] - pub fn ProhibitDynamicCode(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_ProhibitDynamicCode(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub fn AllowThreadOptOut(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_AllowThreadOptOut(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub fn AllowRemoteDowngrade(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_AllowRemoteDowngrade(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub fn AuditProhibitDynamicCode(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_AuditProhibitDynamicCode(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub fn ReservedFlags(&self) -> DWORD { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 28u8) as u32) } - } - #[inline] - pub fn set_ReservedFlags(&mut self, val: DWORD) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 28u8, val as u64) - } - } - #[inline] - pub fn new_bitfield_1( - ProhibitDynamicCode: DWORD, - AllowThreadOptOut: DWORD, - AllowRemoteDowngrade: DWORD, - AuditProhibitDynamicCode: DWORD, - ReservedFlags: DWORD, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let ProhibitDynamicCode: u32 = unsafe { ::std::mem::transmute(ProhibitDynamicCode) }; - ProhibitDynamicCode as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let AllowThreadOptOut: u32 = unsafe { ::std::mem::transmute(AllowThreadOptOut) }; - AllowThreadOptOut as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let AllowRemoteDowngrade: u32 = unsafe { ::std::mem::transmute(AllowRemoteDowngrade) }; - AllowRemoteDowngrade as u64 + let AllowRemoteDowngrade: u32 = unsafe { ::std::mem::transmute(AllowRemoteDowngrade) }; + AllowRemoteDowngrade as u64 }); __bindgen_bitfield_unit.set(3usize, 1u8, { let AuditProhibitDynamicCode: u32 = @@ -371362,562 +370138,1867 @@ impl MeCab_Model { pub unsafe fn create1(arg: *const ::std::os::raw::c_char) -> *mut MeCab_Model { MeCab_Model_create1(arg) } -} -#[repr(C)] -pub struct MeCab_Tagger__bindgen_vtable(::std::os::raw::c_void); -#[doc = " Tagger class"] -#[repr(C)] -#[derive(Debug)] -pub struct MeCab_Tagger { - pub vtable_: *const MeCab_Tagger__bindgen_vtable, -} -#[test] -fn bindgen_test_layout_MeCab_Tagger() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(MeCab_Tagger)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(MeCab_Tagger)) - ); -} -extern "C" { - #[doc = " Handy static method."] - #[doc = " Return true if lattice is parsed successfully."] - #[doc = " This function is equivalent to"] - #[doc = " {"] - #[doc = " Tagger *tagger = model.createModel();"] - #[doc = " cosnt bool result = tagger->parse(lattice);"] - #[doc = " delete tagger;"] - #[doc = " return result;"] - #[doc = " }"] - #[doc = " @return boolean"] - #[link_name = "\u{1}?parse@Tagger@MeCab@@SA_NAEBVModel@2@PEAVLattice@2@@Z"] - pub fn MeCab_Tagger_parse(model: *const MeCab_Model, lattice: *mut MeCab_Lattice) -> bool; -} -extern "C" { - #[doc = " Factory method to create a new Tagger with a specified main's argc/argv-style parameters."] - #[doc = " Return NULL if new model cannot be initialized. Use MeCab::getLastError() to obtain the"] - #[doc = " cause of the errors."] - #[doc = " @return new Tagger object"] - #[doc = " @param argc number of parameters"] - #[doc = " @param argv parameter list"] - #[link_name = "\u{1}?create@Tagger@MeCab@@SAPEAV12@HPEAPEAD@Z"] - pub fn MeCab_Tagger_create( - argc: ::std::os::raw::c_int, - argv: *mut *mut ::std::os::raw::c_char, - ) -> *mut MeCab_Tagger; -} -extern "C" { - #[doc = " Factory method to create a new Tagger with a string parameter representation, i.e.,"] - #[doc = " \"-d /user/local/mecab/dic/ipadic -Ochasen\"."] - #[doc = " Return NULL if new model cannot be initialized. Use MeCab::getLastError() to obtain the"] - #[doc = " cause of the errors."] - #[doc = " @return new Model object"] - #[doc = " @param arg single string representation of the argment."] - #[link_name = "\u{1}?create@Tagger@MeCab@@SAPEAV12@PEBD@Z"] - pub fn MeCab_Tagger_create1(arg: *const ::std::os::raw::c_char) -> *mut MeCab_Tagger; -} -extern "C" { - #[doc = " Return a version string"] - #[doc = " @return version string"] - #[link_name = "\u{1}?version@Tagger@MeCab@@SAPEBDXZ"] - pub fn MeCab_Tagger_version() -> *const ::std::os::raw::c_char; -} -impl MeCab_Tagger { - #[inline] - pub unsafe fn parse(model: *const MeCab_Model, lattice: *mut MeCab_Lattice) -> bool { - MeCab_Tagger_parse(model, lattice) +} +#[repr(C)] +pub struct MeCab_Tagger__bindgen_vtable(::std::os::raw::c_void); +#[doc = " Tagger class"] +#[repr(C)] +#[derive(Debug)] +pub struct MeCab_Tagger { + pub vtable_: *const MeCab_Tagger__bindgen_vtable, +} +#[test] +fn bindgen_test_layout_MeCab_Tagger() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(MeCab_Tagger)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(MeCab_Tagger)) + ); +} +extern "C" { + #[doc = " Handy static method."] + #[doc = " Return true if lattice is parsed successfully."] + #[doc = " This function is equivalent to"] + #[doc = " {"] + #[doc = " Tagger *tagger = model.createModel();"] + #[doc = " cosnt bool result = tagger->parse(lattice);"] + #[doc = " delete tagger;"] + #[doc = " return result;"] + #[doc = " }"] + #[doc = " @return boolean"] + #[link_name = "\u{1}?parse@Tagger@MeCab@@SA_NAEBVModel@2@PEAVLattice@2@@Z"] + pub fn MeCab_Tagger_parse(model: *const MeCab_Model, lattice: *mut MeCab_Lattice) -> bool; +} +extern "C" { + #[doc = " Factory method to create a new Tagger with a specified main's argc/argv-style parameters."] + #[doc = " Return NULL if new model cannot be initialized. Use MeCab::getLastError() to obtain the"] + #[doc = " cause of the errors."] + #[doc = " @return new Tagger object"] + #[doc = " @param argc number of parameters"] + #[doc = " @param argv parameter list"] + #[link_name = "\u{1}?create@Tagger@MeCab@@SAPEAV12@HPEAPEAD@Z"] + pub fn MeCab_Tagger_create( + argc: ::std::os::raw::c_int, + argv: *mut *mut ::std::os::raw::c_char, + ) -> *mut MeCab_Tagger; +} +extern "C" { + #[doc = " Factory method to create a new Tagger with a string parameter representation, i.e.,"] + #[doc = " \"-d /user/local/mecab/dic/ipadic -Ochasen\"."] + #[doc = " Return NULL if new model cannot be initialized. Use MeCab::getLastError() to obtain the"] + #[doc = " cause of the errors."] + #[doc = " @return new Model object"] + #[doc = " @param arg single string representation of the argment."] + #[link_name = "\u{1}?create@Tagger@MeCab@@SAPEAV12@PEBD@Z"] + pub fn MeCab_Tagger_create1(arg: *const ::std::os::raw::c_char) -> *mut MeCab_Tagger; +} +extern "C" { + #[doc = " Return a version string"] + #[doc = " @return version string"] + #[link_name = "\u{1}?version@Tagger@MeCab@@SAPEBDXZ"] + pub fn MeCab_Tagger_version() -> *const ::std::os::raw::c_char; +} +impl MeCab_Tagger { + #[inline] + pub unsafe fn parse(model: *const MeCab_Model, lattice: *mut MeCab_Lattice) -> bool { + MeCab_Tagger_parse(model, lattice) + } + #[inline] + pub unsafe fn create( + argc: ::std::os::raw::c_int, + argv: *mut *mut ::std::os::raw::c_char, + ) -> *mut MeCab_Tagger { + MeCab_Tagger_create(argc, argv) + } + #[inline] + pub unsafe fn create1(arg: *const ::std::os::raw::c_char) -> *mut MeCab_Tagger { + MeCab_Tagger_create1(arg) + } + #[inline] + pub unsafe fn version() -> *const ::std::os::raw::c_char { + MeCab_Tagger_version() + } +} +extern "C" { + #[doc = " Alias of Lattice::create()"] + #[link_name = "\u{1}?createLattice@MeCab@@YAPEAVLattice@1@XZ"] + pub fn MeCab_createLattice() -> *mut MeCab_Lattice; +} +extern "C" { + #[doc = " Alias of Mode::create(argc, argv)"] + #[link_name = "\u{1}?createModel@MeCab@@YAPEAVModel@1@HPEAPEAD@Z"] + pub fn MeCab_createModel( + argc: ::std::os::raw::c_int, + argv: *mut *mut ::std::os::raw::c_char, + ) -> *mut MeCab_Model; +} +extern "C" { + #[doc = " Alias of Mode::create(arg)"] + #[link_name = "\u{1}?createModel@MeCab@@YAPEAVModel@1@PEBD@Z"] + pub fn MeCab_createModel1(arg: *const ::std::os::raw::c_char) -> *mut MeCab_Model; +} +extern "C" { + #[doc = " Alias of Tagger::create(argc, argv)"] + #[link_name = "\u{1}?createTagger@MeCab@@YAPEAVTagger@1@HPEAPEAD@Z"] + pub fn MeCab_createTagger( + argc: ::std::os::raw::c_int, + argv: *mut *mut ::std::os::raw::c_char, + ) -> *mut MeCab_Tagger; +} +extern "C" { + #[doc = " Alias of Tagger::create(arg)"] + #[link_name = "\u{1}?createTagger@MeCab@@YAPEAVTagger@1@PEBD@Z"] + pub fn MeCab_createTagger1(arg: *const ::std::os::raw::c_char) -> *mut MeCab_Tagger; +} +extern "C" { + #[doc = " delete Lattice object."] + #[doc = " This method calles \"delete lattice\"."] + #[doc = " In some environment, e.g., MS-Windows, an object allocated inside a DLL must be deleted in the same DLL too."] + #[doc = " @param lattice lattice object"] + #[link_name = "\u{1}?deleteLattice@MeCab@@YAXPEAVLattice@1@@Z"] + pub fn MeCab_deleteLattice(lattice: *mut MeCab_Lattice); +} +extern "C" { + #[doc = " delete Model object."] + #[doc = " This method calles \"delete model\"."] + #[doc = " In some environment, e.g., MS-Windows, an object allocated inside a DLL must be deleted in the same DLL too."] + #[doc = " @param model model object"] + #[link_name = "\u{1}?deleteModel@MeCab@@YAXPEAVModel@1@@Z"] + pub fn MeCab_deleteModel(model: *mut MeCab_Model); +} +extern "C" { + #[doc = " delete Tagger object."] + #[doc = " This method calles \"delete tagger\"."] + #[doc = " In some environment, e.g., MS-Windows, an object allocated inside a DLL must be deleted in the same DLL too."] + #[doc = " @param tagger tagger object"] + #[link_name = "\u{1}?deleteTagger@MeCab@@YAXPEAVTagger@1@@Z"] + pub fn MeCab_deleteTagger(tagger: *mut MeCab_Tagger); +} +extern "C" { + #[doc = " Return last error string."] + #[doc = " @return error string"] + #[link_name = "\u{1}?getLastError@MeCab@@YAPEBDXZ"] + pub fn MeCab_getLastError() -> *const ::std::os::raw::c_char; +} +extern "C" { + #[doc = " An alias of getLastError."] + #[doc = " It is kept for backward compatibility."] + #[doc = " @return error string"] + #[link_name = "\u{1}?getTaggerError@MeCab@@YAPEBDXZ"] + pub fn MeCab_getTaggerError() -> *const ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _Mecab { + pub feature: *mut *mut ::std::os::raw::c_char, + pub size: ::std::os::raw::c_int, + pub model: *mut ::std::os::raw::c_void, + pub tagger: *mut ::std::os::raw::c_void, + pub lattice: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout__Mecab() { + assert_eq!( + ::std::mem::size_of::<_Mecab>(), + 40usize, + concat!("Size of: ", stringify!(_Mecab)) + ); + assert_eq!( + ::std::mem::align_of::<_Mecab>(), + 8usize, + concat!("Alignment of ", stringify!(_Mecab)) + ); + fn test_field_feature() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_Mecab>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).feature) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_Mecab), + "::", + stringify!(feature) + ) + ); + } + test_field_feature(); + fn test_field_size() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_Mecab>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_Mecab), + "::", + stringify!(size) + ) + ); + } + test_field_size(); + fn test_field_model() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_Mecab>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).model) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_Mecab), + "::", + stringify!(model) + ) + ); + } + test_field_model(); + fn test_field_tagger() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_Mecab>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).tagger) as usize - ptr as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(_Mecab), + "::", + stringify!(tagger) + ) + ); + } + test_field_tagger(); + fn test_field_lattice() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_Mecab>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).lattice) as usize - ptr as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(_Mecab), + "::", + stringify!(lattice) + ) + ); + } + test_field_lattice(); +} +pub type Mecab = _Mecab; +extern "C" { + pub fn Mecab_initialize(m: *mut Mecab) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Mecab_load( + m: *mut Mecab, + dicdir: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Mecab_analysis( + m: *mut Mecab, + str_: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Mecab_print(m: *mut Mecab) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Mecab_get_size(m: *mut Mecab) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Mecab_get_feature(m: *mut Mecab) -> *mut *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn Mecab_refresh(m: *mut Mecab) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Mecab_clear(m: *mut Mecab) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NJDNode { + pub string: *mut ::std::os::raw::c_char, + pub pos: *mut ::std::os::raw::c_char, + pub pos_group1: *mut ::std::os::raw::c_char, + pub pos_group2: *mut ::std::os::raw::c_char, + pub pos_group3: *mut ::std::os::raw::c_char, + pub ctype: *mut ::std::os::raw::c_char, + pub cform: *mut ::std::os::raw::c_char, + pub orig: *mut ::std::os::raw::c_char, + pub read: *mut ::std::os::raw::c_char, + pub pron: *mut ::std::os::raw::c_char, + pub acc: ::std::os::raw::c_int, + pub mora_size: ::std::os::raw::c_int, + pub chain_rule: *mut ::std::os::raw::c_char, + pub chain_flag: ::std::os::raw::c_int, + pub prev: *mut _NJDNode, + pub next: *mut _NJDNode, +} +#[test] +fn bindgen_test_layout__NJDNode() { + assert_eq!( + ::std::mem::size_of::<_NJDNode>(), + 120usize, + concat!("Size of: ", stringify!(_NJDNode)) + ); + assert_eq!( + ::std::mem::align_of::<_NJDNode>(), + 8usize, + concat!("Alignment of ", stringify!(_NJDNode)) + ); + fn test_field_string() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).string) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_NJDNode), + "::", + stringify!(string) + ) + ); + } + test_field_string(); + fn test_field_pos() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).pos) as usize - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_NJDNode), + "::", + stringify!(pos) + ) + ); + } + test_field_pos(); + fn test_field_pos_group1() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).pos_group1) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_NJDNode), + "::", + stringify!(pos_group1) + ) + ); + } + test_field_pos_group1(); + fn test_field_pos_group2() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).pos_group2) as usize - ptr as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(_NJDNode), + "::", + stringify!(pos_group2) + ) + ); + } + test_field_pos_group2(); + fn test_field_pos_group3() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).pos_group3) as usize - ptr as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(_NJDNode), + "::", + stringify!(pos_group3) + ) + ); + } + test_field_pos_group3(); + fn test_field_ctype() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).ctype) as usize - ptr as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(_NJDNode), + "::", + stringify!(ctype) + ) + ); + } + test_field_ctype(); + fn test_field_cform() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).cform) as usize - ptr as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(_NJDNode), + "::", + stringify!(cform) + ) + ); + } + test_field_cform(); + fn test_field_orig() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).orig) as usize - ptr as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(_NJDNode), + "::", + stringify!(orig) + ) + ); + } + test_field_orig(); + fn test_field_read() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).read) as usize - ptr as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(_NJDNode), + "::", + stringify!(read) + ) + ); + } + test_field_read(); + fn test_field_pron() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).pron) as usize - ptr as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(_NJDNode), + "::", + stringify!(pron) + ) + ); + } + test_field_pron(); + fn test_field_acc() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).acc) as usize - ptr as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(_NJDNode), + "::", + stringify!(acc) + ) + ); + } + test_field_acc(); + fn test_field_mora_size() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).mora_size) as usize - ptr as usize + }, + 84usize, + concat!( + "Offset of field: ", + stringify!(_NJDNode), + "::", + stringify!(mora_size) + ) + ); + } + test_field_mora_size(); + fn test_field_chain_rule() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).chain_rule) as usize - ptr as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(_NJDNode), + "::", + stringify!(chain_rule) + ) + ); + } + test_field_chain_rule(); + fn test_field_chain_flag() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).chain_flag) as usize - ptr as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(_NJDNode), + "::", + stringify!(chain_flag) + ) + ); + } + test_field_chain_flag(); + fn test_field_prev() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(_NJDNode), + "::", + stringify!(prev) + ) + ); + } + test_field_prev(); + fn test_field_next() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(_NJDNode), + "::", + stringify!(next) + ) + ); + } + test_field_next(); +} +pub type NJDNode = _NJDNode; +extern "C" { + pub fn NJDNode_initialize(node: *mut NJDNode); +} +extern "C" { + pub fn NJDNode_set_string(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn NJDNode_set_pos(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn NJDNode_set_pos_group1(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn NJDNode_set_pos_group2(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn NJDNode_set_pos_group3(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn NJDNode_set_ctype(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn NJDNode_set_cform(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn NJDNode_set_orig(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn NJDNode_set_read(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn NJDNode_set_pron(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn NJDNode_set_acc(node: *mut NJDNode, acc: ::std::os::raw::c_int); +} +extern "C" { + pub fn NJDNode_set_mora_size(node: *mut NJDNode, size: ::std::os::raw::c_int); +} +extern "C" { + pub fn NJDNode_set_chain_rule(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn NJDNode_set_chain_flag(node: *mut NJDNode, flag: ::std::os::raw::c_int); +} +extern "C" { + pub fn NJDNode_add_string(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn NJDNode_add_orig(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn NJDNode_add_read(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn NJDNode_add_pron(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn NJDNode_add_acc(node: *mut NJDNode, acc: ::std::os::raw::c_int); +} +extern "C" { + pub fn NJDNode_add_mora_size(node: *mut NJDNode, size: ::std::os::raw::c_int); +} +extern "C" { + pub fn NJDNode_get_string(node: *mut NJDNode) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn NJDNode_get_pos(node: *mut NJDNode) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn NJDNode_get_pos_group1(node: *mut NJDNode) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn NJDNode_get_pos_group2(node: *mut NJDNode) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn NJDNode_get_pos_group3(node: *mut NJDNode) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn NJDNode_get_ctype(node: *mut NJDNode) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn NJDNode_get_cform(node: *mut NJDNode) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn NJDNode_get_orig(node: *mut NJDNode) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn NJDNode_get_read(node: *mut NJDNode) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn NJDNode_get_pron(node: *mut NJDNode) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn NJDNode_get_acc(node: *mut NJDNode) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn NJDNode_get_mora_size(node: *mut NJDNode) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn NJDNode_get_chain_rule(node: *mut NJDNode) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn NJDNode_get_chain_flag(node: *mut NJDNode) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn NJDNode_load(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn NJDNode_insert( + prev: *mut NJDNode, + next: *mut NJDNode, + node: *mut NJDNode, + ) -> *mut NJDNode; +} +extern "C" { + pub fn NJDNode_copy(node1: *mut NJDNode, node2: *mut NJDNode); +} +extern "C" { + pub fn NJDNode_print(node: *mut NJDNode); +} +extern "C" { + pub fn NJDNode_fprint(node: *mut NJDNode, fp: *mut FILE); +} +extern "C" { + pub fn NJDNode_sprint( + node: *mut NJDNode, + buff: *mut ::std::os::raw::c_char, + split_code: *const ::std::os::raw::c_char, + ); +} +extern "C" { + pub fn NJDNode_clear(node: *mut NJDNode); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NJD { + pub head: *mut NJDNode, + pub tail: *mut NJDNode, +} +#[test] +fn bindgen_test_layout__NJD() { + assert_eq!( + ::std::mem::size_of::<_NJD>(), + 16usize, + concat!("Size of: ", stringify!(_NJD)) + ); + assert_eq!( + ::std::mem::align_of::<_NJD>(), + 8usize, + concat!("Alignment of ", stringify!(_NJD)) + ); + fn test_field_head() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_NJD>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).head) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_NJD), + "::", + stringify!(head) + ) + ); + } + test_field_head(); + fn test_field_tail() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_NJD>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).tail) as usize - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_NJD), + "::", + stringify!(tail) + ) + ); + } + test_field_tail(); +} +pub type NJD = _NJD; +extern "C" { + pub fn NJD_initialize(njd: *mut NJD); +} +extern "C" { + pub fn NJD_load(njd: *mut NJD, str_: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn NJD_load_from_fp(njd: *mut NJD, fp: *mut FILE); +} +extern "C" { + pub fn NJD_get_size(njd: *mut NJD) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn NJD_push_node(njd: *mut NJD, node: *mut NJDNode); +} +extern "C" { + pub fn NJD_remove_node(njd: *mut NJD, node: *mut NJDNode) -> *mut NJDNode; +} +extern "C" { + pub fn NJD_remove_silent_node(njd: *mut NJD); +} +extern "C" { + pub fn NJD_print(njd: *mut NJD); +} +extern "C" { + pub fn NJD_fprint(njd: *mut NJD, fp: *mut FILE); +} +extern "C" { + pub fn NJD_sprint( + njd: *mut NJD, + buff: *mut ::std::os::raw::c_char, + split_code: *const ::std::os::raw::c_char, + ); +} +extern "C" { + pub fn NJD_refresh(njd: *mut NJD); +} +extern "C" { + pub fn NJD_clear(wl: *mut NJD); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _JPCommonLabelPhoneme { + pub phoneme: *mut ::std::os::raw::c_char, + pub prev: *mut _JPCommonLabelPhoneme, + pub next: *mut _JPCommonLabelPhoneme, + pub up: *mut _JPCommonLabelMora, +} +#[test] +fn bindgen_test_layout__JPCommonLabelPhoneme() { + assert_eq!( + ::std::mem::size_of::<_JPCommonLabelPhoneme>(), + 32usize, + concat!("Size of: ", stringify!(_JPCommonLabelPhoneme)) + ); + assert_eq!( + ::std::mem::align_of::<_JPCommonLabelPhoneme>(), + 8usize, + concat!("Alignment of ", stringify!(_JPCommonLabelPhoneme)) + ); + fn test_field_phoneme() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelPhoneme>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).phoneme) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelPhoneme), + "::", + stringify!(phoneme) + ) + ); + } + test_field_phoneme(); + fn test_field_prev() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelPhoneme>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelPhoneme), + "::", + stringify!(prev) + ) + ); + } + test_field_prev(); + fn test_field_next() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelPhoneme>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelPhoneme), + "::", + stringify!(next) + ) + ); + } + test_field_next(); + fn test_field_up() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelPhoneme>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).up) as usize - ptr as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelPhoneme), + "::", + stringify!(up) + ) + ); + } + test_field_up(); +} +pub type JPCommonLabelPhoneme = _JPCommonLabelPhoneme; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _JPCommonLabelMora { + pub mora: *mut ::std::os::raw::c_char, + pub head: *mut _JPCommonLabelPhoneme, + pub tail: *mut _JPCommonLabelPhoneme, + pub prev: *mut _JPCommonLabelMora, + pub next: *mut _JPCommonLabelMora, + pub up: *mut _JPCommonLabelWord, +} +#[test] +fn bindgen_test_layout__JPCommonLabelMora() { + assert_eq!( + ::std::mem::size_of::<_JPCommonLabelMora>(), + 48usize, + concat!("Size of: ", stringify!(_JPCommonLabelMora)) + ); + assert_eq!( + ::std::mem::align_of::<_JPCommonLabelMora>(), + 8usize, + concat!("Alignment of ", stringify!(_JPCommonLabelMora)) + ); + fn test_field_mora() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelMora>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).mora) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelMora), + "::", + stringify!(mora) + ) + ); + } + test_field_mora(); + fn test_field_head() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelMora>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).head) as usize - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelMora), + "::", + stringify!(head) + ) + ); + } + test_field_head(); + fn test_field_tail() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelMora>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).tail) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelMora), + "::", + stringify!(tail) + ) + ); + } + test_field_tail(); + fn test_field_prev() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelMora>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelMora), + "::", + stringify!(prev) + ) + ); + } + test_field_prev(); + fn test_field_next() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelMora>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelMora), + "::", + stringify!(next) + ) + ); + } + test_field_next(); + fn test_field_up() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelMora>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).up) as usize - ptr as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelMora), + "::", + stringify!(up) + ) + ); + } + test_field_up(); +} +pub type JPCommonLabelMora = _JPCommonLabelMora; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _JPCommonLabelWord { + pub pron: *mut ::std::os::raw::c_char, + pub pos: *mut ::std::os::raw::c_char, + pub ctype: *mut ::std::os::raw::c_char, + pub cform: *mut ::std::os::raw::c_char, + pub head: *mut _JPCommonLabelMora, + pub tail: *mut _JPCommonLabelMora, + pub prev: *mut _JPCommonLabelWord, + pub next: *mut _JPCommonLabelWord, + pub up: *mut _JPCommonLabelAccentPhrase, +} +#[test] +fn bindgen_test_layout__JPCommonLabelWord() { + assert_eq!( + ::std::mem::size_of::<_JPCommonLabelWord>(), + 72usize, + concat!("Size of: ", stringify!(_JPCommonLabelWord)) + ); + assert_eq!( + ::std::mem::align_of::<_JPCommonLabelWord>(), + 8usize, + concat!("Alignment of ", stringify!(_JPCommonLabelWord)) + ); + fn test_field_pron() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelWord>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).pron) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelWord), + "::", + stringify!(pron) + ) + ); + } + test_field_pron(); + fn test_field_pos() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelWord>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).pos) as usize - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelWord), + "::", + stringify!(pos) + ) + ); + } + test_field_pos(); + fn test_field_ctype() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelWord>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).ctype) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelWord), + "::", + stringify!(ctype) + ) + ); + } + test_field_ctype(); + fn test_field_cform() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelWord>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).cform) as usize - ptr as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelWord), + "::", + stringify!(cform) + ) + ); + } + test_field_cform(); + fn test_field_head() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelWord>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).head) as usize - ptr as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelWord), + "::", + stringify!(head) + ) + ); + } + test_field_head(); + fn test_field_tail() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelWord>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).tail) as usize - ptr as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelWord), + "::", + stringify!(tail) + ) + ); } - #[inline] - pub unsafe fn create( - argc: ::std::os::raw::c_int, - argv: *mut *mut ::std::os::raw::c_char, - ) -> *mut MeCab_Tagger { - MeCab_Tagger_create(argc, argv) + test_field_tail(); + fn test_field_prev() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelWord>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelWord), + "::", + stringify!(prev) + ) + ); } - #[inline] - pub unsafe fn create1(arg: *const ::std::os::raw::c_char) -> *mut MeCab_Tagger { - MeCab_Tagger_create1(arg) + test_field_prev(); + fn test_field_next() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelWord>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelWord), + "::", + stringify!(next) + ) + ); } - #[inline] - pub unsafe fn version() -> *const ::std::os::raw::c_char { - MeCab_Tagger_version() + test_field_next(); + fn test_field_up() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelWord>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).up) as usize - ptr as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelWord), + "::", + stringify!(up) + ) + ); } + test_field_up(); } -extern "C" { - #[doc = " Alias of Lattice::create()"] - #[link_name = "\u{1}?createLattice@MeCab@@YAPEAVLattice@1@XZ"] - pub fn MeCab_createLattice() -> *mut MeCab_Lattice; -} -extern "C" { - #[doc = " Alias of Mode::create(argc, argv)"] - #[link_name = "\u{1}?createModel@MeCab@@YAPEAVModel@1@HPEAPEAD@Z"] - pub fn MeCab_createModel( - argc: ::std::os::raw::c_int, - argv: *mut *mut ::std::os::raw::c_char, - ) -> *mut MeCab_Model; -} -extern "C" { - #[doc = " Alias of Mode::create(arg)"] - #[link_name = "\u{1}?createModel@MeCab@@YAPEAVModel@1@PEBD@Z"] - pub fn MeCab_createModel1(arg: *const ::std::os::raw::c_char) -> *mut MeCab_Model; -} -extern "C" { - #[doc = " Alias of Tagger::create(argc, argv)"] - #[link_name = "\u{1}?createTagger@MeCab@@YAPEAVTagger@1@HPEAPEAD@Z"] - pub fn MeCab_createTagger( - argc: ::std::os::raw::c_int, - argv: *mut *mut ::std::os::raw::c_char, - ) -> *mut MeCab_Tagger; -} -extern "C" { - #[doc = " Alias of Tagger::create(arg)"] - #[link_name = "\u{1}?createTagger@MeCab@@YAPEAVTagger@1@PEBD@Z"] - pub fn MeCab_createTagger1(arg: *const ::std::os::raw::c_char) -> *mut MeCab_Tagger; -} -extern "C" { - #[doc = " delete Lattice object."] - #[doc = " This method calles \"delete lattice\"."] - #[doc = " In some environment, e.g., MS-Windows, an object allocated inside a DLL must be deleted in the same DLL too."] - #[doc = " @param lattice lattice object"] - #[link_name = "\u{1}?deleteLattice@MeCab@@YAXPEAVLattice@1@@Z"] - pub fn MeCab_deleteLattice(lattice: *mut MeCab_Lattice); -} -extern "C" { - #[doc = " delete Model object."] - #[doc = " This method calles \"delete model\"."] - #[doc = " In some environment, e.g., MS-Windows, an object allocated inside a DLL must be deleted in the same DLL too."] - #[doc = " @param model model object"] - #[link_name = "\u{1}?deleteModel@MeCab@@YAXPEAVModel@1@@Z"] - pub fn MeCab_deleteModel(model: *mut MeCab_Model); -} -extern "C" { - #[doc = " delete Tagger object."] - #[doc = " This method calles \"delete tagger\"."] - #[doc = " In some environment, e.g., MS-Windows, an object allocated inside a DLL must be deleted in the same DLL too."] - #[doc = " @param tagger tagger object"] - #[link_name = "\u{1}?deleteTagger@MeCab@@YAXPEAVTagger@1@@Z"] - pub fn MeCab_deleteTagger(tagger: *mut MeCab_Tagger); -} -extern "C" { - #[doc = " Return last error string."] - #[doc = " @return error string"] - #[link_name = "\u{1}?getLastError@MeCab@@YAPEBDXZ"] - pub fn MeCab_getLastError() -> *const ::std::os::raw::c_char; -} -extern "C" { - #[doc = " An alias of getLastError."] - #[doc = " It is kept for backward compatibility."] - #[doc = " @return error string"] - #[link_name = "\u{1}?getTaggerError@MeCab@@YAPEBDXZ"] - pub fn MeCab_getTaggerError() -> *const ::std::os::raw::c_char; -} +pub type JPCommonLabelWord = _JPCommonLabelWord; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _Mecab { - pub feature: *mut *mut ::std::os::raw::c_char, - pub size: ::std::os::raw::c_int, - pub model: *mut ::std::os::raw::c_void, - pub tagger: *mut ::std::os::raw::c_void, - pub lattice: *mut ::std::os::raw::c_void, +pub struct _JPCommonLabelAccentPhrase { + pub accent: ::std::os::raw::c_int, + pub emotion: *mut ::std::os::raw::c_char, + pub head: *mut _JPCommonLabelWord, + pub tail: *mut _JPCommonLabelWord, + pub prev: *mut _JPCommonLabelAccentPhrase, + pub next: *mut _JPCommonLabelAccentPhrase, + pub up: *mut _JPCommonLabelBreathGroup, } #[test] -fn bindgen_test_layout__Mecab() { +fn bindgen_test_layout__JPCommonLabelAccentPhrase() { assert_eq!( - ::std::mem::size_of::<_Mecab>(), - 40usize, - concat!("Size of: ", stringify!(_Mecab)) + ::std::mem::size_of::<_JPCommonLabelAccentPhrase>(), + 56usize, + concat!("Size of: ", stringify!(_JPCommonLabelAccentPhrase)) ); assert_eq!( - ::std::mem::align_of::<_Mecab>(), + ::std::mem::align_of::<_JPCommonLabelAccentPhrase>(), 8usize, - concat!("Alignment of ", stringify!(_Mecab)) + concat!("Alignment of ", stringify!(_JPCommonLabelAccentPhrase)) ); - fn test_field_feature() { + fn test_field_accent() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_Mecab>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelAccentPhrase>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).feature) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).accent) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_Mecab), + stringify!(_JPCommonLabelAccentPhrase), "::", - stringify!(feature) + stringify!(accent) ) ); } - test_field_feature(); - fn test_field_size() { + test_field_accent(); + fn test_field_emotion() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_Mecab>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelAccentPhrase>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).emotion) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_Mecab), + stringify!(_JPCommonLabelAccentPhrase), "::", - stringify!(size) + stringify!(emotion) ) ); } - test_field_size(); - fn test_field_model() { + test_field_emotion(); + fn test_field_head() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_Mecab>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelAccentPhrase>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).model) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).head) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", - stringify!(_Mecab), + stringify!(_JPCommonLabelAccentPhrase), "::", - stringify!(model) + stringify!(head) ) ); } - test_field_model(); - fn test_field_tagger() { + test_field_head(); + fn test_field_tail() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_Mecab>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelAccentPhrase>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).tagger) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).tail) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", - stringify!(_Mecab), + stringify!(_JPCommonLabelAccentPhrase), "::", - stringify!(tagger) + stringify!(tail) ) ); } - test_field_tagger(); - fn test_field_lattice() { + test_field_tail(); + fn test_field_prev() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_Mecab>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelAccentPhrase>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).lattice) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", - stringify!(_Mecab), + stringify!(_JPCommonLabelAccentPhrase), "::", - stringify!(lattice) + stringify!(prev) ) ); } - test_field_lattice(); -} -pub type Mecab = _Mecab; -extern "C" { - pub fn Mecab_initialize(m: *mut Mecab) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn Mecab_load( - m: *mut Mecab, - dicdir: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn Mecab_analysis( - m: *mut Mecab, - str_: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn Mecab_print(m: *mut Mecab) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn Mecab_get_size(m: *mut Mecab) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn Mecab_get_feature(m: *mut Mecab) -> *mut *mut ::std::os::raw::c_char; + test_field_prev(); + fn test_field_next() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelAccentPhrase>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelAccentPhrase), + "::", + stringify!(next) + ) + ); + } + test_field_next(); + fn test_field_up() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelAccentPhrase>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).up) as usize - ptr as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelAccentPhrase), + "::", + stringify!(up) + ) + ); + } + test_field_up(); } -extern "C" { - pub fn Mecab_refresh(m: *mut Mecab) -> ::std::os::raw::c_int; +pub type JPCommonLabelAccentPhrase = _JPCommonLabelAccentPhrase; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _JPCommonLabelBreathGroup { + pub head: *mut _JPCommonLabelAccentPhrase, + pub tail: *mut _JPCommonLabelAccentPhrase, + pub prev: *mut _JPCommonLabelBreathGroup, + pub next: *mut _JPCommonLabelBreathGroup, } -extern "C" { - pub fn Mecab_clear(m: *mut Mecab) -> ::std::os::raw::c_int; +#[test] +fn bindgen_test_layout__JPCommonLabelBreathGroup() { + assert_eq!( + ::std::mem::size_of::<_JPCommonLabelBreathGroup>(), + 32usize, + concat!("Size of: ", stringify!(_JPCommonLabelBreathGroup)) + ); + assert_eq!( + ::std::mem::align_of::<_JPCommonLabelBreathGroup>(), + 8usize, + concat!("Alignment of ", stringify!(_JPCommonLabelBreathGroup)) + ); + fn test_field_head() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelBreathGroup>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).head) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelBreathGroup), + "::", + stringify!(head) + ) + ); + } + test_field_head(); + fn test_field_tail() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelBreathGroup>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).tail) as usize - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelBreathGroup), + "::", + stringify!(tail) + ) + ); + } + test_field_tail(); + fn test_field_prev() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelBreathGroup>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelBreathGroup), + "::", + stringify!(prev) + ) + ); + } + test_field_prev(); + fn test_field_next() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabelBreathGroup>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabelBreathGroup), + "::", + stringify!(next) + ) + ); + } + test_field_next(); } +pub type JPCommonLabelBreathGroup = _JPCommonLabelBreathGroup; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _NJDNode { - pub string: *mut ::std::os::raw::c_char, - pub pos: *mut ::std::os::raw::c_char, - pub pos_group1: *mut ::std::os::raw::c_char, - pub pos_group2: *mut ::std::os::raw::c_char, - pub pos_group3: *mut ::std::os::raw::c_char, - pub ctype: *mut ::std::os::raw::c_char, - pub cform: *mut ::std::os::raw::c_char, - pub orig: *mut ::std::os::raw::c_char, - pub read: *mut ::std::os::raw::c_char, - pub pron: *mut ::std::os::raw::c_char, - pub acc: ::std::os::raw::c_int, - pub mora_size: ::std::os::raw::c_int, - pub chain_rule: *mut ::std::os::raw::c_char, - pub chain_flag: ::std::os::raw::c_int, - pub prev: *mut _NJDNode, - pub next: *mut _NJDNode, +pub struct _JPCommonLabel { + pub size: ::std::os::raw::c_int, + pub feature: *mut *mut ::std::os::raw::c_char, + pub breath_head: *mut JPCommonLabelBreathGroup, + pub breath_tail: *mut JPCommonLabelBreathGroup, + pub accent_head: *mut JPCommonLabelAccentPhrase, + pub accent_tail: *mut JPCommonLabelAccentPhrase, + pub word_head: *mut JPCommonLabelWord, + pub word_tail: *mut JPCommonLabelWord, + pub mora_head: *mut JPCommonLabelMora, + pub mora_tail: *mut JPCommonLabelMora, + pub phoneme_head: *mut JPCommonLabelPhoneme, + pub phoneme_tail: *mut JPCommonLabelPhoneme, + pub short_pause_flag: ::std::os::raw::c_int, } #[test] -fn bindgen_test_layout__NJDNode() { +fn bindgen_test_layout__JPCommonLabel() { assert_eq!( - ::std::mem::size_of::<_NJDNode>(), - 120usize, - concat!("Size of: ", stringify!(_NJDNode)) + ::std::mem::size_of::<_JPCommonLabel>(), + 104usize, + concat!("Size of: ", stringify!(_JPCommonLabel)) ); assert_eq!( - ::std::mem::align_of::<_NJDNode>(), + ::std::mem::align_of::<_JPCommonLabel>(), 8usize, - concat!("Alignment of ", stringify!(_NJDNode)) + concat!("Alignment of ", stringify!(_JPCommonLabel)) ); - fn test_field_string() { + fn test_field_size() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).string) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_NJDNode), + stringify!(_JPCommonLabel), "::", - stringify!(string) + stringify!(size) ) ); } - test_field_string(); - fn test_field_pos() { + test_field_size(); + fn test_field_feature() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).pos) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).feature) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_NJDNode), + stringify!(_JPCommonLabel), "::", - stringify!(pos) + stringify!(feature) ) ); } - test_field_pos(); - fn test_field_pos_group1() { + test_field_feature(); + fn test_field_breath_head() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).pos_group1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).breath_head) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", - stringify!(_NJDNode), + stringify!(_JPCommonLabel), "::", - stringify!(pos_group1) + stringify!(breath_head) ) ); } - test_field_pos_group1(); - fn test_field_pos_group2() { + test_field_breath_head(); + fn test_field_breath_tail() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).pos_group2) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).breath_tail) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", - stringify!(_NJDNode), + stringify!(_JPCommonLabel), "::", - stringify!(pos_group2) + stringify!(breath_tail) ) ); } - test_field_pos_group2(); - fn test_field_pos_group3() { + test_field_breath_tail(); + fn test_field_accent_head() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).pos_group3) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).accent_head) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", - stringify!(_NJDNode), + stringify!(_JPCommonLabel), "::", - stringify!(pos_group3) + stringify!(accent_head) ) ); } - test_field_pos_group3(); - fn test_field_ctype() { + test_field_accent_head(); + fn test_field_accent_tail() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).ctype) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).accent_tail) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", - stringify!(_NJDNode), + stringify!(_JPCommonLabel), "::", - stringify!(ctype) + stringify!(accent_tail) ) ); } - test_field_ctype(); - fn test_field_cform() { + test_field_accent_tail(); + fn test_field_word_head() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).cform) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).word_head) as usize - ptr as usize }, 48usize, concat!( "Offset of field: ", - stringify!(_NJDNode), + stringify!(_JPCommonLabel), "::", - stringify!(cform) + stringify!(word_head) ) ); } - test_field_cform(); - fn test_field_orig() { + test_field_word_head(); + fn test_field_word_tail() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).orig) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).word_tail) as usize - ptr as usize }, 56usize, concat!( "Offset of field: ", - stringify!(_NJDNode), + stringify!(_JPCommonLabel), "::", - stringify!(orig) + stringify!(word_tail) ) ); } - test_field_orig(); - fn test_field_read() { + test_field_word_tail(); + fn test_field_mora_head() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).read) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).mora_head) as usize - ptr as usize }, 64usize, concat!( "Offset of field: ", - stringify!(_NJDNode), + stringify!(_JPCommonLabel), "::", - stringify!(read) + stringify!(mora_head) ) ); } - test_field_read(); + test_field_mora_head(); + fn test_field_mora_tail() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).mora_tail) as usize - ptr as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabel), + "::", + stringify!(mora_tail) + ) + ); + } + test_field_mora_tail(); + fn test_field_phoneme_head() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).phoneme_head) as usize - ptr as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabel), + "::", + stringify!(phoneme_head) + ) + ); + } + test_field_phoneme_head(); + fn test_field_phoneme_tail() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).phoneme_tail) as usize - ptr as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabel), + "::", + stringify!(phoneme_tail) + ) + ); + } + test_field_phoneme_tail(); + fn test_field_short_pause_flag() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonLabel>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).short_pause_flag) as usize - ptr as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonLabel), + "::", + stringify!(short_pause_flag) + ) + ); + } + test_field_short_pause_flag(); +} +pub type JPCommonLabel = _JPCommonLabel; +extern "C" { + pub fn JPCommonLabel_initialize(label: *mut JPCommonLabel); +} +extern "C" { + pub fn JPCommonLabel_push_word( + label: *mut JPCommonLabel, + pron: *const ::std::os::raw::c_char, + pos: *const ::std::os::raw::c_char, + ctype: *const ::std::os::raw::c_char, + cform: *const ::std::os::raw::c_char, + acc: ::std::os::raw::c_int, + chain_flag: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn JPCommonLabel_make(label: *mut JPCommonLabel); +} +extern "C" { + pub fn JPCommonLabel_get_size(label: *mut JPCommonLabel) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn JPCommonLabel_get_feature(label: *mut JPCommonLabel) + -> *mut *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn JPCommonLabel_print(label: *mut JPCommonLabel); +} +extern "C" { + pub fn JPCommonLabel_fprint(label: *mut JPCommonLabel, fp: *mut FILE); +} +extern "C" { + pub fn JPCommonLabel_clear(label: *mut JPCommonLabel); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _JPCommonNode { + pub pron: *mut ::std::os::raw::c_char, + pub pos: *mut ::std::os::raw::c_char, + pub ctype: *mut ::std::os::raw::c_char, + pub cform: *mut ::std::os::raw::c_char, + pub acc: ::std::os::raw::c_int, + pub chain_flag: ::std::os::raw::c_int, + pub prev: *mut _JPCommonNode, + pub next: *mut _JPCommonNode, +} +#[test] +fn bindgen_test_layout__JPCommonNode() { + assert_eq!( + ::std::mem::size_of::<_JPCommonNode>(), + 56usize, + concat!("Size of: ", stringify!(_JPCommonNode)) + ); + assert_eq!( + ::std::mem::align_of::<_JPCommonNode>(), + 8usize, + concat!("Alignment of ", stringify!(_JPCommonNode)) + ); fn test_field_pron() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonNode>::uninit(); let ptr = uninit.as_ptr(); ::std::ptr::addr_of!((*ptr).pron) as usize - ptr as usize }, - 72usize, + 0usize, concat!( "Offset of field: ", - stringify!(_NJDNode), + stringify!(_JPCommonNode), "::", stringify!(pron) ) ); } test_field_pron(); - fn test_field_acc() { + fn test_field_pos() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonNode>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).acc) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).pos) as usize - ptr as usize }, - 80usize, + 8usize, concat!( "Offset of field: ", - stringify!(_NJDNode), + stringify!(_JPCommonNode), "::", - stringify!(acc) + stringify!(pos) ) ); } - test_field_acc(); - fn test_field_mora_size() { + test_field_pos(); + fn test_field_ctype() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonNode>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).mora_size) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).ctype) as usize - ptr as usize }, - 84usize, + 16usize, concat!( "Offset of field: ", - stringify!(_NJDNode), + stringify!(_JPCommonNode), "::", - stringify!(mora_size) + stringify!(ctype) ) ); } - test_field_mora_size(); - fn test_field_chain_rule() { + test_field_ctype(); + fn test_field_cform() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonNode>::uninit(); let ptr = uninit.as_ptr(); - ::std::ptr::addr_of!((*ptr).chain_rule) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).cform) as usize - ptr as usize }, - 88usize, + 24usize, concat!( "Offset of field: ", - stringify!(_NJDNode), + stringify!(_JPCommonNode), "::", - stringify!(chain_rule) + stringify!(cform) ) ); } - test_field_chain_rule(); + test_field_cform(); + fn test_field_acc() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommonNode>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).acc) as usize - ptr as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(_JPCommonNode), + "::", + stringify!(acc) + ) + ); + } + test_field_acc(); fn test_field_chain_flag() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonNode>::uninit(); let ptr = uninit.as_ptr(); ::std::ptr::addr_of!((*ptr).chain_flag) as usize - ptr as usize }, - 96usize, + 36usize, concat!( "Offset of field: ", - stringify!(_NJDNode), + stringify!(_JPCommonNode), "::", stringify!(chain_flag) ) @@ -371927,14 +372008,14 @@ fn bindgen_test_layout__NJDNode() { fn test_field_prev() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonNode>::uninit(); let ptr = uninit.as_ptr(); ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize }, - 104usize, + 40usize, concat!( "Offset of field: ", - stringify!(_NJDNode), + stringify!(_JPCommonNode), "::", stringify!(prev) ) @@ -371944,14 +372025,14 @@ fn bindgen_test_layout__NJDNode() { fn test_field_next() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NJDNode>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommonNode>::uninit(); let ptr = uninit.as_ptr(); ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize }, - 112usize, + 48usize, concat!( "Offset of field: ", - stringify!(_NJDNode), + stringify!(_JPCommonNode), "::", stringify!(next) ) @@ -371959,170 +372040,85 @@ fn bindgen_test_layout__NJDNode() { } test_field_next(); } -pub type NJDNode = _NJDNode; -extern "C" { - pub fn NJDNode_initialize(node: *mut NJDNode); -} -extern "C" { - pub fn NJDNode_set_string(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); -} -extern "C" { - pub fn NJDNode_set_pos(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); -} -extern "C" { - pub fn NJDNode_set_pos_group1(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); -} -extern "C" { - pub fn NJDNode_set_pos_group2(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); -} -extern "C" { - pub fn NJDNode_set_pos_group3(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); -} -extern "C" { - pub fn NJDNode_set_ctype(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); -} -extern "C" { - pub fn NJDNode_set_cform(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); -} -extern "C" { - pub fn NJDNode_set_orig(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); -} -extern "C" { - pub fn NJDNode_set_read(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); -} -extern "C" { - pub fn NJDNode_set_pron(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); -} -extern "C" { - pub fn NJDNode_set_acc(node: *mut NJDNode, acc: ::std::os::raw::c_int); -} -extern "C" { - pub fn NJDNode_set_mora_size(node: *mut NJDNode, size: ::std::os::raw::c_int); -} -extern "C" { - pub fn NJDNode_set_chain_rule(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); -} -extern "C" { - pub fn NJDNode_set_chain_flag(node: *mut NJDNode, flag: ::std::os::raw::c_int); -} -extern "C" { - pub fn NJDNode_add_string(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); -} -extern "C" { - pub fn NJDNode_add_orig(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); -} -extern "C" { - pub fn NJDNode_add_read(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); -} -extern "C" { - pub fn NJDNode_add_pron(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); -} -extern "C" { - pub fn NJDNode_add_acc(node: *mut NJDNode, acc: ::std::os::raw::c_int); -} -extern "C" { - pub fn NJDNode_add_mora_size(node: *mut NJDNode, size: ::std::os::raw::c_int); -} -extern "C" { - pub fn NJDNode_get_string(node: *mut NJDNode) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn NJDNode_get_pos(node: *mut NJDNode) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn NJDNode_get_pos_group1(node: *mut NJDNode) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn NJDNode_get_pos_group2(node: *mut NJDNode) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn NJDNode_get_pos_group3(node: *mut NJDNode) -> *const ::std::os::raw::c_char; -} +pub type JPCommonNode = _JPCommonNode; extern "C" { - pub fn NJDNode_get_ctype(node: *mut NJDNode) -> *const ::std::os::raw::c_char; + pub fn JPCommonNode_initialize(node: *mut JPCommonNode); } extern "C" { - pub fn NJDNode_get_cform(node: *mut NJDNode) -> *const ::std::os::raw::c_char; + pub fn JPCommonNode_set_pron(node: *mut JPCommonNode, str_: *const ::std::os::raw::c_char); } extern "C" { - pub fn NJDNode_get_orig(node: *mut NJDNode) -> *const ::std::os::raw::c_char; + pub fn JPCommonNode_set_pos(node: *mut JPCommonNode, str_: *const ::std::os::raw::c_char); } extern "C" { - pub fn NJDNode_get_read(node: *mut NJDNode) -> *const ::std::os::raw::c_char; + pub fn JPCommonNode_set_ctype(node: *mut JPCommonNode, str_: *const ::std::os::raw::c_char); } extern "C" { - pub fn NJDNode_get_pron(node: *mut NJDNode) -> *const ::std::os::raw::c_char; + pub fn JPCommonNode_set_cform(node: *mut JPCommonNode, str_: *const ::std::os::raw::c_char); } extern "C" { - pub fn NJDNode_get_acc(node: *mut NJDNode) -> ::std::os::raw::c_int; + pub fn JPCommonNode_set_acc(node: *mut JPCommonNode, acc: ::std::os::raw::c_int); } extern "C" { - pub fn NJDNode_get_mora_size(node: *mut NJDNode) -> ::std::os::raw::c_int; + pub fn JPCommonNode_set_chain_flag(node: *mut JPCommonNode, flag: ::std::os::raw::c_int); } extern "C" { - pub fn NJDNode_get_chain_rule(node: *mut NJDNode) -> *const ::std::os::raw::c_char; + pub fn JPCommonNode_get_pron(node: *mut JPCommonNode) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn NJDNode_get_chain_flag(node: *mut NJDNode) -> ::std::os::raw::c_int; + pub fn JPCommonNode_get_pos(node: *mut JPCommonNode) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn NJDNode_load(node: *mut NJDNode, str_: *const ::std::os::raw::c_char); + pub fn JPCommonNode_get_ctype(node: *mut JPCommonNode) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn NJDNode_insert( - prev: *mut NJDNode, - next: *mut NJDNode, - node: *mut NJDNode, - ) -> *mut NJDNode; + pub fn JPCommonNode_get_cform(node: *mut JPCommonNode) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn NJDNode_copy(node1: *mut NJDNode, node2: *mut NJDNode); + pub fn JPCommonNode_get_acc(node: *mut JPCommonNode) -> ::std::os::raw::c_int; } extern "C" { - pub fn NJDNode_print(node: *mut NJDNode); + pub fn JPCommonNode_get_chain_flag(node: *mut JPCommonNode) -> ::std::os::raw::c_int; } extern "C" { - pub fn NJDNode_fprint(node: *mut NJDNode, fp: *mut FILE); + pub fn JPCommonNode_print(node: *mut JPCommonNode); } extern "C" { - pub fn NJDNode_sprint( - node: *mut NJDNode, - buff: *mut ::std::os::raw::c_char, - split_code: *const ::std::os::raw::c_char, - ); + pub fn JPCommonNode_fprint(node: *mut JPCommonNode, fp: *mut FILE); } extern "C" { - pub fn NJDNode_clear(node: *mut NJDNode); + pub fn JPCommonNode_clear(node: *mut JPCommonNode); } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct _NJD { - pub head: *mut NJDNode, - pub tail: *mut NJDNode, +pub struct _JPCommon { + pub head: *mut JPCommonNode, + pub tail: *mut JPCommonNode, + pub label: *mut JPCommonLabel, } #[test] -fn bindgen_test_layout__NJD() { +fn bindgen_test_layout__JPCommon() { assert_eq!( - ::std::mem::size_of::<_NJD>(), - 16usize, - concat!("Size of: ", stringify!(_NJD)) + ::std::mem::size_of::<_JPCommon>(), + 24usize, + concat!("Size of: ", stringify!(_JPCommon)) ); assert_eq!( - ::std::mem::align_of::<_NJD>(), + ::std::mem::align_of::<_JPCommon>(), 8usize, - concat!("Alignment of ", stringify!(_NJD)) + concat!("Alignment of ", stringify!(_JPCommon)) ); fn test_field_head() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NJD>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommon>::uninit(); let ptr = uninit.as_ptr(); ::std::ptr::addr_of!((*ptr).head) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_NJD), + stringify!(_JPCommon), "::", stringify!(head) ) @@ -372132,61 +372128,65 @@ fn bindgen_test_layout__NJD() { fn test_field_tail() { assert_eq!( unsafe { - let uninit = ::std::mem::MaybeUninit::<_NJD>::uninit(); + let uninit = ::std::mem::MaybeUninit::<_JPCommon>::uninit(); let ptr = uninit.as_ptr(); ::std::ptr::addr_of!((*ptr).tail) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(_NJD), + stringify!(_JPCommon), "::", stringify!(tail) ) ); } test_field_tail(); + fn test_field_label() { + assert_eq!( + unsafe { + let uninit = ::std::mem::MaybeUninit::<_JPCommon>::uninit(); + let ptr = uninit.as_ptr(); + ::std::ptr::addr_of!((*ptr).label) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_JPCommon), + "::", + stringify!(label) + ) + ); + } + test_field_label(); } -pub type NJD = _NJD; -extern "C" { - pub fn NJD_initialize(njd: *mut NJD); -} -extern "C" { - pub fn NJD_load(njd: *mut NJD, str_: *const ::std::os::raw::c_char); -} -extern "C" { - pub fn NJD_load_from_fp(njd: *mut NJD, fp: *mut FILE); -} +pub type JPCommon = _JPCommon; extern "C" { - pub fn NJD_get_size(njd: *mut NJD) -> ::std::os::raw::c_int; + pub fn JPCommon_initialize(jpcommon: *mut JPCommon); } extern "C" { - pub fn NJD_push_node(njd: *mut NJD, node: *mut NJDNode); + pub fn JPCommon_push(jpcommon: *mut JPCommon, node: *mut JPCommonNode); } extern "C" { - pub fn NJD_remove_node(njd: *mut NJD, node: *mut NJDNode) -> *mut NJDNode; + pub fn JPCommon_make_label(jpcommon: *mut JPCommon); } extern "C" { - pub fn NJD_remove_silent_node(njd: *mut NJD); + pub fn JPCommon_get_label_size(jpcommon: *mut JPCommon) -> ::std::os::raw::c_int; } extern "C" { - pub fn NJD_print(njd: *mut NJD); + pub fn JPCommon_get_label_feature(jpcommon: *mut JPCommon) -> *mut *mut ::std::os::raw::c_char; } extern "C" { - pub fn NJD_fprint(njd: *mut NJD, fp: *mut FILE); + pub fn JPCommon_print(jpcommon: *mut JPCommon); } extern "C" { - pub fn NJD_sprint( - njd: *mut NJD, - buff: *mut ::std::os::raw::c_char, - split_code: *const ::std::os::raw::c_char, - ); + pub fn JPCommon_fprint(jpcommon: *mut JPCommon, fp: *mut FILE); } extern "C" { - pub fn NJD_refresh(njd: *mut NJD); + pub fn JPCommon_refresh(jpcommon: *mut JPCommon); } extern "C" { - pub fn NJD_clear(wl: *mut NJD); + pub fn JPCommon_clear(jpcommon: *mut JPCommon); } extern "C" { pub fn njd2jpcommon(jpcommon: *mut JPCommon, njd: *mut NJD);