diff --git a/Cargo.toml b/Cargo.toml index a96b336..99c5fcd 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,7 +10,17 @@ readme = ".github/README.md" exclude = [".github", ".metadata", "docs", "tests"] [workspace] -members = ["crates/samples/*", "crates/tests/*"] +members = ["crates/samples/*"] + +[dependencies.windows] +version = "0.59" +features = [ + "Win32_Foundation", + "Win32_System_Com", + "Win32_System_Variant", + "Win32_System_Ole", + "Win32_System_Com_StructuredStorage", +] [dependencies.windows-core] version = "0.59" diff --git a/build.rs b/build.rs index 08da012..00d4449 100644 --- a/build.rs +++ b/build.rs @@ -11,6 +11,8 @@ fn main() { "--flat", "--filter", "Microsoft.Dia", + "--reference", + "windows,skip-root,Windows", ]); windows_bindgen::bindgen([ diff --git a/crates/tests/enumerators/Cargo.toml b/crates/tests/enumerators/Cargo.toml deleted file mode 100644 index 5f5312c..0000000 --- a/crates/tests/enumerators/Cargo.toml +++ /dev/null @@ -1,11 +0,0 @@ -[package] -name = "test_enumerators" -version = "0.0.0" -edition = "2021" -publish = false - -[dependencies.windows-core] -version = "0.59" - -[dependencies.microsoft-dia] -path = "../../../" diff --git a/crates/tests/enumerators/src/lib.rs b/crates/tests/enumerators/src/lib.rs deleted file mode 100644 index 8b13789..0000000 --- a/crates/tests/enumerators/src/lib.rs +++ /dev/null @@ -1 +0,0 @@ - diff --git a/crates/tests/enumerators/tests/tests.rs b/crates/tests/enumerators/tests/tests.rs deleted file mode 100644 index 571ae9c..0000000 --- a/crates/tests/enumerators/tests/tests.rs +++ /dev/null @@ -1,92 +0,0 @@ -use microsoft_dia::{nsfRegularExpression, DiaSource, IDiaDataSource, IDiaSession, SymTagNull}; -use windows_core::*; -const S_OK: HRESULT = HRESULT(0); - -fn get_test_session() -> Result { - unsafe { - let path = if cfg!(target_arch = "x86_64") { - s!( - r"C:\Program Files\Microsoft Visual Studio\2022\Enterprise\DIA SDK\bin\amd64\msdia140.dll" - ) - } else if cfg!(target_arch = "aarch64") { - s!( - r"C:\Program Files\Microsoft Visual Studio\2022\Enterprise\DIA SDK\bin\arm64\msdia140.dll" - ) - } else if cfg!(target_arch = "x86") { - s!(r"C:\Program Files\Microsoft Visual Studio\2022\Enterprise\DIA SDK\bin\msdia140.dll") - } else { - panic!("Unsupported target architecture"); - }; - let source: IDiaDataSource = microsoft_dia::helpers::NoRegCoCreate(path, &DiaSource)?; - let executable = std::env::current_exe().unwrap(); - source.loadDataForExe(&HSTRING::from(executable.as_os_str()), None, None)?; - source.openSession() - } -} - -#[allow(dead_code)] -static TEST_VALUE_01: i32 = 1; -#[allow(dead_code)] -static TEST_VALUE_02: i32 = 2; -#[allow(dead_code)] -static TEST_VALUE_03: i32 = 3; - -#[test] -fn simple_enumeration() -> Result<()> { - unsafe { - let session = get_test_session()?; - let symbols = session.globalScope()?.findChildren( - SymTagNull, - w!("tests::TEST_VALUE_[0-9]+"), - nsfRegularExpression.0 as u32, - )?; - - let mut found = Vec::new(); - for i in 0..symbols.Count()? { - found.push(symbols.Item(i as u32)?.name()?); - } - assert_eq!( - found, - [ - "tests::TEST_VALUE_01", - "tests::TEST_VALUE_02", - "tests::TEST_VALUE_03", - ] - ); - - Ok(()) - } -} - -#[test] -fn batch_enumeration() -> Result<()> { - unsafe { - let session = get_test_session()?; - let symbols = session.globalScope()?.findChildren( - SymTagNull, - w!("tests::TEST_VALUE_[0-9]+"), - nsfRegularExpression.0 as u32, - )?; - - let mut found = Vec::new(); - let mut batch = [None, None]; - let mut fetched = 0; - while symbols.Next(&mut batch, &mut fetched) == S_OK { - found.extend( - batch[0..fetched as usize] - .iter() - .filter_map(|s| s.as_ref()?.name().ok()), - ); - } - assert_eq!( - found, - [ - "tests::TEST_VALUE_01", - "tests::TEST_VALUE_02", - "tests::TEST_VALUE_03", - ] - ); - - Ok(()) - } -} diff --git a/src/public_bindings.rs b/src/public_bindings.rs index 135a190..e2bde8d 100644 --- a/src/public_bindings.rs +++ b/src/public_bindings.rs @@ -3641,6 +3641,51 @@ windows_core::imp::define_interface!( ); windows_core::imp::interface_hierarchy!(IDiaAddressMap, windows_core::IUnknown); impl IDiaAddressMap { + pub unsafe fn addressMapEnabled( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).addressMapEnabled)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn SetaddressMapEnabled(&self, newval: bool) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).SetaddressMapEnabled)( + windows_core::Interface::as_raw(self), + newval.into(), + ) + .ok() + } + } + pub unsafe fn relativeVirtualAddressEnabled( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).relativeVirtualAddressEnabled)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn SetrelativeVirtualAddressEnabled( + &self, + newval: bool, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).SetrelativeVirtualAddressEnabled)( + windows_core::Interface::as_raw(self), + newval.into(), + ) + .ok() + } + } pub unsafe fn imageAlign(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); @@ -3660,27 +3705,172 @@ impl IDiaAddressMap { .ok() } } + pub unsafe fn set_imageHeaders( + &self, + pbdata: &[u8], + originalheaders: bool, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).set_imageHeaders)( + windows_core::Interface::as_raw(self), + pbdata.len().try_into().unwrap(), + core::mem::transmute(pbdata.as_ptr()), + originalheaders.into(), + ) + .ok() + } + } + pub unsafe fn set_addressMap( + &self, + pdata: &[DiaAddressMapEntry], + imagetosymbols: bool, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).set_addressMap)( + windows_core::Interface::as_raw(self), + pdata.len().try_into().unwrap(), + core::mem::transmute(pdata.as_ptr()), + imagetosymbols.into(), + ) + .ok() + } + } } #[repr(C)] pub struct IDiaAddressMap_Vtbl { pub base__: windows_core::IUnknown_Vtbl, - get_addressMapEnabled: usize, - put_addressMapEnabled: usize, - get_relativeVirtualAddressEnabled: usize, - put_relativeVirtualAddressEnabled: usize, + pub addressMapEnabled: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub SetaddressMapEnabled: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub relativeVirtualAddressEnabled: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub SetrelativeVirtualAddressEnabled: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub imageAlign: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub SetimageAlign: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT, - set_imageHeaders: usize, - set_addressMap: usize, + pub set_imageHeaders: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const u8, + windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub set_addressMap: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const DiaAddressMapEntry, + windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, } pub trait IDiaAddressMap_Impl: windows_core::IUnknownImpl { + fn addressMapEnabled(&self) -> windows_core::Result; + fn SetaddressMapEnabled( + &self, + newval: windows::Win32::Foundation::BOOL, + ) -> windows_core::Result<()>; + fn relativeVirtualAddressEnabled( + &self, + ) -> windows_core::Result; + fn SetrelativeVirtualAddressEnabled( + &self, + newval: windows::Win32::Foundation::BOOL, + ) -> windows_core::Result<()>; fn imageAlign(&self) -> windows_core::Result; fn SetimageAlign(&self, newval: u32) -> windows_core::Result<()>; + fn set_imageHeaders( + &self, + cbdata: u32, + pbdata: *const u8, + originalheaders: windows::Win32::Foundation::BOOL, + ) -> windows_core::Result<()>; + fn set_addressMap( + &self, + cdata: u32, + pdata: *const DiaAddressMapEntry, + imagetosymbols: windows::Win32::Foundation::BOOL, + ) -> windows_core::Result<()>; } impl IDiaAddressMap_Vtbl { pub const fn new() -> Self { + unsafe extern "system" fn addressMapEnabled< + Identity: IDiaAddressMap_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaAddressMap_Impl::addressMapEnabled(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn SetaddressMapEnabled< + Identity: IDiaAddressMap_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + newval: windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IDiaAddressMap_Impl::SetaddressMapEnabled(this, core::mem::transmute_copy(&newval)) + .into() + } + } + unsafe extern "system" fn relativeVirtualAddressEnabled< + Identity: IDiaAddressMap_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaAddressMap_Impl::relativeVirtualAddressEnabled(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn SetrelativeVirtualAddressEnabled< + Identity: IDiaAddressMap_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + newval: windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IDiaAddressMap_Impl::SetrelativeVirtualAddressEnabled( + this, + core::mem::transmute_copy(&newval), + ) + .into() + } + } unsafe extern "system" fn imageAlign( this: *mut core::ffi::c_void, pretval: *mut u32, @@ -3710,16 +3900,58 @@ impl IDiaAddressMap_Vtbl { IDiaAddressMap_Impl::SetimageAlign(this, core::mem::transmute_copy(&newval)).into() } } + unsafe extern "system" fn set_imageHeaders< + Identity: IDiaAddressMap_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + cbdata: u32, + pbdata: *const u8, + originalheaders: windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IDiaAddressMap_Impl::set_imageHeaders( + this, + core::mem::transmute_copy(&cbdata), + core::mem::transmute_copy(&pbdata), + core::mem::transmute_copy(&originalheaders), + ) + .into() + } + } + unsafe extern "system" fn set_addressMap< + Identity: IDiaAddressMap_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + cdata: u32, + pdata: *const DiaAddressMapEntry, + imagetosymbols: windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IDiaAddressMap_Impl::set_addressMap( + this, + core::mem::transmute_copy(&cdata), + core::mem::transmute_copy(&pdata), + core::mem::transmute_copy(&imagetosymbols), + ) + .into() + } + } Self { base__: windows_core::IUnknown_Vtbl::new::(), - get_addressMapEnabled: 0, - put_addressMapEnabled: 0, - get_relativeVirtualAddressEnabled: 0, - put_relativeVirtualAddressEnabled: 0, + addressMapEnabled: addressMapEnabled::, + SetaddressMapEnabled: SetaddressMapEnabled::, + relativeVirtualAddressEnabled: relativeVirtualAddressEnabled::, + SetrelativeVirtualAddressEnabled: SetrelativeVirtualAddressEnabled::, imageAlign: imageAlign::, SetimageAlign: SetimageAlign::, - set_imageHeaders: 0, - set_addressMap: 0, + set_imageHeaders: set_imageHeaders::, + set_addressMap: set_addressMap::, } } pub fn matches(iid: &windows_core::GUID) -> bool { @@ -3798,6 +4030,18 @@ impl IDiaDataSource { .ok() } } + pub unsafe fn loadDataFromIStream(&self, pistream: P0) -> windows_core::Result<()> + where + P0: windows_core::Param, + { + unsafe { + (windows_core::Interface::vtable(self).loadDataFromIStream)( + windows_core::Interface::as_raw(self), + pistream.param().abi(), + ) + .ok() + } + } pub unsafe fn openSession(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); @@ -3887,7 +4131,10 @@ pub struct IDiaDataSource_Vtbl { windows_core::PCWSTR, *mut core::ffi::c_void, ) -> windows_core::HRESULT, - loadDataFromIStream: usize, + pub loadDataFromIStream: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut core::ffi::c_void, + ) -> windows_core::HRESULT, pub openSession: unsafe extern "system" fn( *mut core::ffi::c_void, *mut *mut core::ffi::c_void, @@ -3928,6 +4175,10 @@ pub trait IDiaDataSource_Impl: windows_core::IUnknownImpl { searchpath: &windows_core::PCWSTR, pcallback: windows_core::Ref<'_, windows_core::IUnknown>, ) -> windows_core::Result<()>; + fn loadDataFromIStream( + &self, + pistream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>, + ) -> windows_core::Result<()>; fn openSession(&self) -> windows_core::Result; fn loadDataFromCodeViewInfo( &self, @@ -4024,6 +4275,20 @@ impl IDiaDataSource_Vtbl { .into() } } + unsafe extern "system" fn loadDataFromIStream< + Identity: IDiaDataSource_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pistream: *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IDiaDataSource_Impl::loadDataFromIStream(this, core::mem::transmute_copy(&pistream)) + .into() + } + } unsafe extern "system" fn openSession< Identity: IDiaDataSource_Impl, const OFFSET: isize, @@ -4105,7 +4370,7 @@ impl IDiaDataSource_Vtbl { loadDataFromPdb: loadDataFromPdb::, loadAndValidateDataFromPdb: loadAndValidateDataFromPdb::, loadDataForExe: loadDataForExe::, - loadDataFromIStream: 0, + loadDataFromIStream: loadDataFromIStream::, openSession: openSession::, loadDataFromCodeViewInfo: loadDataFromCodeViewInfo::, loadDataFromMiscInfo: loadDataFromMiscInfo::, @@ -4129,6 +4394,86 @@ impl core::ops::Deref for IDiaDataSourceEx { } windows_core::imp::interface_hierarchy!(IDiaDataSourceEx, windows_core::IUnknown, IDiaDataSource); impl IDiaDataSourceEx { + pub unsafe fn loadDataFromPdbEx( + &self, + pdbpath: P0, + fpdbprefetching: bool, + ) -> windows_core::Result<()> + where + P0: windows_core::Param, + { + unsafe { + (windows_core::Interface::vtable(self).loadDataFromPdbEx)( + windows_core::Interface::as_raw(self), + pdbpath.param().abi(), + fpdbprefetching.into(), + ) + .ok() + } + } + pub unsafe fn loadAndValidateDataFromPdbEx( + &self, + pdbpath: P0, + pcsig70: *const windows_core::GUID, + sig: u32, + age: u32, + fpdbprefetching: bool, + ) -> windows_core::Result<()> + where + P0: windows_core::Param, + { + unsafe { + (windows_core::Interface::vtable(self).loadAndValidateDataFromPdbEx)( + windows_core::Interface::as_raw(self), + pdbpath.param().abi(), + pcsig70, + sig, + age, + fpdbprefetching.into(), + ) + .ok() + } + } + pub unsafe fn loadDataForExeEx( + &self, + executable: P0, + searchpath: P1, + pcallback: P2, + fpdbprefetching: bool, + ) -> windows_core::Result<()> + where + P0: windows_core::Param, + P1: windows_core::Param, + P2: windows_core::Param, + { + unsafe { + (windows_core::Interface::vtable(self).loadDataForExeEx)( + windows_core::Interface::as_raw(self), + executable.param().abi(), + searchpath.param().abi(), + pcallback.param().abi(), + fpdbprefetching.into(), + ) + .ok() + } + } + pub unsafe fn loadDataFromIStreamEx( + &self, + pistream: P0, + fpdbprefetching: bool, + ) -> windows_core::Result<()> + where + P0: windows_core::Param, + { + unsafe { + (windows_core::Interface::vtable(self).loadDataFromIStreamEx)( + windows_core::Interface::as_raw(self), + pistream.param().abi(), + fpdbprefetching.into(), + ) + .ok() + } + } pub unsafe fn getStreamSize(&self, stream: P0) -> windows_core::Result where P0: windows_core::Param, @@ -4179,22 +4524,66 @@ impl IDiaDataSourceEx { .ok() } } -} -#[repr(C)] -pub struct IDiaDataSourceEx_Vtbl { - pub base__: IDiaDataSource_Vtbl, - loadDataFromPdbEx: usize, - loadAndValidateDataFromPdbEx: usize, - loadDataForExeEx: usize, - loadDataFromIStreamEx: usize, - pub getStreamSize: unsafe extern "system" fn( - *mut core::ffi::c_void, - windows_core::PCWSTR, - *mut u64, - ) -> windows_core::HRESULT, - pub getStreamRawData: unsafe extern "system" fn( - *mut core::ffi::c_void, - windows_core::PCWSTR, + pub unsafe fn ValidatePdb( + &self, + pdbpath: P0, + pcsig70: *const windows_core::GUID, + sig: u32, + age: u32, + ) -> windows_core::Result + where + P0: windows_core::Param, + { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).ValidatePdb)( + windows_core::Interface::as_raw(self), + pdbpath.param().abi(), + pcsig70, + sig, + age, + &mut result__, + ) + .map(|| result__) + } + } +} +#[repr(C)] +pub struct IDiaDataSourceEx_Vtbl { + pub base__: IDiaDataSource_Vtbl, + pub loadDataFromPdbEx: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows_core::PCWSTR, + windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub loadAndValidateDataFromPdbEx: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows_core::PCWSTR, + *const windows_core::GUID, + u32, + u32, + windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub loadDataForExeEx: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows_core::PCWSTR, + windows_core::PCWSTR, + *mut core::ffi::c_void, + windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub loadDataFromIStreamEx: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut core::ffi::c_void, + windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub getStreamSize: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows_core::PCWSTR, + *mut u64, + ) -> windows_core::HRESULT, + pub getStreamRawData: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows_core::PCWSTR, u64, u64, *mut u64, @@ -4205,9 +4594,41 @@ pub struct IDiaDataSourceEx_Vtbl { *const core::ffi::c_void, PFNMINIPDBERRORCALLBACK2, ) -> windows_core::HRESULT, - ValidatePdb: usize, + pub ValidatePdb: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows_core::PCWSTR, + *const windows_core::GUID, + u32, + u32, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, } pub trait IDiaDataSourceEx_Impl: IDiaDataSource_Impl { + fn loadDataFromPdbEx( + &self, + pdbpath: &windows_core::PCWSTR, + fpdbprefetching: windows::Win32::Foundation::BOOL, + ) -> windows_core::Result<()>; + fn loadAndValidateDataFromPdbEx( + &self, + pdbpath: &windows_core::PCWSTR, + pcsig70: *const windows_core::GUID, + sig: u32, + age: u32, + fpdbprefetching: windows::Win32::Foundation::BOOL, + ) -> windows_core::Result<()>; + fn loadDataForExeEx( + &self, + executable: &windows_core::PCWSTR, + searchpath: &windows_core::PCWSTR, + pcallback: windows_core::Ref<'_, windows_core::IUnknown>, + fpdbprefetching: windows::Win32::Foundation::BOOL, + ) -> windows_core::Result<()>; + fn loadDataFromIStreamEx( + &self, + pistream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>, + fpdbprefetching: windows::Win32::Foundation::BOOL, + ) -> windows_core::Result<()>; fn getStreamSize(&self, stream: &windows_core::PCWSTR) -> windows_core::Result; fn getStreamRawData( &self, @@ -4222,9 +4643,102 @@ pub trait IDiaDataSourceEx_Impl: IDiaDataSource_Impl { pvcontext: *const core::ffi::c_void, pfn: PFNMINIPDBERRORCALLBACK2, ) -> windows_core::Result<()>; + fn ValidatePdb( + &self, + pdbpath: &windows_core::PCWSTR, + pcsig70: *const windows_core::GUID, + sig: u32, + age: u32, + ) -> windows_core::Result; } impl IDiaDataSourceEx_Vtbl { pub const fn new() -> Self { + unsafe extern "system" fn loadDataFromPdbEx< + Identity: IDiaDataSourceEx_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pdbpath: windows_core::PCWSTR, + fpdbprefetching: windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IDiaDataSourceEx_Impl::loadDataFromPdbEx( + this, + core::mem::transmute(&pdbpath), + core::mem::transmute_copy(&fpdbprefetching), + ) + .into() + } + } + unsafe extern "system" fn loadAndValidateDataFromPdbEx< + Identity: IDiaDataSourceEx_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pdbpath: windows_core::PCWSTR, + pcsig70: *const windows_core::GUID, + sig: u32, + age: u32, + fpdbprefetching: windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IDiaDataSourceEx_Impl::loadAndValidateDataFromPdbEx( + this, + core::mem::transmute(&pdbpath), + core::mem::transmute_copy(&pcsig70), + core::mem::transmute_copy(&sig), + core::mem::transmute_copy(&age), + core::mem::transmute_copy(&fpdbprefetching), + ) + .into() + } + } + unsafe extern "system" fn loadDataForExeEx< + Identity: IDiaDataSourceEx_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + executable: windows_core::PCWSTR, + searchpath: windows_core::PCWSTR, + pcallback: *mut core::ffi::c_void, + fpdbprefetching: windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IDiaDataSourceEx_Impl::loadDataForExeEx( + this, + core::mem::transmute(&executable), + core::mem::transmute(&searchpath), + core::mem::transmute_copy(&pcallback), + core::mem::transmute_copy(&fpdbprefetching), + ) + .into() + } + } + unsafe extern "system" fn loadDataFromIStreamEx< + Identity: IDiaDataSourceEx_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pistream: *mut core::ffi::c_void, + fpdbprefetching: windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IDiaDataSourceEx_Impl::loadDataFromIStreamEx( + this, + core::mem::transmute_copy(&pistream), + core::mem::transmute_copy(&fpdbprefetching), + ) + .into() + } + } unsafe extern "system" fn getStreamSize< Identity: IDiaDataSourceEx_Impl, const OFFSET: isize, @@ -4289,16 +4803,45 @@ impl IDiaDataSourceEx_Vtbl { .into() } } + unsafe extern "system" fn ValidatePdb< + Identity: IDiaDataSourceEx_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pdbpath: windows_core::PCWSTR, + pcsig70: *const windows_core::GUID, + sig: u32, + age: u32, + pfstripped: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaDataSourceEx_Impl::ValidatePdb( + this, + core::mem::transmute(&pdbpath), + core::mem::transmute_copy(&pcsig70), + core::mem::transmute_copy(&sig), + core::mem::transmute_copy(&age), + ) { + Ok(ok__) => { + pfstripped.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } Self { base__: IDiaDataSource_Vtbl::new::(), - loadDataFromPdbEx: 0, - loadAndValidateDataFromPdbEx: 0, - loadDataForExeEx: 0, - loadDataFromIStreamEx: 0, + loadDataFromPdbEx: loadDataFromPdbEx::, + loadAndValidateDataFromPdbEx: loadAndValidateDataFromPdbEx::, + loadDataForExeEx: loadDataForExeEx::, + loadDataFromIStreamEx: loadDataFromIStreamEx::, getStreamSize: getStreamSize::, getStreamRawData: getStreamRawData::, setPfnMiniPDBErrorCallback2: setPfnMiniPDBErrorCallback2::, - ValidatePdb: 0, + ValidatePdb: ValidatePdb::, } } pub fn matches(iid: &windows_core::GUID) -> bool { @@ -4658,6 +5201,20 @@ impl IDiaEnumDebugStreams { .map(|| result__) } } + pub unsafe fn Item( + &self, + index: &windows::Win32::System::Variant::VARIANT, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).Item)( + windows_core::Interface::as_raw(self), + core::mem::transmute_copy(index), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } pub unsafe fn Next( &self, celt: u32, @@ -4708,7 +5265,11 @@ pub struct IDiaEnumDebugStreams_Vtbl { *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT, pub Count: unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT, - Item: usize, + pub Item: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows::Win32::System::Variant::VARIANT, + *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT, pub Next: unsafe extern "system" fn( *mut core::ffi::c_void, u32, @@ -4725,6 +5286,10 @@ pub struct IDiaEnumDebugStreams_Vtbl { pub trait IDiaEnumDebugStreams_Impl: windows_core::IUnknownImpl { fn _NewEnum(&self) -> windows_core::Result; fn Count(&self) -> windows_core::Result; + fn Item( + &self, + index: &windows::Win32::System::Variant::VARIANT, + ) -> windows_core::Result; fn Next( &self, celt: u32, @@ -4775,6 +5340,23 @@ impl IDiaEnumDebugStreams_Vtbl { } } } + unsafe extern "system" fn Item( + this: *mut core::ffi::c_void, + index: windows::Win32::System::Variant::VARIANT, + stream: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaEnumDebugStreams_Impl::Item(this, core::mem::transmute(&index)) { + Ok(ok__) => { + stream.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } unsafe extern "system" fn Next( this: *mut core::ffi::c_void, celt: u32, @@ -4838,7 +5420,7 @@ impl IDiaEnumDebugStreams_Vtbl { base__: windows_core::IUnknown_Vtbl::new::(), _NewEnum: _NewEnum::, Count: Count::, - Item: 0, + Item: Item::, Next: Next::, Skip: Skip::, Reset: Reset::, @@ -7614,71 +8196,349 @@ windows_core::imp::interface_hierarchy!( windows_core::IUnknown, IDiaEnumSymbolsByAddr ); -#[repr(C)] -pub struct IDiaEnumSymbolsByAddr2_Vtbl { - pub base__: IDiaEnumSymbolsByAddr_Vtbl, - symbolByAddrEx: usize, - symbolByRVAEx: usize, - symbolByVAEx: usize, - NextEx: usize, - PrevEx: usize, -} -pub trait IDiaEnumSymbolsByAddr2_Impl: IDiaEnumSymbolsByAddr_Impl {} -impl IDiaEnumSymbolsByAddr2_Vtbl { - pub const fn new() -> Self { - Self { - base__: IDiaEnumSymbolsByAddr_Vtbl::new::(), - symbolByAddrEx: 0, - symbolByRVAEx: 0, - symbolByVAEx: 0, - NextEx: 0, - PrevEx: 0, +impl IDiaEnumSymbolsByAddr2 { + pub unsafe fn symbolByAddrEx( + &self, + fpromoteblocksym: bool, + isect: u32, + offset: u32, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).symbolByAddrEx)( + windows_core::Interface::as_raw(self), + fpromoteblocksym.into(), + isect, + offset, + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) } } - pub fn matches(iid: &windows_core::GUID) -> bool { - iid == &::IID - || iid == &::IID - } -} -impl windows_core::RuntimeName for IDiaEnumSymbolsByAddr2 {} -windows_core::imp::define_interface!( - IDiaEnumTables, - IDiaEnumTables_Vtbl, - 0xc65c2b0a_1150_4d7a_afcc_e05bf3dee81e -); -windows_core::imp::interface_hierarchy!(IDiaEnumTables, windows_core::IUnknown); -impl IDiaEnumTables { - pub unsafe fn _NewEnum(&self) -> windows_core::Result { + pub unsafe fn symbolByRVAEx( + &self, + fpromoteblocksym: bool, + relativevirtualaddress: u32, + ) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self)._NewEnum)( + (windows_core::Interface::vtable(self).symbolByRVAEx)( windows_core::Interface::as_raw(self), + fpromoteblocksym.into(), + relativevirtualaddress, &mut result__, ) .and_then(|| windows_core::Type::from_abi(result__)) } } - pub unsafe fn Count(&self) -> windows_core::Result { + pub unsafe fn symbolByVAEx( + &self, + fpromoteblocksym: bool, + virtualaddress: u64, + ) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).Count)( + (windows_core::Interface::vtable(self).symbolByVAEx)( windows_core::Interface::as_raw(self), + fpromoteblocksym.into(), + virtualaddress, &mut result__, ) - .map(|| result__) + .and_then(|| windows_core::Type::from_abi(result__)) } } - pub unsafe fn Next( + pub unsafe fn NextEx( &self, - celt: u32, - rgelt: *mut Option, + fpromoteblocksym: bool, + rgelt: &mut [Option], pceltfetched: *mut u32, - ) -> windows_core::Result<()> { + ) -> windows_core::HRESULT { unsafe { - (windows_core::Interface::vtable(self).Next)( + (windows_core::Interface::vtable(self).NextEx)( windows_core::Interface::as_raw(self), - celt, - core::mem::transmute(rgelt), + fpromoteblocksym.into(), + rgelt.len().try_into().unwrap(), + core::mem::transmute(rgelt.as_ptr()), + pceltfetched as _, + ) + } + } + pub unsafe fn PrevEx( + &self, + fpromoteblocksym: bool, + rgelt: &mut [Option], + pceltfetched: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + (windows_core::Interface::vtable(self).PrevEx)( + windows_core::Interface::as_raw(self), + fpromoteblocksym.into(), + rgelt.len().try_into().unwrap(), + core::mem::transmute(rgelt.as_ptr()), + pceltfetched as _, + ) + } + } +} +#[repr(C)] +pub struct IDiaEnumSymbolsByAddr2_Vtbl { + pub base__: IDiaEnumSymbolsByAddr_Vtbl, + pub symbolByAddrEx: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows::Win32::Foundation::BOOL, + u32, + u32, + *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub symbolByRVAEx: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows::Win32::Foundation::BOOL, + u32, + *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub symbolByVAEx: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows::Win32::Foundation::BOOL, + u64, + *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub NextEx: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows::Win32::Foundation::BOOL, + u32, + *mut *mut core::ffi::c_void, + *mut u32, + ) -> windows_core::HRESULT, + pub PrevEx: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows::Win32::Foundation::BOOL, + u32, + *mut *mut core::ffi::c_void, + *mut u32, + ) -> windows_core::HRESULT, +} +pub trait IDiaEnumSymbolsByAddr2_Impl: IDiaEnumSymbolsByAddr_Impl { + fn symbolByAddrEx( + &self, + fpromoteblocksym: windows::Win32::Foundation::BOOL, + isect: u32, + offset: u32, + ) -> windows_core::Result; + fn symbolByRVAEx( + &self, + fpromoteblocksym: windows::Win32::Foundation::BOOL, + relativevirtualaddress: u32, + ) -> windows_core::Result; + fn symbolByVAEx( + &self, + fpromoteblocksym: windows::Win32::Foundation::BOOL, + virtualaddress: u64, + ) -> windows_core::Result; + fn NextEx( + &self, + fpromoteblocksym: windows::Win32::Foundation::BOOL, + celt: u32, + rgelt: windows_core::OutRef<'_, IDiaSymbol>, + pceltfetched: *mut u32, + ) -> windows_core::HRESULT; + fn PrevEx( + &self, + fpromoteblocksym: windows::Win32::Foundation::BOOL, + celt: u32, + rgelt: windows_core::OutRef<'_, IDiaSymbol>, + pceltfetched: *mut u32, + ) -> windows_core::HRESULT; +} +impl IDiaEnumSymbolsByAddr2_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn symbolByAddrEx< + Identity: IDiaEnumSymbolsByAddr2_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + fpromoteblocksym: windows::Win32::Foundation::BOOL, + isect: u32, + offset: u32, + ppsymbol: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaEnumSymbolsByAddr2_Impl::symbolByAddrEx( + this, + core::mem::transmute_copy(&fpromoteblocksym), + core::mem::transmute_copy(&isect), + core::mem::transmute_copy(&offset), + ) { + Ok(ok__) => { + ppsymbol.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn symbolByRVAEx< + Identity: IDiaEnumSymbolsByAddr2_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + fpromoteblocksym: windows::Win32::Foundation::BOOL, + relativevirtualaddress: u32, + ppsymbol: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaEnumSymbolsByAddr2_Impl::symbolByRVAEx( + this, + core::mem::transmute_copy(&fpromoteblocksym), + core::mem::transmute_copy(&relativevirtualaddress), + ) { + Ok(ok__) => { + ppsymbol.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn symbolByVAEx< + Identity: IDiaEnumSymbolsByAddr2_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + fpromoteblocksym: windows::Win32::Foundation::BOOL, + virtualaddress: u64, + ppsymbol: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaEnumSymbolsByAddr2_Impl::symbolByVAEx( + this, + core::mem::transmute_copy(&fpromoteblocksym), + core::mem::transmute_copy(&virtualaddress), + ) { + Ok(ok__) => { + ppsymbol.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn NextEx< + Identity: IDiaEnumSymbolsByAddr2_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + fpromoteblocksym: windows::Win32::Foundation::BOOL, + celt: u32, + rgelt: *mut *mut core::ffi::c_void, + pceltfetched: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IDiaEnumSymbolsByAddr2_Impl::NextEx( + this, + core::mem::transmute_copy(&fpromoteblocksym), + core::mem::transmute_copy(&celt), + core::mem::transmute_copy(&rgelt), + core::mem::transmute_copy(&pceltfetched), + ) + } + } + unsafe extern "system" fn PrevEx< + Identity: IDiaEnumSymbolsByAddr2_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + fpromoteblocksym: windows::Win32::Foundation::BOOL, + celt: u32, + rgelt: *mut *mut core::ffi::c_void, + pceltfetched: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IDiaEnumSymbolsByAddr2_Impl::PrevEx( + this, + core::mem::transmute_copy(&fpromoteblocksym), + core::mem::transmute_copy(&celt), + core::mem::transmute_copy(&rgelt), + core::mem::transmute_copy(&pceltfetched), + ) + } + } + Self { + base__: IDiaEnumSymbolsByAddr_Vtbl::new::(), + symbolByAddrEx: symbolByAddrEx::, + symbolByRVAEx: symbolByRVAEx::, + symbolByVAEx: symbolByVAEx::, + NextEx: NextEx::, + PrevEx: PrevEx::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + || iid == &::IID + } +} +impl windows_core::RuntimeName for IDiaEnumSymbolsByAddr2 {} +windows_core::imp::define_interface!( + IDiaEnumTables, + IDiaEnumTables_Vtbl, + 0xc65c2b0a_1150_4d7a_afcc_e05bf3dee81e +); +windows_core::imp::interface_hierarchy!(IDiaEnumTables, windows_core::IUnknown); +impl IDiaEnumTables { + pub unsafe fn _NewEnum(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self)._NewEnum)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn Count(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).Count)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn Item( + &self, + index: &windows::Win32::System::Variant::VARIANT, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).Item)( + windows_core::Interface::as_raw(self), + core::mem::transmute_copy(index), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn Next( + &self, + celt: u32, + rgelt: *mut Option, + pceltfetched: *mut u32, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).Next)( + windows_core::Interface::as_raw(self), + celt, + core::mem::transmute(rgelt), pceltfetched as _, ) .ok() @@ -7718,7 +8578,11 @@ pub struct IDiaEnumTables_Vtbl { *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT, pub Count: unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT, - Item: usize, + pub Item: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows::Win32::System::Variant::VARIANT, + *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT, pub Next: unsafe extern "system" fn( *mut core::ffi::c_void, u32, @@ -7735,6 +8599,10 @@ pub struct IDiaEnumTables_Vtbl { pub trait IDiaEnumTables_Impl: windows_core::IUnknownImpl { fn _NewEnum(&self) -> windows_core::Result; fn Count(&self) -> windows_core::Result; + fn Item( + &self, + index: &windows::Win32::System::Variant::VARIANT, + ) -> windows_core::Result; fn Next( &self, celt: u32, @@ -7779,6 +8647,23 @@ impl IDiaEnumTables_Vtbl { } } } + unsafe extern "system" fn Item( + this: *mut core::ffi::c_void, + index: windows::Win32::System::Variant::VARIANT, + table: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaEnumTables_Impl::Item(this, core::mem::transmute(&index)) { + Ok(ok__) => { + table.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } unsafe extern "system" fn Next( this: *mut core::ffi::c_void, celt: u32, @@ -7836,7 +8721,7 @@ impl IDiaEnumTables_Vtbl { base__: windows_core::IUnknown_Vtbl::new::(), _NewEnum: _NewEnum::, Count: Count::, - Item: 0, + Item: Item::, Next: Next::, Skip: Skip::, Reset: Reset::, @@ -7965,34 +8850,80 @@ impl IDiaFrameData { .map(|| core::mem::transmute(result__)) } } - pub unsafe fn r#type(&self) -> windows_core::Result { + pub unsafe fn systemExceptionHandling( + &self, + ) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).r#type)( + (windows_core::Interface::vtable(self).systemExceptionHandling)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn functionParent(&self) -> windows_core::Result { + pub unsafe fn cplusplusExceptionHandling( + &self, + ) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).functionParent)( + (windows_core::Interface::vtable(self).cplusplusExceptionHandling)( windows_core::Interface::as_raw(self), &mut result__, ) - .and_then(|| windows_core::Type::from_abi(result__)) + .map(|| result__) } } - pub unsafe fn execute(&self, frame: P0) -> windows_core::Result<()> - where - P0: windows_core::Param, - { + pub unsafe fn functionStart(&self) -> windows_core::Result { unsafe { - (windows_core::Interface::vtable(self).execute)( + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).functionStart)( windows_core::Interface::as_raw(self), - frame.param().abi(), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn allocatesBasePointer( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).allocatesBasePointer)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn r#type(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).r#type)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn functionParent(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).functionParent)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn execute(&self, frame: P0) -> windows_core::Result<()> + where + P0: windows_core::Param, + { + unsafe { + (windows_core::Interface::vtable(self).execute)( + windows_core::Interface::as_raw(self), + frame.param().abi(), ) .ok() } @@ -8025,10 +8956,22 @@ pub struct IDiaFrameData_Vtbl { *mut core::ffi::c_void, *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT, - get_systemExceptionHandling: usize, - get_cplusplusExceptionHandling: usize, - get_functionStart: usize, - get_allocatesBasePointer: usize, + pub systemExceptionHandling: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub cplusplusExceptionHandling: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub functionStart: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub allocatesBasePointer: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub r#type: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub functionParent: unsafe extern "system" fn( @@ -8052,6 +8995,10 @@ pub trait IDiaFrameData_Impl: windows_core::IUnknownImpl { fn lengthProlog(&self) -> windows_core::Result; fn lengthSavedRegisters(&self) -> windows_core::Result; fn program(&self) -> windows_core::Result; + fn systemExceptionHandling(&self) -> windows_core::Result; + fn cplusplusExceptionHandling(&self) -> windows_core::Result; + fn functionStart(&self) -> windows_core::Result; + fn allocatesBasePointer(&self) -> windows_core::Result; fn r#type(&self) -> windows_core::Result; fn functionParent(&self) -> windows_core::Result; fn execute(&self, frame: windows_core::Ref<'_, IDiaStackWalkFrame>) @@ -8259,6 +9206,82 @@ impl IDiaFrameData_Vtbl { } } } + unsafe extern "system" fn systemExceptionHandling< + Identity: IDiaFrameData_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaFrameData_Impl::systemExceptionHandling(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn cplusplusExceptionHandling< + Identity: IDiaFrameData_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaFrameData_Impl::cplusplusExceptionHandling(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn functionStart< + Identity: IDiaFrameData_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaFrameData_Impl::functionStart(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn allocatesBasePointer< + Identity: IDiaFrameData_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaFrameData_Impl::allocatesBasePointer(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } unsafe extern "system" fn r#type( this: *mut core::ffi::c_void, pretval: *mut u32, @@ -8317,10 +9340,10 @@ impl IDiaFrameData_Vtbl { lengthProlog: lengthProlog::, lengthSavedRegisters: lengthSavedRegisters::, program: program::, - get_systemExceptionHandling: 0, - get_cplusplusExceptionHandling: 0, - get_functionStart: 0, - get_allocatesBasePointer: 0, + systemExceptionHandling: systemExceptionHandling::, + cplusplusExceptionHandling: cplusplusExceptionHandling::, + functionStart: functionStart::, + allocatesBasePointer: allocatesBasePointer::, r#type: r#type::, functionParent: functionParent::, execute: execute::, @@ -8760,6 +9783,18 @@ impl IDiaInputAssemblyFile { .map(|| result__) } } + pub unsafe fn pdbAvailableAtILMerge( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).pdbAvailableAtILMerge)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } pub unsafe fn fileName(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); @@ -8794,7 +9829,10 @@ pub struct IDiaInputAssemblyFile_Vtbl { pub index: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub timestamp: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - get_pdbAvailableAtILMerge: usize, + pub pdbAvailableAtILMerge: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub fileName: unsafe extern "system" fn( *mut core::ffi::c_void, *mut *mut core::ffi::c_void, @@ -8810,6 +9848,7 @@ pub trait IDiaInputAssemblyFile_Impl: windows_core::IUnknownImpl { fn uniqueId(&self) -> windows_core::Result; fn index(&self) -> windows_core::Result; fn timestamp(&self) -> windows_core::Result; + fn pdbAvailableAtILMerge(&self) -> windows_core::Result; fn fileName(&self) -> windows_core::Result; fn get_version( &self, @@ -8877,6 +9916,25 @@ impl IDiaInputAssemblyFile_Vtbl { } } } + unsafe extern "system" fn pdbAvailableAtILMerge< + Identity: IDiaInputAssemblyFile_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaInputAssemblyFile_Impl::pdbAvailableAtILMerge(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } unsafe extern "system" fn fileName< Identity: IDiaInputAssemblyFile_Impl, const OFFSET: isize, @@ -8922,7 +9980,7 @@ impl IDiaInputAssemblyFile_Vtbl { uniqueId: uniqueId::, index: index::, timestamp: timestamp::, - get_pdbAvailableAtILMerge: 0, + pdbAvailableAtILMerge: pdbAvailableAtILMerge::, fileName: fileName::, get_version: get_version::, } @@ -9059,6 +10117,16 @@ impl IDiaLineNumber { .map(|| result__) } } + pub unsafe fn statement(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).statement)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } pub unsafe fn compilandId(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); @@ -9101,7 +10169,10 @@ pub struct IDiaLineNumber_Vtbl { unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub sourceFileId: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - get_statement: usize, + pub statement: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub compilandId: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, } @@ -9118,6 +10189,7 @@ pub trait IDiaLineNumber_Impl: windows_core::IUnknownImpl { fn virtualAddress(&self) -> windows_core::Result; fn length(&self) -> windows_core::Result; fn sourceFileId(&self) -> windows_core::Result; + fn statement(&self) -> windows_core::Result; fn compilandId(&self) -> windows_core::Result; } impl IDiaLineNumber_Vtbl { @@ -9338,6 +10410,22 @@ impl IDiaLineNumber_Vtbl { } } } + unsafe extern "system" fn statement( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaLineNumber_Impl::statement(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } unsafe extern "system" fn compilandId< Identity: IDiaLineNumber_Impl, const OFFSET: isize, @@ -9371,7 +10459,7 @@ impl IDiaLineNumber_Vtbl { virtualAddress: virtualAddress::, length: length::, sourceFileId: sourceFileId::, - get_statement: 0, + statement: statement::, compilandId: compilandId::, } } @@ -9387,6 +10475,21 @@ windows_core::imp::define_interface!( ); windows_core::imp::interface_hierarchy!(IDiaLoadCallback, windows_core::IUnknown); impl IDiaLoadCallback { + pub unsafe fn NotifyDebugDir( + &self, + fexecutable: bool, + pbdata: &[u8], + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).NotifyDebugDir)( + windows_core::Interface::as_raw(self), + fexecutable.into(), + pbdata.len().try_into().unwrap(), + core::mem::transmute(pbdata.as_ptr()), + ) + .ok() + } + } pub unsafe fn NotifyOpenDBG( &self, dbgpath: P0, @@ -9441,7 +10544,12 @@ impl IDiaLoadCallback { #[repr(C)] pub struct IDiaLoadCallback_Vtbl { pub base__: windows_core::IUnknown_Vtbl, - NotifyDebugDir: usize, + pub NotifyDebugDir: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows::Win32::Foundation::BOOL, + u32, + *const u8, + ) -> windows_core::HRESULT, pub NotifyOpenDBG: unsafe extern "system" fn( *mut core::ffi::c_void, windows_core::PCWSTR, @@ -9458,6 +10566,12 @@ pub struct IDiaLoadCallback_Vtbl { unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, } pub trait IDiaLoadCallback_Impl: windows_core::IUnknownImpl { + fn NotifyDebugDir( + &self, + fexecutable: windows::Win32::Foundation::BOOL, + cbdata: u32, + pbdata: *const u8, + ) -> windows_core::Result<()>; fn NotifyOpenDBG( &self, dbgpath: &windows_core::PCWSTR, @@ -9473,6 +10587,27 @@ pub trait IDiaLoadCallback_Impl: windows_core::IUnknownImpl { } impl IDiaLoadCallback_Vtbl { pub const fn new() -> Self { + unsafe extern "system" fn NotifyDebugDir< + Identity: IDiaLoadCallback_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + fexecutable: windows::Win32::Foundation::BOOL, + cbdata: u32, + pbdata: *const u8, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IDiaLoadCallback_Impl::NotifyDebugDir( + this, + core::mem::transmute_copy(&fexecutable), + core::mem::transmute_copy(&cbdata), + core::mem::transmute_copy(&pbdata), + ) + .into() + } + } unsafe extern "system" fn NotifyOpenDBG< Identity: IDiaLoadCallback_Impl, const OFFSET: isize, @@ -9537,7 +10672,7 @@ impl IDiaLoadCallback_Vtbl { } Self { base__: windows_core::IUnknown_Vtbl::new::(), - NotifyDebugDir: 0, + NotifyDebugDir: NotifyDebugDir::, NotifyOpenDBG: NotifyOpenDBG::, NotifyOpenPDB: NotifyOpenPDB::, RestrictRegistryAccess: RestrictRegistryAccess::, @@ -9688,6 +10823,22 @@ windows_core::imp::define_interface!( ); windows_core::imp::interface_hierarchy!(IDiaPropertyStorage, windows_core::IUnknown); impl IDiaPropertyStorage { + pub unsafe fn ReadMultiple( + &self, + cpspec: u32, + rgpspec: *const windows::Win32::System::Com::StructuredStorage::PROPSPEC, + rgvar: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).ReadMultiple)( + windows_core::Interface::as_raw(self), + cpspec, + rgpspec, + core::mem::transmute(rgvar), + ) + .ok() + } + } pub unsafe fn ReadPropertyNames( &self, cpropid: u32, @@ -9704,6 +10855,19 @@ impl IDiaPropertyStorage { .ok() } } + pub unsafe fn Enum( + &self, + ) -> windows_core::Result + { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).Enum)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } pub unsafe fn ReadDWORD(&self, id: u32) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); @@ -9726,6 +10890,20 @@ impl IDiaPropertyStorage { .map(|| result__) } } + pub unsafe fn ReadBOOL( + &self, + id: u32, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).ReadBOOL)( + windows_core::Interface::as_raw(self), + id, + &mut result__, + ) + .map(|| result__) + } + } pub unsafe fn ReadULONGLONG(&self, id: u32) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); @@ -9752,19 +10930,31 @@ impl IDiaPropertyStorage { #[repr(C)] pub struct IDiaPropertyStorage_Vtbl { pub base__: windows_core::IUnknown_Vtbl, - ReadMultiple: usize, + pub ReadMultiple: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const windows::Win32::System::Com::StructuredStorage::PROPSPEC, + *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT, + ) -> windows_core::HRESULT, pub ReadPropertyNames: unsafe extern "system" fn( *mut core::ffi::c_void, u32, *const u32, *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT, - Enum: usize, + pub Enum: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT, pub ReadDWORD: unsafe extern "system" fn(*mut core::ffi::c_void, u32, *mut u32) -> windows_core::HRESULT, pub ReadLONG: unsafe extern "system" fn(*mut core::ffi::c_void, u32, *mut i32) -> windows_core::HRESULT, - ReadBOOL: usize, + pub ReadBOOL: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub ReadULONGLONG: unsafe extern "system" fn(*mut core::ffi::c_void, u32, *mut u64) -> windows_core::HRESULT, pub ReadBSTR: unsafe extern "system" fn( @@ -9774,19 +10964,50 @@ pub struct IDiaPropertyStorage_Vtbl { ) -> windows_core::HRESULT, } pub trait IDiaPropertyStorage_Impl: windows_core::IUnknownImpl { + fn ReadMultiple( + &self, + cpspec: u32, + rgpspec: *const windows::Win32::System::Com::StructuredStorage::PROPSPEC, + rgvar: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT, + ) -> windows_core::Result<()>; fn ReadPropertyNames( &self, cpropid: u32, rgpropid: *const u32, rglpwstrname: *mut windows_core::BSTR, ) -> windows_core::Result<()>; + fn Enum( + &self, + ) -> windows_core::Result; fn ReadDWORD(&self, id: u32) -> windows_core::Result; fn ReadLONG(&self, id: u32) -> windows_core::Result; + fn ReadBOOL(&self, id: u32) -> windows_core::Result; fn ReadULONGLONG(&self, id: u32) -> windows_core::Result; fn ReadBSTR(&self, id: u32) -> windows_core::Result; } impl IDiaPropertyStorage_Vtbl { pub const fn new() -> Self { + unsafe extern "system" fn ReadMultiple< + Identity: IDiaPropertyStorage_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + cpspec: u32, + rgpspec: *const windows::Win32::System::Com::StructuredStorage::PROPSPEC, + rgvar: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IDiaPropertyStorage_Impl::ReadMultiple( + this, + core::mem::transmute_copy(&cpspec), + core::mem::transmute_copy(&rgpspec), + core::mem::transmute_copy(&rgvar), + ) + .into() + } + } unsafe extern "system" fn ReadPropertyNames< Identity: IDiaPropertyStorage_Impl, const OFFSET: isize, @@ -9808,13 +11029,29 @@ impl IDiaPropertyStorage_Vtbl { .into() } } - unsafe extern "system" fn ReadDWORD< - Identity: IDiaPropertyStorage_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn Enum( this: *mut core::ffi::c_void, - id: u32, - pvalue: *mut u32, + ppenum: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaPropertyStorage_Impl::Enum(this) { + Ok(ok__) => { + ppenum.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn ReadDWORD< + Identity: IDiaPropertyStorage_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + id: u32, + pvalue: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = @@ -9848,6 +11085,26 @@ impl IDiaPropertyStorage_Vtbl { } } } + unsafe extern "system" fn ReadBOOL< + Identity: IDiaPropertyStorage_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + id: u32, + pvalue: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaPropertyStorage_Impl::ReadBOOL(this, core::mem::transmute_copy(&id)) { + Ok(ok__) => { + pvalue.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } unsafe extern "system" fn ReadULONGLONG< Identity: IDiaPropertyStorage_Impl, const OFFSET: isize, @@ -9891,12 +11148,12 @@ impl IDiaPropertyStorage_Vtbl { } Self { base__: windows_core::IUnknown_Vtbl::new::(), - ReadMultiple: 0, + ReadMultiple: ReadMultiple::, ReadPropertyNames: ReadPropertyNames::, - Enum: 0, + Enum: Enum::, ReadDWORD: ReadDWORD::, ReadLONG: ReadLONG::, - ReadBOOL: 0, + ReadBOOL: ReadBOOL::, ReadULONGLONG: ReadULONGLONG::, ReadBSTR: ReadBSTR::, } @@ -10133,6 +11390,128 @@ impl IDiaSectionContrib { .map(|| result__) } } + pub unsafe fn notPaged(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).notPaged)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn code(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).code)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn initializedData(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).initializedData)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn uninitializedData( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).uninitializedData)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn remove(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).remove)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn comdat(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).comdat)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn discardable(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).discardable)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn notCached(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).notCached)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn share(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).share)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn execute(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).execute)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn read(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).read)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn write(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).write)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } pub unsafe fn dataCrc(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); @@ -10163,6 +11542,16 @@ impl IDiaSectionContrib { .map(|| result__) } } + pub unsafe fn code16bit(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).code16bit)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } } #[repr(C)] pub struct IDiaSectionContrib_Vtbl { @@ -10181,25 +11570,64 @@ pub struct IDiaSectionContrib_Vtbl { unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT, pub length: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - get_notPaged: usize, - get_code: usize, - get_initializedData: usize, - get_uninitializedData: usize, - get_remove: usize, - get_comdat: usize, - get_discardable: usize, - get_notCached: usize, - get_share: usize, - get_execute: usize, - get_read: usize, - get_write: usize, + pub notPaged: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub code: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub initializedData: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub uninitializedData: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub remove: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub comdat: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub discardable: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub notCached: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub share: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub execute: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub read: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub write: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub dataCrc: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub relocationsCrc: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub compilandId: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - get_code16bit: usize, + pub code16bit: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, } pub trait IDiaSectionContrib_Impl: windows_core::IUnknownImpl { fn compiland(&self) -> windows_core::Result; @@ -10208,9 +11636,22 @@ pub trait IDiaSectionContrib_Impl: windows_core::IUnknownImpl { fn relativeVirtualAddress(&self) -> windows_core::Result; fn virtualAddress(&self) -> windows_core::Result; fn length(&self) -> windows_core::Result; + fn notPaged(&self) -> windows_core::Result; + fn code(&self) -> windows_core::Result; + fn initializedData(&self) -> windows_core::Result; + fn uninitializedData(&self) -> windows_core::Result; + fn remove(&self) -> windows_core::Result; + fn comdat(&self) -> windows_core::Result; + fn discardable(&self) -> windows_core::Result; + fn notCached(&self) -> windows_core::Result; + fn share(&self) -> windows_core::Result; + fn execute(&self) -> windows_core::Result; + fn read(&self) -> windows_core::Result; + fn write(&self) -> windows_core::Result; fn dataCrc(&self) -> windows_core::Result; fn relocationsCrc(&self) -> windows_core::Result; fn compilandId(&self) -> windows_core::Result; + fn code16bit(&self) -> windows_core::Result; } impl IDiaSectionContrib_Vtbl { pub const fn new() -> Self { @@ -10325,17 +11766,17 @@ impl IDiaSectionContrib_Vtbl { } } } - unsafe extern "system" fn dataCrc< + unsafe extern "system" fn notPaged< Identity: IDiaSectionContrib_Impl, const OFFSET: isize, >( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSectionContrib_Impl::dataCrc(this) { + match IDiaSectionContrib_Impl::notPaged(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -10344,17 +11785,33 @@ impl IDiaSectionContrib_Vtbl { } } } - unsafe extern "system" fn relocationsCrc< + unsafe extern "system" fn code( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSectionContrib_Impl::code(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn initializedData< Identity: IDiaSectionContrib_Impl, const OFFSET: isize, >( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSectionContrib_Impl::relocationsCrc(this) { + match IDiaSectionContrib_Impl::initializedData(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -10363,17 +11820,17 @@ impl IDiaSectionContrib_Vtbl { } } } - unsafe extern "system" fn compilandId< + unsafe extern "system" fn uninitializedData< Identity: IDiaSectionContrib_Impl, const OFFSET: isize, >( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSectionContrib_Impl::compilandId(this) { + match IDiaSectionContrib_Impl::uninitializedData(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -10382,62 +11839,275 @@ impl IDiaSectionContrib_Vtbl { } } } - Self { - base__: windows_core::IUnknown_Vtbl::new::(), - compiland: compiland::, - addressSection: addressSection::, - addressOffset: addressOffset::, - relativeVirtualAddress: relativeVirtualAddress::, - virtualAddress: virtualAddress::, - length: length::, - get_notPaged: 0, - get_code: 0, - get_initializedData: 0, - get_uninitializedData: 0, - get_remove: 0, - get_comdat: 0, - get_discardable: 0, - get_notCached: 0, - get_share: 0, - get_execute: 0, - get_read: 0, - get_write: 0, - dataCrc: dataCrc::, - relocationsCrc: relocationsCrc::, - compilandId: compilandId::, - get_code16bit: 0, + unsafe extern "system" fn remove( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSectionContrib_Impl::remove(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } } - } - pub fn matches(iid: &windows_core::GUID) -> bool { - iid == &::IID - } -} -impl windows_core::RuntimeName for IDiaSectionContrib {} -windows_core::imp::define_interface!( - IDiaSegment, - IDiaSegment_Vtbl, - 0x0775b784_c75b_4449_848b_b7bd3159545b -); -windows_core::imp::interface_hierarchy!(IDiaSegment, windows_core::IUnknown); -impl IDiaSegment { - pub unsafe fn frame(&self) -> windows_core::Result { - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).frame)( - windows_core::Interface::as_raw(self), - &mut result__, - ) - .map(|| result__) + unsafe extern "system" fn comdat( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSectionContrib_Impl::comdat(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } } - } - pub unsafe fn offset(&self) -> windows_core::Result { - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).offset)( - windows_core::Interface::as_raw(self), - &mut result__, - ) - .map(|| result__) + unsafe extern "system" fn discardable< + Identity: IDiaSectionContrib_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSectionContrib_Impl::discardable(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn notCached< + Identity: IDiaSectionContrib_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSectionContrib_Impl::notCached(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn share( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSectionContrib_Impl::share(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn execute< + Identity: IDiaSectionContrib_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSectionContrib_Impl::execute(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn read( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSectionContrib_Impl::read(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn write( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSectionContrib_Impl::write(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn dataCrc< + Identity: IDiaSectionContrib_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSectionContrib_Impl::dataCrc(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn relocationsCrc< + Identity: IDiaSectionContrib_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSectionContrib_Impl::relocationsCrc(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn compilandId< + Identity: IDiaSectionContrib_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSectionContrib_Impl::compilandId(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn code16bit< + Identity: IDiaSectionContrib_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSectionContrib_Impl::code16bit(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + compiland: compiland::, + addressSection: addressSection::, + addressOffset: addressOffset::, + relativeVirtualAddress: relativeVirtualAddress::, + virtualAddress: virtualAddress::, + length: length::, + notPaged: notPaged::, + code: code::, + initializedData: initializedData::, + uninitializedData: uninitializedData::, + remove: remove::, + comdat: comdat::, + discardable: discardable::, + notCached: notCached::, + share: share::, + execute: execute::, + read: read::, + write: write::, + dataCrc: dataCrc::, + relocationsCrc: relocationsCrc::, + compilandId: compilandId::, + code16bit: code16bit::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for IDiaSectionContrib {} +windows_core::imp::define_interface!( + IDiaSegment, + IDiaSegment_Vtbl, + 0x0775b784_c75b_4449_848b_b7bd3159545b +); +windows_core::imp::interface_hierarchy!(IDiaSegment, windows_core::IUnknown); +impl IDiaSegment { + pub unsafe fn frame(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).frame)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn offset(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).offset)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) } } pub unsafe fn length(&self) -> windows_core::Result { @@ -10450,6 +12120,36 @@ impl IDiaSegment { .map(|| result__) } } + pub unsafe fn read(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).read)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn write(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).write)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn execute(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).execute)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } pub unsafe fn addressSection(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); @@ -10489,9 +12189,18 @@ pub struct IDiaSegment_Vtbl { unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub length: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - get_read: usize, - get_write: usize, - get_execute: usize, + pub read: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub write: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub execute: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub addressSection: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub relativeVirtualAddress: @@ -10503,6 +12212,9 @@ pub trait IDiaSegment_Impl: windows_core::IUnknownImpl { fn frame(&self) -> windows_core::Result; fn offset(&self) -> windows_core::Result; fn length(&self) -> windows_core::Result; + fn read(&self) -> windows_core::Result; + fn write(&self) -> windows_core::Result; + fn execute(&self) -> windows_core::Result; fn addressSection(&self) -> windows_core::Result; fn relativeVirtualAddress(&self) -> windows_core::Result; fn virtualAddress(&self) -> windows_core::Result; @@ -10557,17 +12269,14 @@ impl IDiaSegment_Vtbl { } } } - unsafe extern "system" fn addressSection< - Identity: IDiaSegment_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn read( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSegment_Impl::addressSection(this) { + match IDiaSegment_Impl::read(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -10576,17 +12285,14 @@ impl IDiaSegment_Vtbl { } } } - unsafe extern "system" fn relativeVirtualAddress< - Identity: IDiaSegment_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn write( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSegment_Impl::relativeVirtualAddress(this) { + match IDiaSegment_Impl::write(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -10595,17 +12301,14 @@ impl IDiaSegment_Vtbl { } } } - unsafe extern "system" fn virtualAddress< - Identity: IDiaSegment_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn execute( this: *mut core::ffi::c_void, - pretval: *mut u64, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSegment_Impl::virtualAddress(this) { + match IDiaSegment_Impl::execute(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -10614,14 +12317,71 @@ impl IDiaSegment_Vtbl { } } } - Self { - base__: windows_core::IUnknown_Vtbl::new::(), + unsafe extern "system" fn addressSection< + Identity: IDiaSegment_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSegment_Impl::addressSection(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn relativeVirtualAddress< + Identity: IDiaSegment_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSegment_Impl::relativeVirtualAddress(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn virtualAddress< + Identity: IDiaSegment_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut u64, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSegment_Impl::virtualAddress(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), frame: frame::, offset: offset::, length: length::, - get_read: 0, - get_write: 0, - get_execute: 0, + read: read::, + write: write::, + execute: execute::, addressSection: addressSection::, relativeVirtualAddress: relativeVirtualAddress::, virtualAddress: virtualAddress::, @@ -13710,6 +15470,26 @@ impl core::ops::Deref for IDiaSessionEx { } windows_core::imp::interface_hierarchy!(IDiaSessionEx, windows_core::IUnknown, IDiaSession); impl IDiaSessionEx { + pub unsafe fn isFastLinkPDB(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isFastLinkPDB)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn isPortablePDB(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isPortablePDB)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } pub unsafe fn getSourceLinkInfo( &self, parent: P0, @@ -13731,8 +15511,14 @@ impl IDiaSessionEx { #[repr(C)] pub struct IDiaSessionEx_Vtbl { pub base__: IDiaSession_Vtbl, - isFastLinkPDB: usize, - isPortablePDB: usize, + pub isFastLinkPDB: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isPortablePDB: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub getSourceLinkInfo: unsafe extern "system" fn( *mut core::ffi::c_void, *mut core::ffi::c_void, @@ -13740,6 +15526,8 @@ pub struct IDiaSessionEx_Vtbl { ) -> windows_core::HRESULT, } pub trait IDiaSessionEx_Impl: IDiaSession_Impl { + fn isFastLinkPDB(&self) -> windows_core::Result; + fn isPortablePDB(&self) -> windows_core::Result; fn getSourceLinkInfo( &self, parent: windows_core::Ref<'_, IDiaSymbol>, @@ -13747,6 +15535,44 @@ pub trait IDiaSessionEx_Impl: IDiaSession_Impl { } impl IDiaSessionEx_Vtbl { pub const fn new() -> Self { + unsafe extern "system" fn isFastLinkPDB< + Identity: IDiaSessionEx_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pffastlinkpdb: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSessionEx_Impl::isFastLinkPDB(this) { + Ok(ok__) => { + pffastlinkpdb.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn isPortablePDB< + Identity: IDiaSessionEx_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pfportablepdb: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSessionEx_Impl::isPortablePDB(this) { + Ok(ok__) => { + pfportablepdb.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } unsafe extern "system" fn getSourceLinkInfo< Identity: IDiaSessionEx_Impl, const OFFSET: isize, @@ -13772,8 +15598,8 @@ impl IDiaSessionEx_Vtbl { } Self { base__: IDiaSession_Vtbl::new::(), - isFastLinkPDB: 0, - isPortablePDB: 0, + isFastLinkPDB: isFastLinkPDB::, + isPortablePDB: isPortablePDB::, getSourceLinkInfo: getSourceLinkInfo::, } } @@ -14087,6 +15913,52 @@ impl IDiaStackFrame { .map(|| result__) } } + pub unsafe fn systemExceptionHandling( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).systemExceptionHandling)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn cplusplusExceptionHandling( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).cplusplusExceptionHandling)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn functionStart(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).functionStart)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn allocatesBasePointer( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).allocatesBasePointer)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } pub unsafe fn maxStack(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); @@ -14128,10 +16000,22 @@ pub struct IDiaStackFrame_Vtbl { unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub lengthSavedRegisters: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - get_systemExceptionHandling: usize, - get_cplusplusExceptionHandling: usize, - get_functionStart: usize, - get_allocatesBasePointer: usize, + pub systemExceptionHandling: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub cplusplusExceptionHandling: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub functionStart: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub allocatesBasePointer: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub maxStack: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub get_registerValue: @@ -14147,6 +16031,10 @@ pub trait IDiaStackFrame_Impl: windows_core::IUnknownImpl { fn lengthParams(&self) -> windows_core::Result; fn lengthProlog(&self) -> windows_core::Result; fn lengthSavedRegisters(&self) -> windows_core::Result; + fn systemExceptionHandling(&self) -> windows_core::Result; + fn cplusplusExceptionHandling(&self) -> windows_core::Result; + fn functionStart(&self) -> windows_core::Result; + fn allocatesBasePointer(&self) -> windows_core::Result; fn maxStack(&self) -> windows_core::Result; fn get_registerValue(&self, index: u32) -> windows_core::Result; } @@ -14311,6 +16199,82 @@ impl IDiaStackFrame_Vtbl { } } } + unsafe extern "system" fn systemExceptionHandling< + Identity: IDiaStackFrame_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaStackFrame_Impl::systemExceptionHandling(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn cplusplusExceptionHandling< + Identity: IDiaStackFrame_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaStackFrame_Impl::cplusplusExceptionHandling(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn functionStart< + Identity: IDiaStackFrame_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaStackFrame_Impl::functionStart(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn allocatesBasePointer< + Identity: IDiaStackFrame_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaStackFrame_Impl::allocatesBasePointer(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } unsafe extern "system" fn maxStack( this: *mut core::ffi::c_void, pretval: *mut u32, @@ -14361,10 +16325,10 @@ impl IDiaStackFrame_Vtbl { lengthParams: lengthParams::, lengthProlog: lengthProlog::, lengthSavedRegisters: lengthSavedRegisters::, - get_systemExceptionHandling: 0, - get_cplusplusExceptionHandling: 0, - get_functionStart: 0, - get_allocatesBasePointer: 0, + systemExceptionHandling: systemExceptionHandling::, + cplusplusExceptionHandling: cplusplusExceptionHandling::, + functionStart: functionStart::, + allocatesBasePointer: allocatesBasePointer::, maxStack: maxStack::, get_registerValue: get_registerValue::, } @@ -15621,6 +17585,36 @@ impl IDiaSymbol { .map(|| result__) } } + pub unsafe fn volatileType(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).volatileType)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn constType(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).constType)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn unalignedType(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).unalignedType)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } pub unsafe fn access(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); @@ -15661,6 +17655,18 @@ impl IDiaSymbol { .map(|| result__) } } + pub unsafe fn editAndContinueEnabled( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).editAndContinueEnabled)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } pub unsafe fn frontEndMajor(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); @@ -15771,30 +17777,70 @@ impl IDiaSymbol { .map(|| result__) } } - pub unsafe fn callingConvention(&self) -> windows_core::Result { + pub unsafe fn r#virtual(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).callingConvention)( + (windows_core::Interface::vtable(self).r#virtual)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn baseType(&self) -> windows_core::Result { + pub unsafe fn intro(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).baseType)( + (windows_core::Interface::vtable(self).intro)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn token(&self) -> windows_core::Result { + pub unsafe fn pure(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).token)( + (windows_core::Interface::vtable(self).pure)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn callingConvention(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).callingConvention)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn value(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).value)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| core::mem::transmute(result__)) + } + } + pub unsafe fn baseType(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).baseType)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn token(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).token)( windows_core::Interface::as_raw(self), &mut result__, ) @@ -15831,6 +17877,16 @@ impl IDiaSymbol { .map(|| core::mem::transmute(result__)) } } + pub unsafe fn reference(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).reference)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } pub unsafe fn count(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); @@ -15861,6 +17917,114 @@ impl IDiaSymbol { .and_then(|| windows_core::Type::from_abi(result__)) } } + pub unsafe fn packed(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).packed)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn constructor(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).constructor)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn overloadedOperator( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).overloadedOperator)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn nested(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).nested)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn hasNestedTypes(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).hasNestedTypes)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn hasAssignmentOperator( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).hasAssignmentOperator)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn hasCastOperator(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).hasCastOperator)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn scoped(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).scoped)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn virtualBaseClass( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).virtualBaseClass)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn indirectVirtualBaseClass( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).indirectVirtualBaseClass)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } pub unsafe fn virtualBasePointerOffset(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); @@ -15931,6 +18095,46 @@ impl IDiaSymbol { .map(|| result__) } } + pub unsafe fn code(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).code)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn function(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).function)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn managed(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).managed)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn msil(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).msil)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } pub unsafe fn virtualBaseDispIndex(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); @@ -15971,6 +18175,28 @@ impl IDiaSymbol { .map(|| result__) } } + pub unsafe fn compilerGenerated( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).compilerGenerated)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn addressTaken(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).addressTaken)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } pub unsafe fn rank(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); @@ -16283,720 +18509,1472 @@ impl IDiaSymbol { .map(|| core::mem::transmute(result__)) } } - pub unsafe fn compilerName(&self) -> windows_core::Result { + pub unsafe fn noReturn(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).compilerName)( + (windows_core::Interface::vtable(self).noReturn)( windows_core::Interface::as_raw(self), &mut result__, ) - .map(|| core::mem::transmute(result__)) + .map(|| result__) } } - pub unsafe fn container(&self) -> windows_core::Result { + pub unsafe fn customCallingConvention( + &self, + ) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).container)( + (windows_core::Interface::vtable(self).customCallingConvention)( windows_core::Interface::as_raw(self), &mut result__, ) - .and_then(|| windows_core::Type::from_abi(result__)) + .map(|| result__) } } - pub unsafe fn virtualBaseTableType(&self) -> windows_core::Result { + pub unsafe fn noInline(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).virtualBaseTableType)( + (windows_core::Interface::vtable(self).noInline)( windows_core::Interface::as_raw(self), &mut result__, ) - .and_then(|| windows_core::Type::from_abi(result__)) + .map(|| result__) } } - pub unsafe fn frontEndQFE(&self) -> windows_core::Result { + pub unsafe fn optimizedCodeDebugInfo( + &self, + ) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).frontEndQFE)( + (windows_core::Interface::vtable(self).optimizedCodeDebugInfo)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn backEndQFE(&self) -> windows_core::Result { + pub unsafe fn notReached(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).backEndQFE)( + (windows_core::Interface::vtable(self).notReached)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn unmodifiedType(&self) -> windows_core::Result { + pub unsafe fn interruptReturn(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).unmodifiedType)( + (windows_core::Interface::vtable(self).interruptReturn)( windows_core::Interface::as_raw(self), &mut result__, ) - .and_then(|| windows_core::Type::from_abi(result__)) + .map(|| result__) } } - pub unsafe fn liveRangeStartAddressSection(&self) -> windows_core::Result { + pub unsafe fn farReturn(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).liveRangeStartAddressSection)( + (windows_core::Interface::vtable(self).farReturn)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn liveRangeStartAddressOffset(&self) -> windows_core::Result { + pub unsafe fn isStatic(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).liveRangeStartAddressOffset)( + (windows_core::Interface::vtable(self).isStatic)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn liveRangeStartRelativeVirtualAddress(&self) -> windows_core::Result { + pub unsafe fn hasDebugInfo(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).liveRangeStartRelativeVirtualAddress)( + (windows_core::Interface::vtable(self).hasDebugInfo)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn countLiveRanges(&self) -> windows_core::Result { + pub unsafe fn isLTCG(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).countLiveRanges)( + (windows_core::Interface::vtable(self).isLTCG)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn liveRangeLength(&self) -> windows_core::Result { + pub unsafe fn isDataAligned(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).liveRangeLength)( + (windows_core::Interface::vtable(self).isDataAligned)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn offsetInUdt(&self) -> windows_core::Result { + pub unsafe fn hasSecurityChecks( + &self, + ) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).offsetInUdt)( + (windows_core::Interface::vtable(self).hasSecurityChecks)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn paramBasePointerRegisterId(&self) -> windows_core::Result { + pub unsafe fn compilerName(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).paramBasePointerRegisterId)( + (windows_core::Interface::vtable(self).compilerName)( windows_core::Interface::as_raw(self), &mut result__, ) - .map(|| result__) + .map(|| core::mem::transmute(result__)) } } - pub unsafe fn localBasePointerRegisterId(&self) -> windows_core::Result { + pub unsafe fn hasAlloca(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).localBasePointerRegisterId)( + (windows_core::Interface::vtable(self).hasAlloca)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn stride(&self) -> windows_core::Result { + pub unsafe fn hasSetJump(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).stride)( + (windows_core::Interface::vtable(self).hasSetJump)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn numberOfRows(&self) -> windows_core::Result { + pub unsafe fn hasLongJump(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).numberOfRows)( + (windows_core::Interface::vtable(self).hasLongJump)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn numberOfColumns(&self) -> windows_core::Result { + pub unsafe fn hasInlAsm(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).numberOfColumns)( + (windows_core::Interface::vtable(self).hasInlAsm)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn get_numericProperties( - &self, - pcnt: *mut u32, - pproperties: &mut [u32], - ) -> windows_core::Result<()> { + pub unsafe fn hasEH(&self) -> windows_core::Result { unsafe { - (windows_core::Interface::vtable(self).get_numericProperties)( + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).hasEH)( windows_core::Interface::as_raw(self), - pproperties.len().try_into().unwrap(), - pcnt as _, - core::mem::transmute(pproperties.as_ptr()), + &mut result__, ) - .ok() + .map(|| result__) } } - pub unsafe fn get_modifierValues( - &self, - pcnt: *mut u32, - pmodifiers: &mut [u16], - ) -> windows_core::Result<()> { + pub unsafe fn hasSEH(&self) -> windows_core::Result { unsafe { - (windows_core::Interface::vtable(self).get_modifierValues)( + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).hasSEH)( windows_core::Interface::as_raw(self), - pmodifiers.len().try_into().unwrap(), - pcnt as _, - core::mem::transmute(pmodifiers.as_ptr()), + &mut result__, ) - .ok() + .map(|| result__) } } - pub unsafe fn builtInKind(&self) -> windows_core::Result { + pub unsafe fn hasEHa(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).builtInKind)( + (windows_core::Interface::vtable(self).hasEHa)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn registerType(&self) -> windows_core::Result { + pub unsafe fn isNaked(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).registerType)( + (windows_core::Interface::vtable(self).isNaked)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn baseDataSlot(&self) -> windows_core::Result { + pub unsafe fn isAggregated(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).baseDataSlot)( + (windows_core::Interface::vtable(self).isAggregated)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn baseDataOffset(&self) -> windows_core::Result { + pub unsafe fn isSplitted(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).baseDataOffset)( + (windows_core::Interface::vtable(self).isSplitted)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn textureSlot(&self) -> windows_core::Result { + pub unsafe fn container(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).textureSlot)( + (windows_core::Interface::vtable(self).container)( windows_core::Interface::as_raw(self), &mut result__, ) - .map(|| result__) + .and_then(|| windows_core::Type::from_abi(result__)) } } - pub unsafe fn samplerSlot(&self) -> windows_core::Result { + pub unsafe fn inlSpec(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).samplerSlot)( + (windows_core::Interface::vtable(self).inlSpec)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn uavSlot(&self) -> windows_core::Result { + pub unsafe fn noStackOrdering(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).uavSlot)( + (windows_core::Interface::vtable(self).noStackOrdering)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn sizeInUdt(&self) -> windows_core::Result { + pub unsafe fn virtualBaseTableType(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).sizeInUdt)( + (windows_core::Interface::vtable(self).virtualBaseTableType)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn hasManagedCode(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).hasManagedCode)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn memorySpaceKind(&self) -> windows_core::Result { + pub unsafe fn isHotpatchable(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).memorySpaceKind)( + (windows_core::Interface::vtable(self).isHotpatchable)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn unmodifiedTypeId(&self) -> windows_core::Result { + pub unsafe fn isCVTCIL(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).unmodifiedTypeId)( + (windows_core::Interface::vtable(self).isCVTCIL)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn subTypeId(&self) -> windows_core::Result { + pub unsafe fn isMSILNetmodule(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).subTypeId)( + (windows_core::Interface::vtable(self).isMSILNetmodule)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn subType(&self) -> windows_core::Result { + pub unsafe fn isCTypes(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).subType)( + (windows_core::Interface::vtable(self).isCTypes)( windows_core::Interface::as_raw(self), &mut result__, ) - .and_then(|| windows_core::Type::from_abi(result__)) + .map(|| result__) } } - pub unsafe fn numberOfModifiers(&self) -> windows_core::Result { + pub unsafe fn isStripped(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).numberOfModifiers)( + (windows_core::Interface::vtable(self).isStripped)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn numberOfRegisterIndices(&self) -> windows_core::Result { + pub unsafe fn frontEndQFE(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).numberOfRegisterIndices)( + (windows_core::Interface::vtable(self).frontEndQFE)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn baseSymbol(&self) -> windows_core::Result { + pub unsafe fn backEndQFE(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).baseSymbol)( + (windows_core::Interface::vtable(self).backEndQFE)( windows_core::Interface::as_raw(self), &mut result__, ) - .and_then(|| windows_core::Type::from_abi(result__)) + .map(|| result__) } } - pub unsafe fn baseSymbolId(&self) -> windows_core::Result { + pub unsafe fn wasInlined(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).baseSymbolId)( + (windows_core::Interface::vtable(self).wasInlined)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn objectFileName(&self) -> windows_core::Result { + pub unsafe fn strictGSCheck(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).objectFileName)( + (windows_core::Interface::vtable(self).strictGSCheck)( windows_core::Interface::as_raw(self), &mut result__, ) - .map(|| core::mem::transmute(result__)) + .map(|| result__) } } - pub unsafe fn numberOfAcceleratorPointerTags(&self) -> windows_core::Result { + pub unsafe fn isCxxReturnUdt(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).numberOfAcceleratorPointerTags)( + (windows_core::Interface::vtable(self).isCxxReturnUdt)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn findInlineFramesByAddr( + pub unsafe fn isConstructorVirtualBase( &self, - isect: u32, - offset: u32, - ) -> windows_core::Result { + ) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).findInlineFramesByAddr)( + (windows_core::Interface::vtable(self).isConstructorVirtualBase)( windows_core::Interface::as_raw(self), - isect, - offset, &mut result__, ) - .and_then(|| windows_core::Type::from_abi(result__)) + .map(|| result__) } } - pub unsafe fn findInlineFramesByRVA(&self, rva: u32) -> windows_core::Result { + pub unsafe fn RValueReference(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).findInlineFramesByRVA)( + (windows_core::Interface::vtable(self).RValueReference)( windows_core::Interface::as_raw(self), - rva, &mut result__, ) - .and_then(|| windows_core::Type::from_abi(result__)) + .map(|| result__) } } - pub unsafe fn findInlineFramesByVA(&self, va: u64) -> windows_core::Result { + pub unsafe fn unmodifiedType(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).findInlineFramesByVA)( + (windows_core::Interface::vtable(self).unmodifiedType)( windows_core::Interface::as_raw(self), - va, &mut result__, ) .and_then(|| windows_core::Type::from_abi(result__)) } } - pub unsafe fn findInlineeLines(&self) -> windows_core::Result { + pub unsafe fn framePointerPresent( + &self, + ) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).findInlineeLines)( + (windows_core::Interface::vtable(self).framePointerPresent)( windows_core::Interface::as_raw(self), &mut result__, ) - .and_then(|| windows_core::Type::from_abi(result__)) + .map(|| result__) } } - pub unsafe fn findInlineeLinesByAddr( - &self, - isect: u32, - offset: u32, - length: u32, - ) -> windows_core::Result { + pub unsafe fn isSafeBuffers(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).findInlineeLinesByAddr)( + (windows_core::Interface::vtable(self).isSafeBuffers)( windows_core::Interface::as_raw(self), - isect, - offset, - length, &mut result__, ) - .and_then(|| windows_core::Type::from_abi(result__)) + .map(|| result__) } } - pub unsafe fn findInlineeLinesByRVA( - &self, - rva: u32, - length: u32, - ) -> windows_core::Result { + pub unsafe fn intrinsic(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).findInlineeLinesByRVA)( + (windows_core::Interface::vtable(self).intrinsic)( windows_core::Interface::as_raw(self), - rva, - length, &mut result__, ) - .and_then(|| windows_core::Type::from_abi(result__)) + .map(|| result__) } } - pub unsafe fn findInlineeLinesByVA( - &self, - va: u64, - length: u32, - ) -> windows_core::Result { + pub unsafe fn sealed(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).findInlineeLinesByVA)( + (windows_core::Interface::vtable(self).sealed)( windows_core::Interface::as_raw(self), - va, - length, &mut result__, ) - .and_then(|| windows_core::Type::from_abi(result__)) + .map(|| result__) } } - pub unsafe fn findSymbolsForAcceleratorPointerTag( - &self, - tagvalue: u32, - ) -> windows_core::Result { + pub unsafe fn hfaFloat(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).findSymbolsForAcceleratorPointerTag)( + (windows_core::Interface::vtable(self).hfaFloat)( windows_core::Interface::as_raw(self), - tagvalue, &mut result__, ) - .and_then(|| windows_core::Type::from_abi(result__)) + .map(|| result__) } } - pub unsafe fn findSymbolsByRVAForAcceleratorPointerTag( - &self, - tagvalue: u32, - rva: u32, - ) -> windows_core::Result { + pub unsafe fn hfaDouble(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).findSymbolsByRVAForAcceleratorPointerTag)( + (windows_core::Interface::vtable(self).hfaDouble)( windows_core::Interface::as_raw(self), - tagvalue, - rva, &mut result__, ) - .and_then(|| windows_core::Type::from_abi(result__)) + .map(|| result__) } } - pub unsafe fn get_acceleratorPointerTags( - &self, - pcnt: *mut u32, - ppointertags: &mut [u32], - ) -> windows_core::Result<()> { + pub unsafe fn liveRangeStartAddressSection(&self) -> windows_core::Result { unsafe { - (windows_core::Interface::vtable(self).get_acceleratorPointerTags)( + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).liveRangeStartAddressSection)( windows_core::Interface::as_raw(self), - ppointertags.len().try_into().unwrap(), - pcnt as _, - core::mem::transmute(ppointertags.as_ptr()), + &mut result__, ) - .ok() + .map(|| result__) } } - pub unsafe fn getSrcLineOnTypeDefn(&self) -> windows_core::Result { + pub unsafe fn liveRangeStartAddressOffset(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).getSrcLineOnTypeDefn)( + (windows_core::Interface::vtable(self).liveRangeStartAddressOffset)( windows_core::Interface::as_raw(self), &mut result__, ) - .and_then(|| windows_core::Type::from_abi(result__)) + .map(|| result__) } } - pub unsafe fn PGOEntryCount(&self) -> windows_core::Result { + pub unsafe fn liveRangeStartRelativeVirtualAddress(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).PGOEntryCount)( + (windows_core::Interface::vtable(self).liveRangeStartRelativeVirtualAddress)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn PGOEdgeCount(&self) -> windows_core::Result { + pub unsafe fn countLiveRanges(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).PGOEdgeCount)( + (windows_core::Interface::vtable(self).countLiveRanges)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn PGODynamicInstructionCount(&self) -> windows_core::Result { + pub unsafe fn liveRangeLength(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).PGODynamicInstructionCount)( + (windows_core::Interface::vtable(self).liveRangeLength)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn staticSize(&self) -> windows_core::Result { + pub unsafe fn offsetInUdt(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).staticSize)( + (windows_core::Interface::vtable(self).offsetInUdt)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn finalLiveStaticSize(&self) -> windows_core::Result { + pub unsafe fn paramBasePointerRegisterId(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).finalLiveStaticSize)( + (windows_core::Interface::vtable(self).paramBasePointerRegisterId)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn phaseName(&self) -> windows_core::Result { + pub unsafe fn localBasePointerRegisterId(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).phaseName)( + (windows_core::Interface::vtable(self).localBasePointerRegisterId)( windows_core::Interface::as_raw(self), &mut result__, ) - .map(|| core::mem::transmute(result__)) + .map(|| result__) } } - pub unsafe fn ordinal(&self) -> windows_core::Result { + pub unsafe fn isLocationControlFlowDependent( + &self, + ) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).ordinal)( + (windows_core::Interface::vtable(self).isLocationControlFlowDependent)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn frameSize(&self) -> windows_core::Result { + pub unsafe fn stride(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).frameSize)( + (windows_core::Interface::vtable(self).stride)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn exceptionHandlerAddressSection(&self) -> windows_core::Result { + pub unsafe fn numberOfRows(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).exceptionHandlerAddressSection)( + (windows_core::Interface::vtable(self).numberOfRows)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn exceptionHandlerAddressOffset(&self) -> windows_core::Result { + pub unsafe fn numberOfColumns(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).exceptionHandlerAddressOffset)( + (windows_core::Interface::vtable(self).numberOfColumns)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn exceptionHandlerRelativeVirtualAddress(&self) -> windows_core::Result { + pub unsafe fn isMatrixRowMajor( + &self, + ) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).exceptionHandlerRelativeVirtualAddress)( + (windows_core::Interface::vtable(self).isMatrixRowMajor)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn exceptionHandlerVirtualAddress(&self) -> windows_core::Result { + pub unsafe fn get_numericProperties( + &self, + pcnt: *mut u32, + pproperties: &mut [u32], + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).get_numericProperties)( + windows_core::Interface::as_raw(self), + pproperties.len().try_into().unwrap(), + pcnt as _, + core::mem::transmute(pproperties.as_ptr()), + ) + .ok() + } + } + pub unsafe fn get_modifierValues( + &self, + pcnt: *mut u32, + pmodifiers: &mut [u16], + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).get_modifierValues)( + windows_core::Interface::as_raw(self), + pmodifiers.len().try_into().unwrap(), + pcnt as _, + core::mem::transmute(pmodifiers.as_ptr()), + ) + .ok() + } + } + pub unsafe fn isReturnValue(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).exceptionHandlerVirtualAddress)( + (windows_core::Interface::vtable(self).isReturnValue)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn findInputAssemblyFile(&self) -> windows_core::Result { + pub unsafe fn isOptimizedAway(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).findInputAssemblyFile)( + (windows_core::Interface::vtable(self).isOptimizedAway)( windows_core::Interface::as_raw(self), &mut result__, ) - .and_then(|| windows_core::Type::from_abi(result__)) + .map(|| result__) } } - pub unsafe fn characteristics(&self) -> windows_core::Result { + pub unsafe fn builtInKind(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).characteristics)( + (windows_core::Interface::vtable(self).builtInKind)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn coffGroup(&self) -> windows_core::Result { + pub unsafe fn registerType(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).coffGroup)( + (windows_core::Interface::vtable(self).registerType)( windows_core::Interface::as_raw(self), &mut result__, ) - .and_then(|| windows_core::Type::from_abi(result__)) + .map(|| result__) } } - pub unsafe fn bindID(&self) -> windows_core::Result { + pub unsafe fn baseDataSlot(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).bindID)( + (windows_core::Interface::vtable(self).baseDataSlot)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn bindSpace(&self) -> windows_core::Result { + pub unsafe fn baseDataOffset(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).bindSpace)( + (windows_core::Interface::vtable(self).baseDataOffset)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } - pub unsafe fn bindSlot(&self) -> windows_core::Result { + pub unsafe fn textureSlot(&self) -> windows_core::Result { unsafe { let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).bindSlot)( + (windows_core::Interface::vtable(self).textureSlot)( windows_core::Interface::as_raw(self), &mut result__, ) .map(|| result__) } } -} + pub unsafe fn samplerSlot(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).samplerSlot)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn uavSlot(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).uavSlot)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn sizeInUdt(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).sizeInUdt)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn memorySpaceKind(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).memorySpaceKind)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn unmodifiedTypeId(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).unmodifiedTypeId)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn subTypeId(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).subTypeId)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn subType(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).subType)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn numberOfModifiers(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).numberOfModifiers)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn numberOfRegisterIndices(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).numberOfRegisterIndices)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn isHLSLData(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isHLSLData)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn isPointerToDataMember( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isPointerToDataMember)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn isPointerToMemberFunction( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isPointerToMemberFunction)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn isSingleInheritance( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isSingleInheritance)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn isMultipleInheritance( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isMultipleInheritance)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn isVirtualInheritance( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isVirtualInheritance)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn restrictedType(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).restrictedType)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn isPointerBasedOnSymbolValue( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isPointerBasedOnSymbolValue)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn baseSymbol(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).baseSymbol)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn baseSymbolId(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).baseSymbolId)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn objectFileName(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).objectFileName)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| core::mem::transmute(result__)) + } + } + pub unsafe fn isAcceleratorGroupSharedLocal( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isAcceleratorGroupSharedLocal)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn isAcceleratorPointerTagLiveRange( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isAcceleratorPointerTagLiveRange)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn isAcceleratorStubFunction( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isAcceleratorStubFunction)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn numberOfAcceleratorPointerTags(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).numberOfAcceleratorPointerTags)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn isSdl(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isSdl)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn isWinRTPointer(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isWinRTPointer)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn isRefUdt(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isRefUdt)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn isValueUdt(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isValueUdt)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn isInterfaceUdt(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isInterfaceUdt)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn findInlineFramesByAddr( + &self, + isect: u32, + offset: u32, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).findInlineFramesByAddr)( + windows_core::Interface::as_raw(self), + isect, + offset, + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn findInlineFramesByRVA(&self, rva: u32) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).findInlineFramesByRVA)( + windows_core::Interface::as_raw(self), + rva, + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn findInlineFramesByVA(&self, va: u64) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).findInlineFramesByVA)( + windows_core::Interface::as_raw(self), + va, + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn findInlineeLines(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).findInlineeLines)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn findInlineeLinesByAddr( + &self, + isect: u32, + offset: u32, + length: u32, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).findInlineeLinesByAddr)( + windows_core::Interface::as_raw(self), + isect, + offset, + length, + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn findInlineeLinesByRVA( + &self, + rva: u32, + length: u32, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).findInlineeLinesByRVA)( + windows_core::Interface::as_raw(self), + rva, + length, + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn findInlineeLinesByVA( + &self, + va: u64, + length: u32, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).findInlineeLinesByVA)( + windows_core::Interface::as_raw(self), + va, + length, + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn findSymbolsForAcceleratorPointerTag( + &self, + tagvalue: u32, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).findSymbolsForAcceleratorPointerTag)( + windows_core::Interface::as_raw(self), + tagvalue, + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn findSymbolsByRVAForAcceleratorPointerTag( + &self, + tagvalue: u32, + rva: u32, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).findSymbolsByRVAForAcceleratorPointerTag)( + windows_core::Interface::as_raw(self), + tagvalue, + rva, + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn get_acceleratorPointerTags( + &self, + pcnt: *mut u32, + ppointertags: &mut [u32], + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).get_acceleratorPointerTags)( + windows_core::Interface::as_raw(self), + ppointertags.len().try_into().unwrap(), + pcnt as _, + core::mem::transmute(ppointertags.as_ptr()), + ) + .ok() + } + } + pub unsafe fn getSrcLineOnTypeDefn(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).getSrcLineOnTypeDefn)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn isPGO(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isPGO)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn hasValidPGOCounts( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).hasValidPGOCounts)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn isOptimizedForSpeed( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isOptimizedForSpeed)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn PGOEntryCount(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).PGOEntryCount)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn PGOEdgeCount(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).PGOEdgeCount)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn PGODynamicInstructionCount(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).PGODynamicInstructionCount)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn staticSize(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).staticSize)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn finalLiveStaticSize(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).finalLiveStaticSize)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn phaseName(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).phaseName)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| core::mem::transmute(result__)) + } + } + pub unsafe fn hasControlFlowCheck( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).hasControlFlowCheck)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn constantExport(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).constantExport)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn dataExport(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).dataExport)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn privateExport(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).privateExport)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn noNameExport(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).noNameExport)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn exportHasExplicitlyAssignedOrdinal( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).exportHasExplicitlyAssignedOrdinal)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn exportIsForwarder( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).exportIsForwarder)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn ordinal(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).ordinal)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn frameSize(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).frameSize)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn exceptionHandlerAddressSection(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).exceptionHandlerAddressSection)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn exceptionHandlerAddressOffset(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).exceptionHandlerAddressOffset)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn exceptionHandlerRelativeVirtualAddress(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).exceptionHandlerRelativeVirtualAddress)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn exceptionHandlerVirtualAddress(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).exceptionHandlerVirtualAddress)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn findInputAssemblyFile(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).findInputAssemblyFile)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn characteristics(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).characteristics)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn coffGroup(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).coffGroup)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn bindID(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).bindID)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn bindSpace(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).bindSpace)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn bindSlot(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).bindSlot)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } +} #[repr(C)] pub struct IDiaSymbol_Vtbl { pub base__: windows_core::IUnknown_Vtbl, @@ -17039,9 +20017,18 @@ pub struct IDiaSymbol_Vtbl { pub length: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT, pub slot: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - get_volatileType: usize, - get_constType: usize, - get_unalignedType: usize, + pub volatileType: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub constType: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub unalignedType: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub access: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub libraryName: unsafe extern "system" fn( @@ -17052,7 +20039,10 @@ pub struct IDiaSymbol_Vtbl { unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub language: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - get_editAndContinueEnabled: usize, + pub editAndContinueEnabled: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub frontEndMajor: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub frontEndMinor: @@ -17079,12 +20069,24 @@ pub struct IDiaSymbol_Vtbl { unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT, pub virtualBaseOffset: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - get_virtual: usize, - get_intro: usize, - get_pure: usize, + pub r#virtual: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub intro: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub pure: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub callingConvention: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - get_value: usize, + pub value: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::System::Variant::VARIANT, + ) -> windows_core::HRESULT, pub baseType: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub token: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, @@ -17092,30 +20094,63 @@ pub struct IDiaSymbol_Vtbl { unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub guid: unsafe extern "system" fn( *mut core::ffi::c_void, - *mut windows_core::GUID, + *mut windows_core::GUID, + ) -> windows_core::HRESULT, + pub symbolsFileName: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub reference: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub count: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, + pub bitPosition: + unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, + pub arrayIndexType: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub packed: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub constructor: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub overloadedOperator: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub nested: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT, - pub symbolsFileName: unsafe extern "system" fn( + pub hasNestedTypes: unsafe extern "system" fn( *mut core::ffi::c_void, - *mut *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT, - get_reference: usize, - pub count: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - pub bitPosition: - unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - pub arrayIndexType: unsafe extern "system" fn( + pub hasAssignmentOperator: unsafe extern "system" fn( *mut core::ffi::c_void, - *mut *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub hasCastOperator: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub scoped: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub virtualBaseClass: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub indirectVirtualBaseClass: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT, - get_packed: usize, - get_constructor: usize, - get_overloadedOperator: usize, - get_nested: usize, - get_hasNestedTypes: usize, - get_hasAssignmentOperator: usize, - get_hasCastOperator: usize, - get_scoped: usize, - get_virtualBaseClass: usize, - get_indirectVirtualBaseClass: usize, pub virtualBasePointerOffset: unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT, pub virtualTableShape: unsafe extern "system" fn( @@ -17132,10 +20167,22 @@ pub struct IDiaSymbol_Vtbl { unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub virtualTableShapeId: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - get_code: usize, - get_function: usize, - get_managed: usize, - get_msil: usize, + pub code: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub function: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub managed: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub msil: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub virtualBaseDispIndex: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub undecoratedName: unsafe extern "system" fn( @@ -17145,8 +20192,14 @@ pub struct IDiaSymbol_Vtbl { pub age: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub signature: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - get_compilerGenerated: usize, - get_addressTaken: usize, + pub compilerGenerated: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub addressTaken: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub rank: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub lowerBound: unsafe extern "system" fn( *mut core::ffi::c_void, @@ -17241,67 +20294,190 @@ pub struct IDiaSymbol_Vtbl { u32, *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT, - get_noReturn: usize, - get_customCallingConvention: usize, - get_noInline: usize, - get_optimizedCodeDebugInfo: usize, - get_notReached: usize, - get_interruptReturn: usize, - get_farReturn: usize, - get_isStatic: usize, - get_hasDebugInfo: usize, - get_isLTCG: usize, - get_isDataAligned: usize, - get_hasSecurityChecks: usize, + pub noReturn: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub customCallingConvention: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub noInline: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub optimizedCodeDebugInfo: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub notReached: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub interruptReturn: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub farReturn: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isStatic: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub hasDebugInfo: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isLTCG: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isDataAligned: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub hasSecurityChecks: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub compilerName: unsafe extern "system" fn( *mut core::ffi::c_void, *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT, - get_hasAlloca: usize, - get_hasSetJump: usize, - get_hasLongJump: usize, - get_hasInlAsm: usize, - get_hasEH: usize, - get_hasSEH: usize, - get_hasEHa: usize, - get_isNaked: usize, - get_isAggregated: usize, - get_isSplitted: usize, + pub hasAlloca: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub hasSetJump: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub hasLongJump: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub hasInlAsm: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub hasEH: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub hasSEH: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub hasEHa: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isNaked: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isAggregated: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isSplitted: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub container: unsafe extern "system" fn( *mut core::ffi::c_void, *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT, - get_inlSpec: usize, - get_noStackOrdering: usize, + pub inlSpec: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub noStackOrdering: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub virtualBaseTableType: unsafe extern "system" fn( *mut core::ffi::c_void, *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT, - get_hasManagedCode: usize, - get_isHotpatchable: usize, - get_isCVTCIL: usize, - get_isMSILNetmodule: usize, - get_isCTypes: usize, - get_isStripped: usize, + pub hasManagedCode: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isHotpatchable: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isCVTCIL: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isMSILNetmodule: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isCTypes: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isStripped: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub frontEndQFE: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub backEndQFE: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - get_wasInlined: usize, - get_strictGSCheck: usize, - get_isCxxReturnUdt: usize, - get_isConstructorVirtualBase: usize, - get_RValueReference: usize, + pub wasInlined: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub strictGSCheck: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isCxxReturnUdt: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isConstructorVirtualBase: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub RValueReference: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub unmodifiedType: unsafe extern "system" fn( *mut core::ffi::c_void, *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT, - get_framePointerPresent: usize, - get_isSafeBuffers: usize, - get_intrinsic: usize, - get_sealed: usize, - get_hfaFloat: usize, - get_hfaDouble: usize, + pub framePointerPresent: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isSafeBuffers: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub intrinsic: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub sealed: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub hfaFloat: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub hfaDouble: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub liveRangeStartAddressSection: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub liveRangeStartAddressOffset: @@ -17318,14 +20494,20 @@ pub struct IDiaSymbol_Vtbl { unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub localBasePointerRegisterId: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - get_isLocationControlFlowDependent: usize, + pub isLocationControlFlowDependent: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub stride: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub numberOfRows: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub numberOfColumns: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - get_isMatrixRowMajor: usize, + pub isMatrixRowMajor: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub get_numericProperties: unsafe extern "system" fn( *mut core::ffi::c_void, u32, @@ -17338,8 +20520,14 @@ pub struct IDiaSymbol_Vtbl { *mut u32, *mut u16, ) -> windows_core::HRESULT, - get_isReturnValue: usize, - get_isOptimizedAway: usize, + pub isReturnValue: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isOptimizedAway: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub builtInKind: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub registerType: @@ -17370,14 +20558,38 @@ pub struct IDiaSymbol_Vtbl { unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub numberOfRegisterIndices: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - get_isHLSLData: usize, - get_isPointerToDataMember: usize, - get_isPointerToMemberFunction: usize, - get_isSingleInheritance: usize, - get_isMultipleInheritance: usize, - get_isVirtualInheritance: usize, - get_restrictedType: usize, - get_isPointerBasedOnSymbolValue: usize, + pub isHLSLData: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isPointerToDataMember: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isPointerToMemberFunction: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isSingleInheritance: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isMultipleInheritance: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isVirtualInheritance: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub restrictedType: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isPointerBasedOnSymbolValue: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub baseSymbol: unsafe extern "system" fn( *mut core::ffi::c_void, *mut *mut core::ffi::c_void, @@ -17388,16 +20600,40 @@ pub struct IDiaSymbol_Vtbl { *mut core::ffi::c_void, *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT, - get_isAcceleratorGroupSharedLocal: usize, - get_isAcceleratorPointerTagLiveRange: usize, - get_isAcceleratorStubFunction: usize, + pub isAcceleratorGroupSharedLocal: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isAcceleratorPointerTagLiveRange: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isAcceleratorStubFunction: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub numberOfAcceleratorPointerTags: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - get_isSdl: usize, - get_isWinRTPointer: usize, - get_isRefUdt: usize, - get_isValueUdt: usize, - get_isInterfaceUdt: usize, + pub isSdl: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isWinRTPointer: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isRefUdt: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isValueUdt: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isInterfaceUdt: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub findInlineFramesByAddr: unsafe extern "system" fn( *mut core::ffi::c_void, u32, @@ -17460,9 +20696,18 @@ pub struct IDiaSymbol_Vtbl { *mut core::ffi::c_void, *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT, - get_isPGO: usize, - get_hasValidPGOCounts: usize, - get_isOptimizedForSpeed: usize, + pub isPGO: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub hasValidPGOCounts: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isOptimizedForSpeed: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub PGOEntryCount: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub PGOEdgeCount: @@ -17477,13 +20722,34 @@ pub struct IDiaSymbol_Vtbl { *mut core::ffi::c_void, *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT, - get_hasControlFlowCheck: usize, - get_constantExport: usize, - get_dataExport: usize, - get_privateExport: usize, - get_noNameExport: usize, - get_exportHasExplicitlyAssignedOrdinal: usize, - get_exportIsForwarder: usize, + pub hasControlFlowCheck: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub constantExport: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub dataExport: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub privateExport: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub noNameExport: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub exportHasExplicitlyAssignedOrdinal: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub exportIsForwarder: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, pub ordinal: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub frameSize: @@ -17530,10 +20796,14 @@ pub trait IDiaSymbol_Impl: windows_core::IUnknownImpl { fn offset(&self) -> windows_core::Result; fn length(&self) -> windows_core::Result; fn slot(&self) -> windows_core::Result; + fn volatileType(&self) -> windows_core::Result; + fn constType(&self) -> windows_core::Result; + fn unalignedType(&self) -> windows_core::Result; fn access(&self) -> windows_core::Result; fn libraryName(&self) -> windows_core::Result; fn platform(&self) -> windows_core::Result; fn language(&self) -> windows_core::Result; + fn editAndContinueEnabled(&self) -> windows_core::Result; fn frontEndMajor(&self) -> windows_core::Result; fn frontEndMinor(&self) -> windows_core::Result; fn frontEndBuild(&self) -> windows_core::Result; @@ -17545,15 +20815,30 @@ pub trait IDiaSymbol_Impl: windows_core::IUnknownImpl { fn thunkOrdinal(&self) -> windows_core::Result; fn thisAdjust(&self) -> windows_core::Result; fn virtualBaseOffset(&self) -> windows_core::Result; + fn r#virtual(&self) -> windows_core::Result; + fn intro(&self) -> windows_core::Result; + fn pure(&self) -> windows_core::Result; fn callingConvention(&self) -> windows_core::Result; + fn value(&self) -> windows_core::Result; fn baseType(&self) -> windows_core::Result; fn token(&self) -> windows_core::Result; fn timeStamp(&self) -> windows_core::Result; fn guid(&self) -> windows_core::Result; fn symbolsFileName(&self) -> windows_core::Result; + fn reference(&self) -> windows_core::Result; fn count(&self) -> windows_core::Result; fn bitPosition(&self) -> windows_core::Result; fn arrayIndexType(&self) -> windows_core::Result; + fn packed(&self) -> windows_core::Result; + fn constructor(&self) -> windows_core::Result; + fn overloadedOperator(&self) -> windows_core::Result; + fn nested(&self) -> windows_core::Result; + fn hasNestedTypes(&self) -> windows_core::Result; + fn hasAssignmentOperator(&self) -> windows_core::Result; + fn hasCastOperator(&self) -> windows_core::Result; + fn scoped(&self) -> windows_core::Result; + fn virtualBaseClass(&self) -> windows_core::Result; + fn indirectVirtualBaseClass(&self) -> windows_core::Result; fn virtualBasePointerOffset(&self) -> windows_core::Result; fn virtualTableShape(&self) -> windows_core::Result; fn lexicalParentId(&self) -> windows_core::Result; @@ -17561,10 +20846,16 @@ pub trait IDiaSymbol_Impl: windows_core::IUnknownImpl { fn typeId(&self) -> windows_core::Result; fn arrayIndexTypeId(&self) -> windows_core::Result; fn virtualTableShapeId(&self) -> windows_core::Result; + fn code(&self) -> windows_core::Result; + fn function(&self) -> windows_core::Result; + fn managed(&self) -> windows_core::Result; + fn msil(&self) -> windows_core::Result; fn virtualBaseDispIndex(&self) -> windows_core::Result; fn undecoratedName(&self) -> windows_core::Result; fn age(&self) -> windows_core::Result; fn signature(&self) -> windows_core::Result; + fn compilerGenerated(&self) -> windows_core::Result; + fn addressTaken(&self) -> windows_core::Result; fn rank(&self) -> windows_core::Result; fn lowerBound(&self) -> windows_core::Result; fn upperBound(&self) -> windows_core::Result; @@ -17635,12 +20926,53 @@ pub trait IDiaSymbol_Impl: windows_core::IUnknownImpl { &self, undecorateoptions: u32, ) -> windows_core::Result; + fn noReturn(&self) -> windows_core::Result; + fn customCallingConvention(&self) -> windows_core::Result; + fn noInline(&self) -> windows_core::Result; + fn optimizedCodeDebugInfo(&self) -> windows_core::Result; + fn notReached(&self) -> windows_core::Result; + fn interruptReturn(&self) -> windows_core::Result; + fn farReturn(&self) -> windows_core::Result; + fn isStatic(&self) -> windows_core::Result; + fn hasDebugInfo(&self) -> windows_core::Result; + fn isLTCG(&self) -> windows_core::Result; + fn isDataAligned(&self) -> windows_core::Result; + fn hasSecurityChecks(&self) -> windows_core::Result; fn compilerName(&self) -> windows_core::Result; + fn hasAlloca(&self) -> windows_core::Result; + fn hasSetJump(&self) -> windows_core::Result; + fn hasLongJump(&self) -> windows_core::Result; + fn hasInlAsm(&self) -> windows_core::Result; + fn hasEH(&self) -> windows_core::Result; + fn hasSEH(&self) -> windows_core::Result; + fn hasEHa(&self) -> windows_core::Result; + fn isNaked(&self) -> windows_core::Result; + fn isAggregated(&self) -> windows_core::Result; + fn isSplitted(&self) -> windows_core::Result; fn container(&self) -> windows_core::Result; + fn inlSpec(&self) -> windows_core::Result; + fn noStackOrdering(&self) -> windows_core::Result; fn virtualBaseTableType(&self) -> windows_core::Result; + fn hasManagedCode(&self) -> windows_core::Result; + fn isHotpatchable(&self) -> windows_core::Result; + fn isCVTCIL(&self) -> windows_core::Result; + fn isMSILNetmodule(&self) -> windows_core::Result; + fn isCTypes(&self) -> windows_core::Result; + fn isStripped(&self) -> windows_core::Result; fn frontEndQFE(&self) -> windows_core::Result; fn backEndQFE(&self) -> windows_core::Result; + fn wasInlined(&self) -> windows_core::Result; + fn strictGSCheck(&self) -> windows_core::Result; + fn isCxxReturnUdt(&self) -> windows_core::Result; + fn isConstructorVirtualBase(&self) -> windows_core::Result; + fn RValueReference(&self) -> windows_core::Result; fn unmodifiedType(&self) -> windows_core::Result; + fn framePointerPresent(&self) -> windows_core::Result; + fn isSafeBuffers(&self) -> windows_core::Result; + fn intrinsic(&self) -> windows_core::Result; + fn sealed(&self) -> windows_core::Result; + fn hfaFloat(&self) -> windows_core::Result; + fn hfaDouble(&self) -> windows_core::Result; fn liveRangeStartAddressSection(&self) -> windows_core::Result; fn liveRangeStartAddressOffset(&self) -> windows_core::Result; fn liveRangeStartRelativeVirtualAddress(&self) -> windows_core::Result; @@ -17649,9 +20981,13 @@ pub trait IDiaSymbol_Impl: windows_core::IUnknownImpl { fn offsetInUdt(&self) -> windows_core::Result; fn paramBasePointerRegisterId(&self) -> windows_core::Result; fn localBasePointerRegisterId(&self) -> windows_core::Result; + fn isLocationControlFlowDependent( + &self, + ) -> windows_core::Result; fn stride(&self) -> windows_core::Result; fn numberOfRows(&self) -> windows_core::Result; fn numberOfColumns(&self) -> windows_core::Result; + fn isMatrixRowMajor(&self) -> windows_core::Result; fn get_numericProperties( &self, cnt: u32, @@ -17664,6 +21000,8 @@ pub trait IDiaSymbol_Impl: windows_core::IUnknownImpl { pcnt: *mut u32, pmodifiers: *mut u16, ) -> windows_core::Result<()>; + fn isReturnValue(&self) -> windows_core::Result; + fn isOptimizedAway(&self) -> windows_core::Result; fn builtInKind(&self) -> windows_core::Result; fn registerType(&self) -> windows_core::Result; fn baseDataSlot(&self) -> windows_core::Result; @@ -17678,10 +21016,31 @@ pub trait IDiaSymbol_Impl: windows_core::IUnknownImpl { fn subType(&self) -> windows_core::Result; fn numberOfModifiers(&self) -> windows_core::Result; fn numberOfRegisterIndices(&self) -> windows_core::Result; + fn isHLSLData(&self) -> windows_core::Result; + fn isPointerToDataMember(&self) -> windows_core::Result; + fn isPointerToMemberFunction(&self) -> windows_core::Result; + fn isSingleInheritance(&self) -> windows_core::Result; + fn isMultipleInheritance(&self) -> windows_core::Result; + fn isVirtualInheritance(&self) -> windows_core::Result; + fn restrictedType(&self) -> windows_core::Result; + fn isPointerBasedOnSymbolValue(&self) + -> windows_core::Result; fn baseSymbol(&self) -> windows_core::Result; fn baseSymbolId(&self) -> windows_core::Result; fn objectFileName(&self) -> windows_core::Result; + fn isAcceleratorGroupSharedLocal( + &self, + ) -> windows_core::Result; + fn isAcceleratorPointerTagLiveRange( + &self, + ) -> windows_core::Result; + fn isAcceleratorStubFunction(&self) -> windows_core::Result; fn numberOfAcceleratorPointerTags(&self) -> windows_core::Result; + fn isSdl(&self) -> windows_core::Result; + fn isWinRTPointer(&self) -> windows_core::Result; + fn isRefUdt(&self) -> windows_core::Result; + fn isValueUdt(&self) -> windows_core::Result; + fn isInterfaceUdt(&self) -> windows_core::Result; fn findInlineFramesByAddr( &self, isect: u32, @@ -17722,12 +21081,24 @@ pub trait IDiaSymbol_Impl: windows_core::IUnknownImpl { ppointertags: *mut u32, ) -> windows_core::Result<()>; fn getSrcLineOnTypeDefn(&self) -> windows_core::Result; + fn isPGO(&self) -> windows_core::Result; + fn hasValidPGOCounts(&self) -> windows_core::Result; + fn isOptimizedForSpeed(&self) -> windows_core::Result; fn PGOEntryCount(&self) -> windows_core::Result; fn PGOEdgeCount(&self) -> windows_core::Result; fn PGODynamicInstructionCount(&self) -> windows_core::Result; fn staticSize(&self) -> windows_core::Result; fn finalLiveStaticSize(&self) -> windows_core::Result; fn phaseName(&self) -> windows_core::Result; + fn hasControlFlowCheck(&self) -> windows_core::Result; + fn constantExport(&self) -> windows_core::Result; + fn dataExport(&self) -> windows_core::Result; + fn privateExport(&self) -> windows_core::Result; + fn noNameExport(&self) -> windows_core::Result; + fn exportHasExplicitlyAssignedOrdinal( + &self, + ) -> windows_core::Result; + fn exportIsForwarder(&self) -> windows_core::Result; fn ordinal(&self) -> windows_core::Result; fn frameSize(&self) -> windows_core::Result; fn exceptionHandlerAddressSection(&self) -> windows_core::Result; @@ -17750,7 +21121,1210 @@ impl IDiaSymbol_Vtbl { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::symIndexId(this) { + match IDiaSymbol_Impl::symIndexId(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn symTag( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::symTag(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn name( + this: *mut core::ffi::c_void, + pretval: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::name(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn lexicalParent( + this: *mut core::ffi::c_void, + pretval: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::lexicalParent(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn classParent( + this: *mut core::ffi::c_void, + pretval: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::classParent(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn r#type( + this: *mut core::ffi::c_void, + pretval: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::r#type(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn dataKind( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::dataKind(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn locationType( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::locationType(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn addressSection( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::addressSection(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn addressOffset( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::addressOffset(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn relativeVirtualAddress< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::relativeVirtualAddress(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn virtualAddress( + this: *mut core::ffi::c_void, + pretval: *mut u64, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::virtualAddress(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn registerId( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::registerId(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn offset( + this: *mut core::ffi::c_void, + pretval: *mut i32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::offset(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn length( + this: *mut core::ffi::c_void, + pretval: *mut u64, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::length(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn slot( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::slot(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn volatileType( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::volatileType(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn constType( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::constType(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn unalignedType( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::unalignedType(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn access( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::access(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn libraryName( + this: *mut core::ffi::c_void, + pretval: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::libraryName(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn platform( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::platform(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn language( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::language(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn editAndContinueEnabled< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::editAndContinueEnabled(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn frontEndMajor( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::frontEndMajor(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn frontEndMinor( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::frontEndMinor(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn frontEndBuild( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::frontEndBuild(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn backEndMajor( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::backEndMajor(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn backEndMinor( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::backEndMinor(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn backEndBuild( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::backEndBuild(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn sourceFileName( + this: *mut core::ffi::c_void, + pretval: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::sourceFileName(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn unused( + this: *mut core::ffi::c_void, + pretval: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::unused(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn thunkOrdinal( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::thunkOrdinal(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn thisAdjust( + this: *mut core::ffi::c_void, + pretval: *mut i32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::thisAdjust(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn virtualBaseOffset< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::virtualBaseOffset(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn r#virtual( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::r#virtual(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn intro( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::intro(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn pure( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::pure(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn callingConvention< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::callingConvention(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn value( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::System::Variant::VARIANT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::value(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn baseType( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::baseType(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn token( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::token(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn timeStamp( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::timeStamp(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn guid( + this: *mut core::ffi::c_void, + pretval: *mut windows_core::GUID, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::guid(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn symbolsFileName< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::symbolsFileName(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn reference( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::reference(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn count( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::count(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn bitPosition( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::bitPosition(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn arrayIndexType( + this: *mut core::ffi::c_void, + pretval: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::arrayIndexType(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn packed( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::packed(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn constructor( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::constructor(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn overloadedOperator< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::overloadedOperator(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn nested( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::nested(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn hasNestedTypes( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::hasNestedTypes(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn hasAssignmentOperator< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::hasAssignmentOperator(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn hasCastOperator< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::hasCastOperator(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn scoped( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::scoped(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn virtualBaseClass< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::virtualBaseClass(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn indirectVirtualBaseClass< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::indirectVirtualBaseClass(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn virtualBasePointerOffset< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut i32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::virtualBasePointerOffset(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn virtualTableShape< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::virtualTableShape(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn lexicalParentId< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::lexicalParentId(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn classParentId( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::classParentId(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn typeId( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::typeId(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn arrayIndexTypeId< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::arrayIndexTypeId(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn virtualTableShapeId< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::virtualTableShapeId(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn code( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::code(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn function( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::function(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn managed( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::managed(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn msil( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::msil(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn virtualBaseDispIndex< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::virtualBaseDispIndex(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn undecoratedName< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::undecoratedName(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn age( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::age(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -17759,46 +22333,300 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn symTag( + unsafe extern "system" fn signature( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::signature(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn compilerGenerated< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::compilerGenerated(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn addressTaken( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::addressTaken(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn rank( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::rank(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn lowerBound( + this: *mut core::ffi::c_void, + pretval: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::lowerBound(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn upperBound( + this: *mut core::ffi::c_void, + pretval: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::upperBound(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn lowerBoundId( + this: *mut core::ffi::c_void, + pretval: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::lowerBoundId(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn upperBoundId( this: *mut core::ffi::c_void, pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::symTag(this) { + match IDiaSymbol_Impl::upperBoundId(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn get_dataBytes( + this: *mut core::ffi::c_void, + cbdata: u32, + pcbdata: *mut u32, + pbdata: *mut u8, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IDiaSymbol_Impl::get_dataBytes( + this, + core::mem::transmute_copy(&cbdata), + core::mem::transmute_copy(&pcbdata), + core::mem::transmute_copy(&pbdata), + ) + .into() + } + } + unsafe extern "system" fn findChildren( + this: *mut core::ffi::c_void, + symtag: SymTag, + name: windows_core::PCWSTR, + compareflags: u32, + ppresult: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::findChildren( + this, + core::mem::transmute_copy(&symtag), + core::mem::transmute(&name), + core::mem::transmute_copy(&compareflags), + ) { + Ok(ok__) => { + ppresult.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn findChildrenEx( + this: *mut core::ffi::c_void, + symtag: SymTag, + name: windows_core::PCWSTR, + compareflags: u32, + ppresult: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::findChildrenEx( + this, + core::mem::transmute_copy(&symtag), + core::mem::transmute(&name), + core::mem::transmute_copy(&compareflags), + ) { + Ok(ok__) => { + ppresult.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn findChildrenExByAddr< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + symtag: SymTag, + name: windows_core::PCWSTR, + compareflags: u32, + isect: u32, + offset: u32, + ppresult: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::findChildrenExByAddr( + this, + core::mem::transmute_copy(&symtag), + core::mem::transmute(&name), + core::mem::transmute_copy(&compareflags), + core::mem::transmute_copy(&isect), + core::mem::transmute_copy(&offset), + ) { + Ok(ok__) => { + ppresult.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn findChildrenExByVA< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + symtag: SymTag, + name: windows_core::PCWSTR, + compareflags: u32, + va: u64, + ppresult: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::findChildrenExByVA( + this, + core::mem::transmute_copy(&symtag), + core::mem::transmute(&name), + core::mem::transmute_copy(&compareflags), + core::mem::transmute_copy(&va), + ) { Ok(ok__) => { - pretval.write(core::mem::transmute(ok__)); + ppresult.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) } Err(err) => err.into(), } } } - unsafe extern "system" fn name( + unsafe extern "system" fn findChildrenExByRVA< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut *mut core::ffi::c_void, + symtag: SymTag, + name: windows_core::PCWSTR, + compareflags: u32, + rva: u32, + ppresult: *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::name(this) { + match IDiaSymbol_Impl::findChildrenExByRVA( + this, + core::mem::transmute_copy(&symtag), + core::mem::transmute(&name), + core::mem::transmute_copy(&compareflags), + core::mem::transmute_copy(&rva), + ) { Ok(ok__) => { - pretval.write(core::mem::transmute(ok__)); + ppresult.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) } Err(err) => err.into(), } } } - unsafe extern "system" fn lexicalParent( + unsafe extern "system" fn targetSection( this: *mut core::ffi::c_void, - pretval: *mut *mut core::ffi::c_void, + pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::lexicalParent(this) { + match IDiaSymbol_Impl::targetSection(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -17807,14 +22635,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn classParent( + unsafe extern "system" fn targetOffset( this: *mut core::ffi::c_void, - pretval: *mut *mut core::ffi::c_void, + pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::classParent(this) { + match IDiaSymbol_Impl::targetOffset(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -17823,14 +22651,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn r#type( + unsafe extern "system" fn targetRelativeVirtualAddress< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut *mut core::ffi::c_void, + pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::r#type(this) { + match IDiaSymbol_Impl::targetRelativeVirtualAddress(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -17839,14 +22670,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn dataKind( + unsafe extern "system" fn targetVirtualAddress< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut u64, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::dataKind(this) { + match IDiaSymbol_Impl::targetVirtualAddress(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -17855,14 +22689,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn locationType( + unsafe extern "system" fn machineType( this: *mut core::ffi::c_void, pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::locationType(this) { + match IDiaSymbol_Impl::machineType(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -17871,14 +22705,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn addressSection( + unsafe extern "system" fn oemId( this: *mut core::ffi::c_void, pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::addressSection(this) { + match IDiaSymbol_Impl::oemId(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -17887,14 +22721,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn addressOffset( + unsafe extern "system" fn oemSymbolId( this: *mut core::ffi::c_void, pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::addressOffset(this) { + match IDiaSymbol_Impl::oemSymbolId(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -17903,49 +22737,53 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn relativeVirtualAddress< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn get_types( this: *mut core::ffi::c_void, - pretval: *mut u32, + ctypes: u32, + pctypes: *mut u32, + ptypes: *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::relativeVirtualAddress(this) { - Ok(ok__) => { - pretval.write(core::mem::transmute(ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } + IDiaSymbol_Impl::get_types( + this, + core::mem::transmute_copy(&ctypes), + core::mem::transmute_copy(&pctypes), + core::mem::transmute_copy(&ptypes), + ) + .into() } } - unsafe extern "system" fn virtualAddress( + unsafe extern "system" fn get_typeIds( this: *mut core::ffi::c_void, - pretval: *mut u64, + ctypeids: u32, + pctypeids: *mut u32, + pdwtypeids: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::virtualAddress(this) { - Ok(ok__) => { - pretval.write(core::mem::transmute(ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } + IDiaSymbol_Impl::get_typeIds( + this, + core::mem::transmute_copy(&ctypeids), + core::mem::transmute_copy(&pctypeids), + core::mem::transmute_copy(&pdwtypeids), + ) + .into() } } - unsafe extern "system" fn registerId( + unsafe extern "system" fn objectPointerType< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::registerId(this) { + match IDiaSymbol_Impl::objectPointerType(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -17954,14 +22792,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn offset( + unsafe extern "system" fn udtKind( this: *mut core::ffi::c_void, - pretval: *mut i32, + pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::offset(this) { + match IDiaSymbol_Impl::udtKind(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -17970,30 +22808,37 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn length( + unsafe extern "system" fn get_undecoratedNameEx< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut u64, + undecorateoptions: u32, + name: *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::length(this) { + match IDiaSymbol_Impl::get_undecoratedNameEx( + this, + core::mem::transmute_copy(&undecorateoptions), + ) { Ok(ok__) => { - pretval.write(core::mem::transmute(ok__)); + name.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) } Err(err) => err.into(), } } } - unsafe extern "system" fn slot( + unsafe extern "system" fn noReturn( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::slot(this) { + match IDiaSymbol_Impl::noReturn(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18002,14 +22847,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn access( + unsafe extern "system" fn customCallingConvention< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::access(this) { + match IDiaSymbol_Impl::customCallingConvention(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18018,14 +22866,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn libraryName( + unsafe extern "system" fn noInline( this: *mut core::ffi::c_void, - pretval: *mut *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::libraryName(this) { + match IDiaSymbol_Impl::noInline(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18034,14 +22882,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn platform( + unsafe extern "system" fn optimizedCodeDebugInfo< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::platform(this) { + match IDiaSymbol_Impl::optimizedCodeDebugInfo(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18050,14 +22901,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn language( + unsafe extern "system" fn notReached( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::language(this) { + match IDiaSymbol_Impl::notReached(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18066,14 +22917,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn frontEndMajor( + unsafe extern "system" fn interruptReturn< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::frontEndMajor(this) { + match IDiaSymbol_Impl::interruptReturn(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18082,14 +22936,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn frontEndMinor( + unsafe extern "system" fn farReturn( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::frontEndMinor(this) { + match IDiaSymbol_Impl::farReturn(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18098,14 +22952,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn frontEndBuild( + unsafe extern "system" fn isStatic( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::frontEndBuild(this) { + match IDiaSymbol_Impl::isStatic(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18114,14 +22968,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn backEndMajor( + unsafe extern "system" fn hasDebugInfo( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::backEndMajor(this) { + match IDiaSymbol_Impl::hasDebugInfo(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18130,14 +22984,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn backEndMinor( + unsafe extern "system" fn isLTCG( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::backEndMinor(this) { + match IDiaSymbol_Impl::isLTCG(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18146,14 +23000,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn backEndBuild( + unsafe extern "system" fn isDataAligned( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::backEndBuild(this) { + match IDiaSymbol_Impl::isDataAligned(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18162,14 +23016,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn sourceFileName( + unsafe extern "system" fn hasSecurityChecks< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::sourceFileName(this) { + match IDiaSymbol_Impl::hasSecurityChecks(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18178,14 +23035,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn unused( + unsafe extern "system" fn compilerName( this: *mut core::ffi::c_void, pretval: *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::unused(this) { + match IDiaSymbol_Impl::compilerName(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18194,14 +23051,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn thunkOrdinal( + unsafe extern "system" fn hasAlloca( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::thunkOrdinal(this) { + match IDiaSymbol_Impl::hasAlloca(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18210,14 +23067,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn thisAdjust( + unsafe extern "system" fn hasSetJump( this: *mut core::ffi::c_void, - pretval: *mut i32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::thisAdjust(this) { + match IDiaSymbol_Impl::hasSetJump(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18226,17 +23083,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn virtualBaseOffset< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn hasLongJump( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::virtualBaseOffset(this) { + match IDiaSymbol_Impl::hasLongJump(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18245,17 +23099,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn callingConvention< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn hasInlAsm( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::callingConvention(this) { + match IDiaSymbol_Impl::hasInlAsm(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18264,14 +23115,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn baseType( + unsafe extern "system" fn hasEH( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::baseType(this) { + match IDiaSymbol_Impl::hasEH(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18280,14 +23131,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn token( + unsafe extern "system" fn hasSEH( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::token(this) { + match IDiaSymbol_Impl::hasSEH(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18296,14 +23147,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn timeStamp( + unsafe extern "system" fn hasEHa( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::timeStamp(this) { + match IDiaSymbol_Impl::hasEHa(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18312,14 +23163,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn guid( + unsafe extern "system" fn isNaked( this: *mut core::ffi::c_void, - pretval: *mut windows_core::GUID, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::guid(this) { + match IDiaSymbol_Impl::isNaked(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18328,17 +23179,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn symbolsFileName< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn isAggregated( this: *mut core::ffi::c_void, - pretval: *mut *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::symbolsFileName(this) { + match IDiaSymbol_Impl::isAggregated(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18347,14 +23195,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn count( + unsafe extern "system" fn isSplitted( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::count(this) { + match IDiaSymbol_Impl::isSplitted(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18363,14 +23211,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn bitPosition( + unsafe extern "system" fn container( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::bitPosition(this) { + match IDiaSymbol_Impl::container(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18379,14 +23227,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn arrayIndexType( + unsafe extern "system" fn inlSpec( this: *mut core::ffi::c_void, - pretval: *mut *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::arrayIndexType(this) { + match IDiaSymbol_Impl::inlSpec(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18395,17 +23243,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn virtualBasePointerOffset< + unsafe extern "system" fn noStackOrdering< Identity: IDiaSymbol_Impl, const OFFSET: isize, >( this: *mut core::ffi::c_void, - pretval: *mut i32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::virtualBasePointerOffset(this) { + match IDiaSymbol_Impl::noStackOrdering(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18414,7 +23262,7 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn virtualTableShape< + unsafe extern "system" fn virtualBaseTableType< Identity: IDiaSymbol_Impl, const OFFSET: isize, >( @@ -18424,7 +23272,7 @@ impl IDiaSymbol_Vtbl { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::virtualTableShape(this) { + match IDiaSymbol_Impl::virtualBaseTableType(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18433,17 +23281,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn lexicalParentId< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn hasManagedCode( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::lexicalParentId(this) { + match IDiaSymbol_Impl::hasManagedCode(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18452,14 +23297,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn classParentId( + unsafe extern "system" fn isHotpatchable( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::classParentId(this) { + match IDiaSymbol_Impl::isHotpatchable(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18468,14 +23313,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn typeId( + unsafe extern "system" fn isCVTCIL( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::typeId(this) { + match IDiaSymbol_Impl::isCVTCIL(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18484,17 +23329,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn arrayIndexTypeId< + unsafe extern "system" fn isMSILNetmodule< Identity: IDiaSymbol_Impl, const OFFSET: isize, >( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::arrayIndexTypeId(this) { + match IDiaSymbol_Impl::isMSILNetmodule(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18503,17 +23348,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn virtualTableShapeId< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn isCTypes( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::virtualTableShapeId(this) { + match IDiaSymbol_Impl::isCTypes(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18522,17 +23364,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn virtualBaseDispIndex< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn isStripped( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::virtualBaseDispIndex(this) { + match IDiaSymbol_Impl::isStripped(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18541,17 +23380,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn undecoratedName< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn frontEndQFE( this: *mut core::ffi::c_void, - pretval: *mut *mut core::ffi::c_void, + pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::undecoratedName(this) { + match IDiaSymbol_Impl::frontEndQFE(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18560,14 +23396,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn age( + unsafe extern "system" fn backEndQFE( this: *mut core::ffi::c_void, pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::age(this) { + match IDiaSymbol_Impl::backEndQFE(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18576,14 +23412,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn signature( + unsafe extern "system" fn wasInlined( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::signature(this) { + match IDiaSymbol_Impl::wasInlined(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18592,14 +23428,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn rank( + unsafe extern "system" fn strictGSCheck( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::rank(this) { + match IDiaSymbol_Impl::strictGSCheck(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18608,14 +23444,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn lowerBound( + unsafe extern "system" fn isCxxReturnUdt( this: *mut core::ffi::c_void, - pretval: *mut *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::lowerBound(this) { + match IDiaSymbol_Impl::isCxxReturnUdt(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18624,14 +23460,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn upperBound( + unsafe extern "system" fn isConstructorVirtualBase< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::upperBound(this) { + match IDiaSymbol_Impl::isConstructorVirtualBase(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18640,14 +23479,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn lowerBoundId( + unsafe extern "system" fn RValueReference< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::lowerBoundId(this) { + match IDiaSymbol_Impl::RValueReference(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18656,14 +23498,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn upperBoundId( + unsafe extern "system" fn unmodifiedType( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::upperBoundId(this) { + match IDiaSymbol_Impl::unmodifiedType(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18672,169 +23514,116 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn get_dataBytes( + unsafe extern "system" fn framePointerPresent< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - cbdata: u32, - pcbdata: *mut u32, - pbdata: *mut u8, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IDiaSymbol_Impl::get_dataBytes( - this, - core::mem::transmute_copy(&cbdata), - core::mem::transmute_copy(&pcbdata), - core::mem::transmute_copy(&pbdata), - ) - .into() + match IDiaSymbol_Impl::framePointerPresent(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } } } - unsafe extern "system" fn findChildren( + unsafe extern "system" fn isSafeBuffers( this: *mut core::ffi::c_void, - symtag: SymTag, - name: windows_core::PCWSTR, - compareflags: u32, - ppresult: *mut *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::findChildren( - this, - core::mem::transmute_copy(&symtag), - core::mem::transmute(&name), - core::mem::transmute_copy(&compareflags), - ) { + match IDiaSymbol_Impl::isSafeBuffers(this) { Ok(ok__) => { - ppresult.write(core::mem::transmute(ok__)); + pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) } Err(err) => err.into(), } } } - unsafe extern "system" fn findChildrenEx( + unsafe extern "system" fn intrinsic( this: *mut core::ffi::c_void, - symtag: SymTag, - name: windows_core::PCWSTR, - compareflags: u32, - ppresult: *mut *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::findChildrenEx( - this, - core::mem::transmute_copy(&symtag), - core::mem::transmute(&name), - core::mem::transmute_copy(&compareflags), - ) { + match IDiaSymbol_Impl::intrinsic(this) { Ok(ok__) => { - ppresult.write(core::mem::transmute(ok__)); + pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) } Err(err) => err.into(), } } } - unsafe extern "system" fn findChildrenExByAddr< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn sealed( this: *mut core::ffi::c_void, - symtag: SymTag, - name: windows_core::PCWSTR, - compareflags: u32, - isect: u32, - offset: u32, - ppresult: *mut *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::findChildrenExByAddr( - this, - core::mem::transmute_copy(&symtag), - core::mem::transmute(&name), - core::mem::transmute_copy(&compareflags), - core::mem::transmute_copy(&isect), - core::mem::transmute_copy(&offset), - ) { + match IDiaSymbol_Impl::sealed(this) { Ok(ok__) => { - ppresult.write(core::mem::transmute(ok__)); + pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) } Err(err) => err.into(), } } } - unsafe extern "system" fn findChildrenExByVA< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn hfaFloat( this: *mut core::ffi::c_void, - symtag: SymTag, - name: windows_core::PCWSTR, - compareflags: u32, - va: u64, - ppresult: *mut *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::findChildrenExByVA( - this, - core::mem::transmute_copy(&symtag), - core::mem::transmute(&name), - core::mem::transmute_copy(&compareflags), - core::mem::transmute_copy(&va), - ) { + match IDiaSymbol_Impl::hfaFloat(this) { Ok(ok__) => { - ppresult.write(core::mem::transmute(ok__)); + pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) } Err(err) => err.into(), } } } - unsafe extern "system" fn findChildrenExByRVA< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn hfaDouble( this: *mut core::ffi::c_void, - symtag: SymTag, - name: windows_core::PCWSTR, - compareflags: u32, - rva: u32, - ppresult: *mut *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::findChildrenExByRVA( - this, - core::mem::transmute_copy(&symtag), - core::mem::transmute(&name), - core::mem::transmute_copy(&compareflags), - core::mem::transmute_copy(&rva), - ) { + match IDiaSymbol_Impl::hfaDouble(this) { Ok(ok__) => { - ppresult.write(core::mem::transmute(ok__)); + pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) } Err(err) => err.into(), } } } - unsafe extern "system" fn targetSection( + unsafe extern "system" fn liveRangeStartAddressSection< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::targetSection(this) { + match IDiaSymbol_Impl::liveRangeStartAddressSection(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18843,14 +23632,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn targetOffset( + unsafe extern "system" fn liveRangeStartAddressOffset< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::targetOffset(this) { + match IDiaSymbol_Impl::liveRangeStartAddressOffset(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18859,7 +23651,7 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn targetRelativeVirtualAddress< + unsafe extern "system" fn liveRangeStartRelativeVirtualAddress< Identity: IDiaSymbol_Impl, const OFFSET: isize, >( @@ -18869,7 +23661,7 @@ impl IDiaSymbol_Vtbl { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::targetRelativeVirtualAddress(this) { + match IDiaSymbol_Impl::liveRangeStartRelativeVirtualAddress(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18878,17 +23670,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn targetVirtualAddress< + unsafe extern "system" fn countLiveRanges< Identity: IDiaSymbol_Impl, const OFFSET: isize, >( this: *mut core::ffi::c_void, - pretval: *mut u64, + pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::targetVirtualAddress(this) { + match IDiaSymbol_Impl::countLiveRanges(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18897,14 +23689,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn machineType( + unsafe extern "system" fn liveRangeLength< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut u64, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::machineType(this) { + match IDiaSymbol_Impl::liveRangeLength(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18913,14 +23708,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn oemId( + unsafe extern "system" fn offsetInUdt( this: *mut core::ffi::c_void, pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::oemId(this) { + match IDiaSymbol_Impl::offsetInUdt(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18929,14 +23724,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn oemSymbolId( + unsafe extern "system" fn paramBasePointerRegisterId< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::oemSymbolId(this) { + match IDiaSymbol_Impl::paramBasePointerRegisterId(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -18945,53 +23743,52 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn get_types( + unsafe extern "system" fn localBasePointerRegisterId< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - ctypes: u32, - pctypes: *mut u32, - ptypes: *mut *mut core::ffi::c_void, + pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IDiaSymbol_Impl::get_types( - this, - core::mem::transmute_copy(&ctypes), - core::mem::transmute_copy(&pctypes), - core::mem::transmute_copy(&ptypes), - ) - .into() + match IDiaSymbol_Impl::localBasePointerRegisterId(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } } } - unsafe extern "system" fn get_typeIds( + unsafe extern "system" fn isLocationControlFlowDependent< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - ctypeids: u32, - pctypeids: *mut u32, - pdwtypeids: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IDiaSymbol_Impl::get_typeIds( - this, - core::mem::transmute_copy(&ctypeids), - core::mem::transmute_copy(&pctypeids), - core::mem::transmute_copy(&pdwtypeids), - ) - .into() + match IDiaSymbol_Impl::isLocationControlFlowDependent(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } } } - unsafe extern "system" fn objectPointerType< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn stride( this: *mut core::ffi::c_void, - pretval: *mut *mut core::ffi::c_void, + pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::objectPointerType(this) { + match IDiaSymbol_Impl::stride(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19000,14 +23797,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn udtKind( + unsafe extern "system" fn numberOfRows( this: *mut core::ffi::c_void, pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::udtKind(this) { + match IDiaSymbol_Impl::numberOfRows(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19016,37 +23813,36 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn get_undecoratedNameEx< + unsafe extern "system" fn numberOfColumns< Identity: IDiaSymbol_Impl, const OFFSET: isize, >( this: *mut core::ffi::c_void, - undecorateoptions: u32, - name: *mut *mut core::ffi::c_void, + pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::get_undecoratedNameEx( - this, - core::mem::transmute_copy(&undecorateoptions), - ) { + match IDiaSymbol_Impl::numberOfColumns(this) { Ok(ok__) => { - name.write(core::mem::transmute(ok__)); + pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) } Err(err) => err.into(), } } } - unsafe extern "system" fn compilerName( + unsafe extern "system" fn isMatrixRowMajor< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::compilerName(this) { + match IDiaSymbol_Impl::isMatrixRowMajor(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19055,14 +23851,56 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn container( + unsafe extern "system" fn get_numericProperties< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut *mut core::ffi::c_void, + cnt: u32, + pcnt: *mut u32, + pproperties: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::container(this) { + IDiaSymbol_Impl::get_numericProperties( + this, + core::mem::transmute_copy(&cnt), + core::mem::transmute_copy(&pcnt), + core::mem::transmute_copy(&pproperties), + ) + .into() + } + } + unsafe extern "system" fn get_modifierValues< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + cnt: u32, + pcnt: *mut u32, + pmodifiers: *mut u16, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IDiaSymbol_Impl::get_modifierValues( + this, + core::mem::transmute_copy(&cnt), + core::mem::transmute_copy(&pcnt), + core::mem::transmute_copy(&pmodifiers), + ) + .into() + } + } + unsafe extern "system" fn isReturnValue( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::isReturnValue(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19071,17 +23909,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn virtualBaseTableType< + unsafe extern "system" fn isOptimizedAway< Identity: IDiaSymbol_Impl, const OFFSET: isize, >( this: *mut core::ffi::c_void, - pretval: *mut *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::virtualBaseTableType(this) { + match IDiaSymbol_Impl::isOptimizedAway(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19090,14 +23928,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn frontEndQFE( + unsafe extern "system" fn builtInKind( this: *mut core::ffi::c_void, pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::frontEndQFE(this) { + match IDiaSymbol_Impl::builtInKind(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19106,14 +23944,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn backEndQFE( + unsafe extern "system" fn registerType( this: *mut core::ffi::c_void, pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::backEndQFE(this) { + match IDiaSymbol_Impl::registerType(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19122,14 +23960,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn unmodifiedType( + unsafe extern "system" fn baseDataSlot( this: *mut core::ffi::c_void, - pretval: *mut *mut core::ffi::c_void, + pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::unmodifiedType(this) { + match IDiaSymbol_Impl::baseDataSlot(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19138,17 +23976,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn liveRangeStartAddressSection< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn baseDataOffset( this: *mut core::ffi::c_void, pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::liveRangeStartAddressSection(this) { + match IDiaSymbol_Impl::baseDataOffset(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19157,17 +23992,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn liveRangeStartAddressOffset< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn textureSlot( this: *mut core::ffi::c_void, pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::liveRangeStartAddressOffset(this) { + match IDiaSymbol_Impl::textureSlot(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19176,17 +24008,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn liveRangeStartRelativeVirtualAddress< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn samplerSlot( this: *mut core::ffi::c_void, pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::liveRangeStartRelativeVirtualAddress(this) { + match IDiaSymbol_Impl::samplerSlot(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19195,17 +24024,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn countLiveRanges< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn uavSlot( this: *mut core::ffi::c_void, pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::countLiveRanges(this) { + match IDiaSymbol_Impl::uavSlot(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19214,17 +24040,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn liveRangeLength< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn sizeInUdt( this: *mut core::ffi::c_void, - pretval: *mut u64, + pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::liveRangeLength(this) { + match IDiaSymbol_Impl::sizeInUdt(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19233,14 +24056,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn offsetInUdt( + unsafe extern "system" fn memorySpaceKind< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::offsetInUdt(this) { + match IDiaSymbol_Impl::memorySpaceKind(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19249,7 +24075,7 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn paramBasePointerRegisterId< + unsafe extern "system" fn unmodifiedTypeId< Identity: IDiaSymbol_Impl, const OFFSET: isize, >( @@ -19259,7 +24085,7 @@ impl IDiaSymbol_Vtbl { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::paramBasePointerRegisterId(this) { + match IDiaSymbol_Impl::unmodifiedTypeId(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19268,17 +24094,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn localBasePointerRegisterId< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn subTypeId( this: *mut core::ffi::c_void, pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::localBasePointerRegisterId(this) { + match IDiaSymbol_Impl::subTypeId(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19287,14 +24110,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn stride( + unsafe extern "system" fn subType( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::stride(this) { + match IDiaSymbol_Impl::subType(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19303,14 +24126,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn numberOfRows( + unsafe extern "system" fn numberOfModifiers< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::numberOfRows(this) { + match IDiaSymbol_Impl::numberOfModifiers(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19319,7 +24145,7 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn numberOfColumns< + unsafe extern "system" fn numberOfRegisterIndices< Identity: IDiaSymbol_Impl, const OFFSET: isize, >( @@ -19329,7 +24155,7 @@ impl IDiaSymbol_Vtbl { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::numberOfColumns(this) { + match IDiaSymbol_Impl::numberOfRegisterIndices(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19338,56 +24164,52 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn get_numericProperties< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn isHLSLData( this: *mut core::ffi::c_void, - cnt: u32, - pcnt: *mut u32, - pproperties: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IDiaSymbol_Impl::get_numericProperties( - this, - core::mem::transmute_copy(&cnt), - core::mem::transmute_copy(&pcnt), - core::mem::transmute_copy(&pproperties), - ) - .into() + match IDiaSymbol_Impl::isHLSLData(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } } } - unsafe extern "system" fn get_modifierValues< + unsafe extern "system" fn isPointerToDataMember< Identity: IDiaSymbol_Impl, const OFFSET: isize, >( this: *mut core::ffi::c_void, - cnt: u32, - pcnt: *mut u32, - pmodifiers: *mut u16, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IDiaSymbol_Impl::get_modifierValues( - this, - core::mem::transmute_copy(&cnt), - core::mem::transmute_copy(&pcnt), - core::mem::transmute_copy(&pmodifiers), - ) - .into() + match IDiaSymbol_Impl::isPointerToDataMember(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } } } - unsafe extern "system" fn builtInKind( + unsafe extern "system" fn isPointerToMemberFunction< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::builtInKind(this) { + match IDiaSymbol_Impl::isPointerToMemberFunction(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19396,14 +24218,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn registerType( + unsafe extern "system" fn isSingleInheritance< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::registerType(this) { + match IDiaSymbol_Impl::isSingleInheritance(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19412,14 +24237,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn baseDataSlot( + unsafe extern "system" fn isMultipleInheritance< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::baseDataSlot(this) { + match IDiaSymbol_Impl::isMultipleInheritance(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19428,14 +24256,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn baseDataOffset( + unsafe extern "system" fn isVirtualInheritance< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::baseDataOffset(this) { + match IDiaSymbol_Impl::isVirtualInheritance(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19444,14 +24275,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn textureSlot( + unsafe extern "system" fn restrictedType( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::textureSlot(this) { + match IDiaSymbol_Impl::restrictedType(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19460,14 +24291,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn samplerSlot( + unsafe extern "system" fn isPointerBasedOnSymbolValue< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::samplerSlot(this) { + match IDiaSymbol_Impl::isPointerBasedOnSymbolValue(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19476,14 +24310,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn uavSlot( + unsafe extern "system" fn baseSymbol( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::uavSlot(this) { + match IDiaSymbol_Impl::baseSymbol(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19492,14 +24326,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn sizeInUdt( + unsafe extern "system" fn baseSymbolId( this: *mut core::ffi::c_void, pretval: *mut u32, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::sizeInUdt(this) { + match IDiaSymbol_Impl::baseSymbolId(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19508,17 +24342,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn memorySpaceKind< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn objectFileName( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::memorySpaceKind(this) { + match IDiaSymbol_Impl::objectFileName(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19527,17 +24358,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn unmodifiedTypeId< + unsafe extern "system" fn isAcceleratorGroupSharedLocal< Identity: IDiaSymbol_Impl, const OFFSET: isize, >( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::unmodifiedTypeId(this) { + match IDiaSymbol_Impl::isAcceleratorGroupSharedLocal(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19546,14 +24377,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn subTypeId( + unsafe extern "system" fn isAcceleratorPointerTagLiveRange< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::subTypeId(this) { + match IDiaSymbol_Impl::isAcceleratorPointerTagLiveRange(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19562,14 +24396,17 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn subType( + unsafe extern "system" fn isAcceleratorStubFunction< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( this: *mut core::ffi::c_void, - pretval: *mut *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::subType(this) { + match IDiaSymbol_Impl::isAcceleratorStubFunction(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19578,7 +24415,7 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn numberOfModifiers< + unsafe extern "system" fn numberOfAcceleratorPointerTags< Identity: IDiaSymbol_Impl, const OFFSET: isize, >( @@ -19588,7 +24425,7 @@ impl IDiaSymbol_Vtbl { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::numberOfModifiers(this) { + match IDiaSymbol_Impl::numberOfAcceleratorPointerTags(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19597,17 +24434,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn numberOfRegisterIndices< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn isSdl( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::numberOfRegisterIndices(this) { + match IDiaSymbol_Impl::isSdl(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19616,14 +24450,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn baseSymbol( + unsafe extern "system" fn isWinRTPointer( this: *mut core::ffi::c_void, - pretval: *mut *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::baseSymbol(this) { + match IDiaSymbol_Impl::isWinRTPointer(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19632,14 +24466,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn baseSymbolId( + unsafe extern "system" fn isRefUdt( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::baseSymbolId(this) { + match IDiaSymbol_Impl::isRefUdt(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19648,14 +24482,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn objectFileName( + unsafe extern "system" fn isValueUdt( this: *mut core::ffi::c_void, - pretval: *mut *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::objectFileName(this) { + match IDiaSymbol_Impl::isValueUdt(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19664,17 +24498,14 @@ impl IDiaSymbol_Vtbl { } } } - unsafe extern "system" fn numberOfAcceleratorPointerTags< - Identity: IDiaSymbol_Impl, - const OFFSET: isize, - >( + unsafe extern "system" fn isInterfaceUdt( this: *mut core::ffi::c_void, - pretval: *mut u32, + pretval: *mut windows::Win32::Foundation::BOOL, ) -> windows_core::HRESULT { unsafe { let this: &Identity = &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IDiaSymbol_Impl::numberOfAcceleratorPointerTags(this) { + match IDiaSymbol_Impl::isInterfaceUdt(this) { Ok(ok__) => { pretval.write(core::mem::transmute(ok__)); windows_core::HRESULT(0) @@ -19933,6 +24764,60 @@ impl IDiaSymbol_Vtbl { } } } + unsafe extern "system" fn isPGO( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::isPGO(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn hasValidPGOCounts< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::hasValidPGOCounts(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn isOptimizedForSpeed< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::isOptimizedForSpeed(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } unsafe extern "system" fn PGOEntryCount( this: *mut core::ffi::c_void, pretval: *mut u32, @@ -20035,6 +24920,127 @@ impl IDiaSymbol_Vtbl { } } } + unsafe extern "system" fn hasControlFlowCheck< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::hasControlFlowCheck(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn constantExport( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::constantExport(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn dataExport( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::dataExport(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn privateExport( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::privateExport(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn noNameExport( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::noNameExport(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn exportHasExplicitlyAssignedOrdinal< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::exportHasExplicitlyAssignedOrdinal(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn exportIsForwarder< + Identity: IDiaSymbol_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol_Impl::exportIsForwarder(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } unsafe extern "system" fn ordinal( this: *mut core::ffi::c_void, pretval: *mut u32, @@ -20263,14 +25269,14 @@ impl IDiaSymbol_Vtbl { offset: offset::, length: length::, slot: slot::, - get_volatileType: 0, - get_constType: 0, - get_unalignedType: 0, + volatileType: volatileType::, + constType: constType::, + unalignedType: unalignedType::, access: access::, libraryName: libraryName::, platform: platform::, language: language::, - get_editAndContinueEnabled: 0, + editAndContinueEnabled: editAndContinueEnabled::, frontEndMajor: frontEndMajor::, frontEndMinor: frontEndMinor::, frontEndBuild: frontEndBuild::, @@ -20282,30 +25288,30 @@ impl IDiaSymbol_Vtbl { thunkOrdinal: thunkOrdinal::, thisAdjust: thisAdjust::, virtualBaseOffset: virtualBaseOffset::, - get_virtual: 0, - get_intro: 0, - get_pure: 0, + r#virtual: r#virtual::, + intro: intro::, + pure: pure::, callingConvention: callingConvention::, - get_value: 0, + value: value::, baseType: baseType::, token: token::, timeStamp: timeStamp::, guid: guid::, symbolsFileName: symbolsFileName::, - get_reference: 0, + reference: reference::, count: count::, bitPosition: bitPosition::, arrayIndexType: arrayIndexType::, - get_packed: 0, - get_constructor: 0, - get_overloadedOperator: 0, - get_nested: 0, - get_hasNestedTypes: 0, - get_hasAssignmentOperator: 0, - get_hasCastOperator: 0, - get_scoped: 0, - get_virtualBaseClass: 0, - get_indirectVirtualBaseClass: 0, + packed: packed::, + constructor: constructor::, + overloadedOperator: overloadedOperator::, + nested: nested::, + hasNestedTypes: hasNestedTypes::, + hasAssignmentOperator: hasAssignmentOperator::, + hasCastOperator: hasCastOperator::, + scoped: scoped::, + virtualBaseClass: virtualBaseClass::, + indirectVirtualBaseClass: indirectVirtualBaseClass::, virtualBasePointerOffset: virtualBasePointerOffset::, virtualTableShape: virtualTableShape::, lexicalParentId: lexicalParentId::, @@ -20313,16 +25319,16 @@ impl IDiaSymbol_Vtbl { typeId: typeId::, arrayIndexTypeId: arrayIndexTypeId::, virtualTableShapeId: virtualTableShapeId::, - get_code: 0, - get_function: 0, - get_managed: 0, - get_msil: 0, + code: code::, + function: function::, + managed: managed::, + msil: msil::, virtualBaseDispIndex: virtualBaseDispIndex::, undecoratedName: undecoratedName::, age: age::, signature: signature::, - get_compilerGenerated: 0, - get_addressTaken: 0, + compilerGenerated: compilerGenerated::, + addressTaken: addressTaken::, rank: rank::, lowerBound: lowerBound::, upperBound: upperBound::, @@ -20346,53 +25352,53 @@ impl IDiaSymbol_Vtbl { objectPointerType: objectPointerType::, udtKind: udtKind::, get_undecoratedNameEx: get_undecoratedNameEx::, - get_noReturn: 0, - get_customCallingConvention: 0, - get_noInline: 0, - get_optimizedCodeDebugInfo: 0, - get_notReached: 0, - get_interruptReturn: 0, - get_farReturn: 0, - get_isStatic: 0, - get_hasDebugInfo: 0, - get_isLTCG: 0, - get_isDataAligned: 0, - get_hasSecurityChecks: 0, + noReturn: noReturn::, + customCallingConvention: customCallingConvention::, + noInline: noInline::, + optimizedCodeDebugInfo: optimizedCodeDebugInfo::, + notReached: notReached::, + interruptReturn: interruptReturn::, + farReturn: farReturn::, + isStatic: isStatic::, + hasDebugInfo: hasDebugInfo::, + isLTCG: isLTCG::, + isDataAligned: isDataAligned::, + hasSecurityChecks: hasSecurityChecks::, compilerName: compilerName::, - get_hasAlloca: 0, - get_hasSetJump: 0, - get_hasLongJump: 0, - get_hasInlAsm: 0, - get_hasEH: 0, - get_hasSEH: 0, - get_hasEHa: 0, - get_isNaked: 0, - get_isAggregated: 0, - get_isSplitted: 0, + hasAlloca: hasAlloca::, + hasSetJump: hasSetJump::, + hasLongJump: hasLongJump::, + hasInlAsm: hasInlAsm::, + hasEH: hasEH::, + hasSEH: hasSEH::, + hasEHa: hasEHa::, + isNaked: isNaked::, + isAggregated: isAggregated::, + isSplitted: isSplitted::, container: container::, - get_inlSpec: 0, - get_noStackOrdering: 0, + inlSpec: inlSpec::, + noStackOrdering: noStackOrdering::, virtualBaseTableType: virtualBaseTableType::, - get_hasManagedCode: 0, - get_isHotpatchable: 0, - get_isCVTCIL: 0, - get_isMSILNetmodule: 0, - get_isCTypes: 0, - get_isStripped: 0, + hasManagedCode: hasManagedCode::, + isHotpatchable: isHotpatchable::, + isCVTCIL: isCVTCIL::, + isMSILNetmodule: isMSILNetmodule::, + isCTypes: isCTypes::, + isStripped: isStripped::, frontEndQFE: frontEndQFE::, backEndQFE: backEndQFE::, - get_wasInlined: 0, - get_strictGSCheck: 0, - get_isCxxReturnUdt: 0, - get_isConstructorVirtualBase: 0, - get_RValueReference: 0, + wasInlined: wasInlined::, + strictGSCheck: strictGSCheck::, + isCxxReturnUdt: isCxxReturnUdt::, + isConstructorVirtualBase: isConstructorVirtualBase::, + RValueReference: RValueReference::, unmodifiedType: unmodifiedType::, - get_framePointerPresent: 0, - get_isSafeBuffers: 0, - get_intrinsic: 0, - get_sealed: 0, - get_hfaFloat: 0, - get_hfaDouble: 0, + framePointerPresent: framePointerPresent::, + isSafeBuffers: isSafeBuffers::, + intrinsic: intrinsic::, + sealed: sealed::, + hfaFloat: hfaFloat::, + hfaDouble: hfaDouble::, liveRangeStartAddressSection: liveRangeStartAddressSection::, liveRangeStartAddressOffset: liveRangeStartAddressOffset::, liveRangeStartRelativeVirtualAddress: liveRangeStartRelativeVirtualAddress::< @@ -20404,15 +25410,15 @@ impl IDiaSymbol_Vtbl { offsetInUdt: offsetInUdt::, paramBasePointerRegisterId: paramBasePointerRegisterId::, localBasePointerRegisterId: localBasePointerRegisterId::, - get_isLocationControlFlowDependent: 0, + isLocationControlFlowDependent: isLocationControlFlowDependent::, stride: stride::, numberOfRows: numberOfRows::, numberOfColumns: numberOfColumns::, - get_isMatrixRowMajor: 0, + isMatrixRowMajor: isMatrixRowMajor::, get_numericProperties: get_numericProperties::, get_modifierValues: get_modifierValues::, - get_isReturnValue: 0, - get_isOptimizedAway: 0, + isReturnValue: isReturnValue::, + isOptimizedAway: isOptimizedAway::, builtInKind: builtInKind::, registerType: registerType::, baseDataSlot: baseDataSlot::, @@ -20427,26 +25433,26 @@ impl IDiaSymbol_Vtbl { subType: subType::, numberOfModifiers: numberOfModifiers::, numberOfRegisterIndices: numberOfRegisterIndices::, - get_isHLSLData: 0, - get_isPointerToDataMember: 0, - get_isPointerToMemberFunction: 0, - get_isSingleInheritance: 0, - get_isMultipleInheritance: 0, - get_isVirtualInheritance: 0, - get_restrictedType: 0, - get_isPointerBasedOnSymbolValue: 0, + isHLSLData: isHLSLData::, + isPointerToDataMember: isPointerToDataMember::, + isPointerToMemberFunction: isPointerToMemberFunction::, + isSingleInheritance: isSingleInheritance::, + isMultipleInheritance: isMultipleInheritance::, + isVirtualInheritance: isVirtualInheritance::, + restrictedType: restrictedType::, + isPointerBasedOnSymbolValue: isPointerBasedOnSymbolValue::, baseSymbol: baseSymbol::, baseSymbolId: baseSymbolId::, objectFileName: objectFileName::, - get_isAcceleratorGroupSharedLocal: 0, - get_isAcceleratorPointerTagLiveRange: 0, - get_isAcceleratorStubFunction: 0, + isAcceleratorGroupSharedLocal: isAcceleratorGroupSharedLocal::, + isAcceleratorPointerTagLiveRange: isAcceleratorPointerTagLiveRange::, + isAcceleratorStubFunction: isAcceleratorStubFunction::, numberOfAcceleratorPointerTags: numberOfAcceleratorPointerTags::, - get_isSdl: 0, - get_isWinRTPointer: 0, - get_isRefUdt: 0, - get_isValueUdt: 0, - get_isInterfaceUdt: 0, + isSdl: isSdl::, + isWinRTPointer: isWinRTPointer::, + isRefUdt: isRefUdt::, + isValueUdt: isValueUdt::, + isInterfaceUdt: isInterfaceUdt::, findInlineFramesByAddr: findInlineFramesByAddr::, findInlineFramesByRVA: findInlineFramesByRVA::, findInlineFramesByVA: findInlineFramesByVA::, @@ -20464,22 +25470,25 @@ impl IDiaSymbol_Vtbl { >, get_acceleratorPointerTags: get_acceleratorPointerTags::, getSrcLineOnTypeDefn: getSrcLineOnTypeDefn::, - get_isPGO: 0, - get_hasValidPGOCounts: 0, - get_isOptimizedForSpeed: 0, + isPGO: isPGO::, + hasValidPGOCounts: hasValidPGOCounts::, + isOptimizedForSpeed: isOptimizedForSpeed::, PGOEntryCount: PGOEntryCount::, PGOEdgeCount: PGOEdgeCount::, PGODynamicInstructionCount: PGODynamicInstructionCount::, staticSize: staticSize::, finalLiveStaticSize: finalLiveStaticSize::, phaseName: phaseName::, - get_hasControlFlowCheck: 0, - get_constantExport: 0, - get_dataExport: 0, - get_privateExport: 0, - get_noNameExport: 0, - get_exportHasExplicitlyAssignedOrdinal: 0, - get_exportIsForwarder: 0, + hasControlFlowCheck: hasControlFlowCheck::, + constantExport: constantExport::, + dataExport: dataExport::, + privateExport: privateExport::, + noNameExport: noNameExport::, + exportHasExplicitlyAssignedOrdinal: exportHasExplicitlyAssignedOrdinal::< + Identity, + OFFSET, + >, + exportIsForwarder: exportIsForwarder::, ordinal: ordinal::, frameSize: frameSize::, exceptionHandlerAddressSection: exceptionHandlerAddressSection::, @@ -20767,21 +25776,120 @@ impl core::ops::Deref for IDiaSymbol2 { } } windows_core::imp::interface_hierarchy!(IDiaSymbol2, windows_core::IUnknown, IDiaSymbol); +impl IDiaSymbol2 { + pub unsafe fn isObjCClass(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isObjCClass)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn isObjCCategory(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isObjCCategory)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn isObjCProtocol(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isObjCProtocol)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } +} #[repr(C)] pub struct IDiaSymbol2_Vtbl { pub base__: IDiaSymbol_Vtbl, - get_isObjCClass: usize, - get_isObjCCategory: usize, - get_isObjCProtocol: usize, + pub isObjCClass: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isObjCCategory: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, + pub isObjCProtocol: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, +} +pub trait IDiaSymbol2_Impl: IDiaSymbol_Impl { + fn isObjCClass(&self) -> windows_core::Result; + fn isObjCCategory(&self) -> windows_core::Result; + fn isObjCProtocol(&self) -> windows_core::Result; } -pub trait IDiaSymbol2_Impl: IDiaSymbol_Impl {} impl IDiaSymbol2_Vtbl { pub const fn new() -> Self { + unsafe extern "system" fn isObjCClass( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol2_Impl::isObjCClass(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn isObjCCategory< + Identity: IDiaSymbol2_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol2_Impl::isObjCCategory(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn isObjCProtocol< + Identity: IDiaSymbol2_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol2_Impl::isObjCProtocol(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } Self { base__: IDiaSymbol_Vtbl::new::(), - get_isObjCClass: 0, - get_isObjCCategory: 0, - get_isObjCProtocol: 0, + isObjCClass: isObjCClass::, + isObjCCategory: isObjCCategory::, + isObjCProtocol: isObjCProtocol::, } } pub fn matches(iid: &windows_core::GUID) -> bool { @@ -20908,17 +26016,50 @@ windows_core::imp::interface_hierarchy!( IDiaSymbol2, IDiaSymbol3 ); +impl IDiaSymbol4 { + pub unsafe fn noexcept(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).noexcept)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } +} #[repr(C)] pub struct IDiaSymbol4_Vtbl { pub base__: IDiaSymbol3_Vtbl, - get_noexcept: usize, + pub noexcept: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, +} +pub trait IDiaSymbol4_Impl: IDiaSymbol3_Impl { + fn noexcept(&self) -> windows_core::Result; } -pub trait IDiaSymbol4_Impl: IDiaSymbol3_Impl {} impl IDiaSymbol4_Vtbl { pub const fn new() -> Self { + unsafe extern "system" fn noexcept( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol4_Impl::noexcept(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } Self { base__: IDiaSymbol3_Vtbl::new::(), - get_noexcept: 0, + noexcept: noexcept::, } } pub fn matches(iid: &windows_core::GUID) -> bool { @@ -20948,17 +26089,55 @@ windows_core::imp::interface_hierarchy!( IDiaSymbol3, IDiaSymbol4 ); +impl IDiaSymbol5 { + pub unsafe fn hasAbsoluteAddress( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).hasAbsoluteAddress)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } +} #[repr(C)] pub struct IDiaSymbol5_Vtbl { pub base__: IDiaSymbol4_Vtbl, - get_hasAbsoluteAddress: usize, + pub hasAbsoluteAddress: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, +} +pub trait IDiaSymbol5_Impl: IDiaSymbol4_Impl { + fn hasAbsoluteAddress(&self) -> windows_core::Result; } -pub trait IDiaSymbol5_Impl: IDiaSymbol4_Impl {} impl IDiaSymbol5_Vtbl { pub const fn new() -> Self { + unsafe extern "system" fn hasAbsoluteAddress< + Identity: IDiaSymbol5_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol5_Impl::hasAbsoluteAddress(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } Self { base__: IDiaSymbol4_Vtbl::new::(), - get_hasAbsoluteAddress: 0, + hasAbsoluteAddress: hasAbsoluteAddress::, } } pub fn matches(iid: &windows_core::GUID) -> bool { @@ -20990,17 +26169,55 @@ windows_core::imp::interface_hierarchy!( IDiaSymbol4, IDiaSymbol5 ); +impl IDiaSymbol6 { + pub unsafe fn isStaticMemberFunc( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isStaticMemberFunc)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } +} #[repr(C)] pub struct IDiaSymbol6_Vtbl { pub base__: IDiaSymbol5_Vtbl, - get_isStaticMemberFunc: usize, + pub isStaticMemberFunc: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, +} +pub trait IDiaSymbol6_Impl: IDiaSymbol5_Impl { + fn isStaticMemberFunc(&self) -> windows_core::Result; } -pub trait IDiaSymbol6_Impl: IDiaSymbol5_Impl {} impl IDiaSymbol6_Vtbl { pub const fn new() -> Self { + unsafe extern "system" fn isStaticMemberFunc< + Identity: IDiaSymbol6_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol6_Impl::isStaticMemberFunc(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } Self { base__: IDiaSymbol5_Vtbl::new::(), - get_isStaticMemberFunc: 0, + isStaticMemberFunc: isStaticMemberFunc::, } } pub fn matches(iid: &windows_core::GUID) -> bool { @@ -21034,17 +26251,50 @@ windows_core::imp::interface_hierarchy!( IDiaSymbol5, IDiaSymbol6 ); +impl IDiaSymbol7 { + pub unsafe fn isSignRet(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isSignRet)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } +} #[repr(C)] pub struct IDiaSymbol7_Vtbl { pub base__: IDiaSymbol6_Vtbl, - get_isSignRet: usize, + pub isSignRet: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, +} +pub trait IDiaSymbol7_Impl: IDiaSymbol6_Impl { + fn isSignRet(&self) -> windows_core::Result; } -pub trait IDiaSymbol7_Impl: IDiaSymbol6_Impl {} impl IDiaSymbol7_Vtbl { pub const fn new() -> Self { + unsafe extern "system" fn isSignRet( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol7_Impl::isSignRet(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } Self { base__: IDiaSymbol6_Vtbl::new::(), - get_isSignRet: 0, + isSignRet: isSignRet::, } } pub fn matches(iid: &windows_core::GUID) -> bool { @@ -21345,6 +26595,16 @@ impl IDiaSymbol9 { .map(|| result__) } } + pub unsafe fn isRTCs(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).isRTCs)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } } #[repr(C)] pub struct IDiaSymbol9_Vtbl { @@ -21353,11 +26613,15 @@ pub struct IDiaSymbol9_Vtbl { unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, pub framePadOffset: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - get_isRTCs: usize, + pub isRTCs: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT, } pub trait IDiaSymbol9_Impl: IDiaSymbol8_Impl { fn framePadSize(&self) -> windows_core::Result; fn framePadOffset(&self) -> windows_core::Result; + fn isRTCs(&self) -> windows_core::Result; } impl IDiaSymbol9_Vtbl { pub const fn new() -> Self { @@ -21396,11 +26660,27 @@ impl IDiaSymbol9_Vtbl { } } } + unsafe extern "system" fn isRTCs( + this: *mut core::ffi::c_void, + pretval: *mut windows::Win32::Foundation::BOOL, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IDiaSymbol9_Impl::isRTCs(this) { + Ok(ok__) => { + pretval.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } Self { base__: IDiaSymbol8_Vtbl::new::(), framePadSize: framePadSize::, framePadOffset: framePadOffset::, - get_isRTCs: 0, + isRTCs: isRTCs::, } } pub fn matches(iid: &windows_core::GUID) -> bool { @@ -21422,12 +26702,16 @@ windows_core::imp::define_interface!( 0x4a59fb77_abac_469b_a30b_9ecc85bfef14 ); impl core::ops::Deref for IDiaTable { - type Target = IEnumUnknown; + type Target = windows::Win32::System::Com::IEnumUnknown; fn deref(&self) -> &Self::Target { unsafe { core::mem::transmute(self) } } } -windows_core::imp::interface_hierarchy!(IDiaTable, windows_core::IUnknown, IEnumUnknown); +windows_core::imp::interface_hierarchy!( + IDiaTable, + windows_core::IUnknown, + windows::Win32::System::Com::IEnumUnknown +); impl IDiaTable { pub unsafe fn _NewEnum(&self) -> windows_core::Result { unsafe { @@ -21473,7 +26757,7 @@ impl IDiaTable { } #[repr(C)] pub struct IDiaTable_Vtbl { - pub base__: IEnumUnknown_Vtbl, + pub base__: windows::Win32::System::Com::IEnumUnknown_Vtbl, pub _NewEnum: unsafe extern "system" fn( *mut core::ffi::c_void, *mut *mut core::ffi::c_void, @@ -21489,7 +26773,7 @@ pub struct IDiaTable_Vtbl { *mut *mut core::ffi::c_void, ) -> windows_core::HRESULT, } -pub trait IDiaTable_Impl: IEnumUnknown_Impl { +pub trait IDiaTable_Impl: windows::Win32::System::Com::IEnumUnknown_Impl { fn _NewEnum(&self) -> windows_core::Result; fn name(&self) -> windows_core::Result; fn Count(&self) -> windows_core::Result; @@ -21563,7 +26847,7 @@ impl IDiaTable_Vtbl { } } Self { - base__: IEnumUnknown_Vtbl::new::(), + base__: windows::Win32::System::Com::IEnumUnknown_Vtbl::new::(), _NewEnum: _NewEnum::, name: name::, Count: Count::, @@ -21572,151 +26856,10 @@ impl IDiaTable_Vtbl { } pub fn matches(iid: &windows_core::GUID) -> bool { iid == &::IID - || iid == &::IID + || iid == &::IID } } impl windows_core::RuntimeName for IDiaTable {} -windows_core::imp::define_interface!( - IEnumUnknown, - IEnumUnknown_Vtbl, - 0x00000100_0000_0000_c000_000000000046 -); -windows_core::imp::interface_hierarchy!(IEnumUnknown, windows_core::IUnknown); -impl IEnumUnknown { - pub unsafe fn Next( - &self, - rgelt: &mut [Option], - pceltfetched: Option<*mut u32>, - ) -> windows_core::HRESULT { - unsafe { - (windows_core::Interface::vtable(self).Next)( - windows_core::Interface::as_raw(self), - rgelt.len().try_into().unwrap(), - core::mem::transmute(rgelt.as_ptr()), - pceltfetched.unwrap_or(core::mem::zeroed()) as _, - ) - } - } - pub unsafe fn Skip(&self, celt: u32) -> windows_core::Result<()> { - unsafe { - (windows_core::Interface::vtable(self).Skip)( - windows_core::Interface::as_raw(self), - celt, - ) - .ok() - } - } - pub unsafe fn Reset(&self) -> windows_core::Result<()> { - unsafe { - (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self)) - .ok() - } - } - pub unsafe fn Clone(&self) -> windows_core::Result { - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).Clone)( - windows_core::Interface::as_raw(self), - &mut result__, - ) - .and_then(|| windows_core::Type::from_abi(result__)) - } - } -} -#[repr(C)] -pub struct IEnumUnknown_Vtbl { - pub base__: windows_core::IUnknown_Vtbl, - pub Next: unsafe extern "system" fn( - *mut core::ffi::c_void, - u32, - *mut *mut core::ffi::c_void, - *mut u32, - ) -> windows_core::HRESULT, - pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT, - pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, - pub Clone: unsafe extern "system" fn( - *mut core::ffi::c_void, - *mut *mut core::ffi::c_void, - ) -> windows_core::HRESULT, -} -pub trait IEnumUnknown_Impl: windows_core::IUnknownImpl { - fn Next( - &self, - celt: u32, - rgelt: windows_core::OutRef<'_, windows_core::IUnknown>, - pceltfetched: *mut u32, - ) -> windows_core::HRESULT; - fn Skip(&self, celt: u32) -> windows_core::Result<()>; - fn Reset(&self) -> windows_core::Result<()>; - fn Clone(&self) -> windows_core::Result; -} -impl IEnumUnknown_Vtbl { - pub const fn new() -> Self { - unsafe extern "system" fn Next( - this: *mut core::ffi::c_void, - celt: u32, - rgelt: *mut *mut core::ffi::c_void, - pceltfetched: *mut u32, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IEnumUnknown_Impl::Next( - this, - core::mem::transmute_copy(&celt), - core::mem::transmute_copy(&rgelt), - core::mem::transmute_copy(&pceltfetched), - ) - } - } - unsafe extern "system" fn Skip( - this: *mut core::ffi::c_void, - celt: u32, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IEnumUnknown_Impl::Skip(this, core::mem::transmute_copy(&celt)).into() - } - } - unsafe extern "system" fn Reset( - this: *mut core::ffi::c_void, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IEnumUnknown_Impl::Reset(this).into() - } - } - unsafe extern "system" fn Clone( - this: *mut core::ffi::c_void, - ppenum: *mut *mut core::ffi::c_void, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IEnumUnknown_Impl::Clone(this) { - Ok(ok__) => { - ppenum.write(core::mem::transmute(ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - Self { - base__: windows_core::IUnknown_Vtbl::new::(), - Next: Next::, - Skip: Skip::, - Reset: Reset::, - Clone: Clone::, - } - } - pub fn matches(iid: &windows_core::GUID) -> bool { - iid == &::IID - } -} -impl windows_core::RuntimeName for IEnumUnknown {} pub const LocInMetaData: LocationType = LocationType(9i32); pub const LocIsBitField: LocationType = LocationType(6i32); pub const LocIsConstant: LocationType = LocationType(10i32); diff --git a/tests/basic/mod.rs b/tests/basic/mod.rs new file mode 100644 index 0000000..66ae915 --- /dev/null +++ b/tests/basic/mod.rs @@ -0,0 +1,28 @@ +use microsoft_dia::{NameSearchOptions, SymTagData}; +use windows_core::*; + +use crate::common::get_test_session; + +#[allow(dead_code)] +static TEST_DATA: u32 = 42; + +#[test] +fn symbol_properties() -> Result<()> { + unsafe { + let session = get_test_session()?; + let symbol = session + .globalScope()? + .findChildren( + SymTagData, + w!("main::basic::TEST_DATA"), + NameSearchOptions::default().0 as u32, + )? + .Item(0)?; + + assert_eq!(symbol.unalignedType()?, false); + assert_eq!(symbol.constType()?, false); + assert_eq!(symbol.volatileType()?, false); + + Ok(()) + } +} diff --git a/tests/common/mod.rs b/tests/common/mod.rs new file mode 100644 index 0000000..eb99da3 --- /dev/null +++ b/tests/common/mod.rs @@ -0,0 +1,24 @@ +use microsoft_dia::{DiaSource, IDiaDataSource, IDiaSession}; +use windows_core::*; + +pub fn get_test_session() -> Result { + unsafe { + let path = if cfg!(target_arch = "x86_64") { + s!( + r"C:\Program Files\Microsoft Visual Studio\2022\Enterprise\DIA SDK\bin\amd64\msdia140.dll" + ) + } else if cfg!(target_arch = "aarch64") { + s!( + r"C:\Program Files\Microsoft Visual Studio\2022\Enterprise\DIA SDK\bin\arm64\msdia140.dll" + ) + } else if cfg!(target_arch = "x86") { + s!(r"C:\Program Files\Microsoft Visual Studio\2022\Enterprise\DIA SDK\bin\msdia140.dll") + } else { + panic!("Unsupported target architecture"); + }; + let source: IDiaDataSource = microsoft_dia::helpers::NoRegCoCreate(path, &DiaSource)?; + let executable = std::env::current_exe().unwrap(); + source.loadDataForExe(&HSTRING::from(executable.as_os_str()), None, None)?; + source.openSession() + } +} diff --git a/tests/enumerators/mod.rs b/tests/enumerators/mod.rs new file mode 100644 index 0000000..4060cad --- /dev/null +++ b/tests/enumerators/mod.rs @@ -0,0 +1,75 @@ +use crate::common::get_test_session; +use microsoft_dia::{nsfRegularExpression, SymTagNull}; +use windows::Win32::Foundation::S_OK; +use windows_core::*; + +#[allow(dead_code)] +static TEST_VALUE_01: i32 = 1; +#[allow(dead_code)] +static TEST_VALUE_02: i32 = 2; +#[allow(dead_code)] +static TEST_VALUE_03: i32 = 3; + +#[test] +fn simple_enumeration() -> Result<()> { + unsafe { + let session = get_test_session()?; + let symbols = session.globalScope()?.findChildren( + SymTagNull, + w!("main::enumerators::TEST_VALUE_[0-9]+"), + nsfRegularExpression.0 as u32, + )?; + + let mut found = Vec::new(); + for i in 0..symbols.Count()? { + found.push(symbols.Item(i as u32)?.name()?); + } + + found.sort_by(|a, b| a.cmp(b)); + assert_eq!( + found, + [ + "main::enumerators::TEST_VALUE_01", + "main::enumerators::TEST_VALUE_02", + "main::enumerators::TEST_VALUE_03", + ] + ); + + Ok(()) + } +} + +#[test] +fn batch_enumeration() -> Result<()> { + unsafe { + let session = get_test_session()?; + let symbols = session.globalScope()?.findChildren( + SymTagNull, + w!("main::enumerators::TEST_VALUE_[0-9]+"), + nsfRegularExpression.0 as u32, + )?; + + let mut found = Vec::new(); + let mut batch = [None, None]; + let mut fetched = 0; + while symbols.Next(&mut batch, &mut fetched) == S_OK { + found.extend( + batch[0..fetched as usize] + .iter() + .filter_map(|s| s.as_ref()?.name().ok()), + ); + } + + found.sort_by(|a, b| a.cmp(b)); + assert_eq!( + found, + [ + "main::enumerators::TEST_VALUE_01", + "main::enumerators::TEST_VALUE_02", + "main::enumerators::TEST_VALUE_03", + ] + ); + + Ok(()) + } +} diff --git a/tests/main.rs b/tests/main.rs new file mode 100644 index 0000000..7b050d0 --- /dev/null +++ b/tests/main.rs @@ -0,0 +1,4 @@ +mod common; + +mod basic; +mod enumerators;