Vendor dependencies for 0.3.0 release

vendor/windows-result-0.1.2/src/bindings.rs

@@ -0,0 +1,90 @@
+#![allow(
+    non_snake_case,
+    non_upper_case_globals,
+    non_camel_case_types,
+    dead_code,
+    clippy::all
+)]
+windows_targets::link!("api-ms-win-core-winrt-error-l1-1-0.dll" "system" fn RoOriginateErrorW(error : HRESULT, cchmax : u32, message : PCWSTR) -> BOOL);
+windows_targets::link!("kernel32.dll" "system" fn FormatMessageW(dwflags : FORMAT_MESSAGE_OPTIONS, lpsource : *const core::ffi::c_void, dwmessageid : u32, dwlanguageid : u32, lpbuffer : PWSTR, nsize : u32, arguments : *const *const i8) -> u32);
+windows_targets::link!("kernel32.dll" "system" fn GetLastError() -> WIN32_ERROR);
+windows_targets::link!("kernel32.dll" "system" fn GetProcessHeap() -> HANDLE);
+windows_targets::link!("kernel32.dll" "system" fn HeapFree(hheap : HANDLE, dwflags : HEAP_FLAGS, lpmem : *const core::ffi::c_void) -> BOOL);
+windows_targets::link!("kernel32.dll" "system" fn LoadLibraryExA(lplibfilename : PCSTR, hfile : HANDLE, dwflags : LOAD_LIBRARY_FLAGS) -> HMODULE);
+windows_targets::link!("oleaut32.dll" "system" fn GetErrorInfo(dwreserved : u32, pperrinfo : *mut * mut core::ffi::c_void) -> HRESULT);
+windows_targets::link!("oleaut32.dll" "system" fn SetErrorInfo(dwreserved : u32, perrinfo : * mut core::ffi::c_void) -> HRESULT);
+windows_targets::link!("oleaut32.dll" "system" fn SysFreeString(bstrstring : BSTR));
+windows_targets::link!("oleaut32.dll" "system" fn SysStringLen(pbstr : BSTR) -> u32);
+pub type BOOL = i32;
+pub type BSTR = *const u16;
+pub const ERROR_INVALID_DATA: WIN32_ERROR = 13u32;
+pub const ERROR_NO_UNICODE_TRANSLATION: WIN32_ERROR = 1113u32;
+pub const E_INVALIDARG: HRESULT = 0x80070057_u32 as _;
+pub const E_UNEXPECTED: HRESULT = 0x8000FFFF_u32 as _;
+pub const FORMAT_MESSAGE_ALLOCATE_BUFFER: FORMAT_MESSAGE_OPTIONS = 256u32;
+pub const FORMAT_MESSAGE_FROM_HMODULE: FORMAT_MESSAGE_OPTIONS = 2048u32;
+pub const FORMAT_MESSAGE_FROM_SYSTEM: FORMAT_MESSAGE_OPTIONS = 4096u32;
+pub const FORMAT_MESSAGE_IGNORE_INSERTS: FORMAT_MESSAGE_OPTIONS = 512u32;
+pub type FORMAT_MESSAGE_OPTIONS = u32;
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct GUID {
+    pub data1: u32,
+    pub data2: u16,
+    pub data3: u16,
+    pub data4: [u8; 8],
+}
+impl GUID {
+    pub const fn from_u128(uuid: u128) -> Self {
+        Self {
+            data1: (uuid >> 96) as u32,
+            data2: (uuid >> 80 & 0xffff) as u16,
+            data3: (uuid >> 64 & 0xffff) as u16,
+            data4: (uuid as u64).to_be_bytes(),
+        }
+    }
+}
+pub type HANDLE = isize;
+pub type HEAP_FLAGS = u32;
+pub type HMODULE = isize;
+pub type HRESULT = i32;
+pub const IID_IErrorInfo: GUID = GUID::from_u128(0x1cf2b120_547d_101b_8e65_08002b2bd119);
+#[repr(C)]
+pub struct IErrorInfo_Vtbl {
+    pub base__: IUnknown_Vtbl,
+    pub GetGUID: unsafe extern "system" fn(*mut core::ffi::c_void, *mut GUID) -> HRESULT,
+    pub GetSource: unsafe extern "system" fn(*mut core::ffi::c_void, *mut BSTR) -> HRESULT,
+    pub GetDescription: unsafe extern "system" fn(*mut core::ffi::c_void, *mut BSTR) -> HRESULT,
+    pub GetHelpFile: unsafe extern "system" fn(*mut core::ffi::c_void, *mut BSTR) -> HRESULT,
+    pub GetHelpContext: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> HRESULT,
+}
+pub const IID_IRestrictedErrorInfo: GUID = GUID::from_u128(0x82ba7092_4c88_427d_a7bc_16dd93feb67e);
+#[repr(C)]
+pub struct IRestrictedErrorInfo_Vtbl {
+    pub base__: IUnknown_Vtbl,
+    pub GetErrorDetails: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut BSTR,
+        *mut HRESULT,
+        *mut BSTR,
+        *mut BSTR,
+    ) -> HRESULT,
+    pub GetReference: unsafe extern "system" fn(*mut core::ffi::c_void, *mut BSTR) -> HRESULT,
+}
+pub const IID_IUnknown: GUID = GUID::from_u128(0x00000000_0000_0000_c000_000000000046);
+#[repr(C)]
+pub struct IUnknown_Vtbl {
+    pub QueryInterface: unsafe extern "system" fn(
+        this: *mut core::ffi::c_void,
+        iid: *const GUID,
+        interface: *mut *mut core::ffi::c_void,
+    ) -> HRESULT,
+    pub AddRef: unsafe extern "system" fn(this: *mut core::ffi::c_void) -> u32,
+    pub Release: unsafe extern "system" fn(this: *mut core::ffi::c_void) -> u32,
+}
+pub type LOAD_LIBRARY_FLAGS = u32;
+pub const LOAD_LIBRARY_SEARCH_DEFAULT_DIRS: LOAD_LIBRARY_FLAGS = 4096u32;
+pub type PCSTR = *const u8;
+pub type PCWSTR = *const u16;
+pub type PWSTR = *mut u16;
+pub type WIN32_ERROR = u32;

vendor/windows-result-0.1.2/src/com.rs

@@ -0,0 +1,54 @@
+use super::*;
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! com_call {
+    ($vtbl:ty, $this:ident.$method:ident($($args:tt)*)) => {
+        ((&**($this.as_raw() as *mut *mut $vtbl)).$method)($this.as_raw(), $($args)*)
+    }
+}
+
+#[repr(transparent)]
+pub struct ComPtr(core::ptr::NonNull<core::ffi::c_void>);
+
+impl ComPtr {
+    pub fn as_raw(&self) -> *mut core::ffi::c_void {
+        unsafe { core::mem::transmute_copy(self) }
+    }
+
+    pub fn cast(&self, iid: &GUID) -> Option<Self> {
+        let mut result = None;
+        unsafe {
+            com_call!(
+                IUnknown_Vtbl,
+                self.QueryInterface(iid, &mut result as *mut _ as _)
+            );
+        }
+        result
+    }
+}
+
+impl PartialEq for ComPtr {
+    fn eq(&self, other: &Self) -> bool {
+        self.cast(&IID_IUnknown).unwrap().0 == other.cast(&IID_IUnknown).unwrap().0
+    }
+}
+
+impl Eq for ComPtr {}
+
+impl Clone for ComPtr {
+    fn clone(&self) -> Self {
+        unsafe {
+            com_call!(IUnknown_Vtbl, self.AddRef());
+        }
+        Self(self.0)
+    }
+}
+
+impl Drop for ComPtr {
+    fn drop(&mut self) {
+        unsafe {
+            com_call!(IUnknown_Vtbl, self.Release());
+        }
+    }
+}

vendor/windows-result-0.1.2/src/error.rs

@@ -0,0 +1,192 @@
+use super::*;
+use core::ffi::c_void;
+
+/// An error object consists of both an error code as well as detailed error information for debugging.
+#[derive(Clone, PartialEq, Eq)]
+pub struct Error {
+    code: HRESULT,
+    info: Option<ComPtr>,
+}
+
+impl Error {
+    /// Creates an error object without any failure information.
+    pub const fn empty() -> Self {
+        Self {
+            code: HRESULT(0),
+            info: None,
+        }
+    }
+
+    /// Creates a new error object, capturing the stack and other information about the
+    /// point of failure.
+    pub fn new<T: AsRef<str>>(code: HRESULT, message: T) -> Self {
+        let message: Vec<_> = message.as_ref().encode_utf16().collect();
+
+        if message.is_empty() {
+            Self::from_hresult(code)
+        } else {
+            unsafe {
+                RoOriginateErrorW(code.0, message.len() as u32, message.as_ptr());
+            }
+            code.into()
+        }
+    }
+
+    /// Creates a new error object with an error code, but without additional error information.
+    pub fn from_hresult(code: HRESULT) -> Self {
+        Self { code, info: None }
+    }
+
+    /// Creates a new `Error` from the Win32 error code returned by `GetLastError()`.
+    pub fn from_win32() -> Self {
+        Self {
+            code: HRESULT::from_win32(unsafe { GetLastError() }),
+            info: None,
+        }
+    }
+
+    /// The error code describing the error.
+    pub const fn code(&self) -> HRESULT {
+        self.code
+    }
+
+    /// The error message describing the error.
+    pub fn message(&self) -> String {
+        if let Some(info) = &self.info {
+            let mut message = BasicString::default();
+
+            // First attempt to retrieve the restricted error information.
+            if let Some(info) = info.cast(&IID_IRestrictedErrorInfo) {
+                let mut fallback = BasicString::default();
+                let mut code = 0;
+
+                unsafe {
+                    com_call!(
+                        IRestrictedErrorInfo_Vtbl,
+                        info.GetErrorDetails(
+                            &mut fallback as *mut _ as _,
+                            &mut code,
+                            &mut message as *mut _ as _,
+                            &mut BasicString::default() as *mut _ as _
+                        )
+                    );
+                }
+
+                if message.is_empty() {
+                    message = fallback
+                };
+            }
+
+            // Next attempt to retrieve the regular error information.
+            if message.is_empty() {
+                unsafe {
+                    com_call!(
+                        IErrorInfo_Vtbl,
+                        info.GetDescription(&mut message as *mut _ as _)
+                    );
+                }
+            }
+
+            return String::from_utf16_lossy(wide_trim_end(message.as_wide()));
+        }
+
+        // Otherwise fallback to a generic error code description.
+        self.code.message()
+    }
+
+    /// The error object describing the error.
+    pub fn as_ptr(&self) -> *mut c_void {
+        self.info
+            .as_ref()
+            .map_or(core::ptr::null_mut(), |info| info.as_raw())
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {}
+unsafe impl Send for Error {}
+unsafe impl Sync for Error {}
+
+impl From<Error> for HRESULT {
+    fn from(error: Error) -> Self {
+        if let Some(info) = error.info {
+            unsafe {
+                SetErrorInfo(0, info.as_raw());
+            }
+        }
+        error.code
+    }
+}
+
+impl From<HRESULT> for Error {
+    fn from(code: HRESULT) -> Self {
+        let mut info = None;
+        unsafe { GetErrorInfo(0, &mut info as *mut _ as _) };
+        Self { code, info }
+    }
+}
+
+#[cfg(feature = "std")]
+impl From<Error> for std::io::Error {
+    fn from(from: Error) -> Self {
+        Self::from_raw_os_error(from.code.0)
+    }
+}
+
+#[cfg(feature = "std")]
+impl From<std::io::Error> for Error {
+    fn from(from: std::io::Error) -> Self {
+        match from.raw_os_error() {
+            Some(status) => HRESULT::from_win32(status as u32).into(),
+            None => HRESULT(E_UNEXPECTED).into(),
+        }
+    }
+}
+
+impl From<alloc::string::FromUtf16Error> for Error {
+    fn from(_: alloc::string::FromUtf16Error) -> Self {
+        Self {
+            code: HRESULT::from_win32(ERROR_NO_UNICODE_TRANSLATION),
+            info: None,
+        }
+    }
+}
+
+impl From<alloc::string::FromUtf8Error> for Error {
+    fn from(_: alloc::string::FromUtf8Error) -> Self {
+        Self {
+            code: HRESULT::from_win32(ERROR_NO_UNICODE_TRANSLATION),
+            info: None,
+        }
+    }
+}
+
+impl From<core::num::TryFromIntError> for Error {
+    fn from(_: core::num::TryFromIntError) -> Self {
+        Self {
+            code: HRESULT::from_win32(ERROR_INVALID_DATA),
+            info: None,
+        }
+    }
+}
+
+impl core::fmt::Debug for Error {
+    fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let mut debug = fmt.debug_struct("Error");
+        debug
+            .field("code", &self.code)
+            .field("message", &self.message())
+            .finish()
+    }
+}
+
+impl core::fmt::Display for Error {
+    fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let message = self.message();
+        if message.is_empty() {
+            core::write!(fmt, "{}", self.code())
+        } else {
+            core::write!(fmt, "{} ({})", self.message(), self.code())
+        }
+    }
+}

vendor/windows-result-0.1.2/src/hresult.rs

@@ -0,0 +1,143 @@
+use super::*;
+
+/// An error code value returned by most COM functions.
+#[repr(transparent)]
+#[derive(Copy, Clone, Default, Eq, PartialEq)]
+#[must_use]
+#[allow(non_camel_case_types)]
+pub struct HRESULT(pub i32);
+
+impl HRESULT {
+    /// Returns [`true`] if `self` is a success code.
+    #[inline]
+    pub const fn is_ok(self) -> bool {
+        self.0 >= 0
+    }
+
+    /// Returns [`true`] if `self` is a failure code.
+    #[inline]
+    pub const fn is_err(self) -> bool {
+        !self.is_ok()
+    }
+
+    /// Asserts that `self` is a success code.
+    ///
+    /// This will invoke the [`panic!`] macro if `self` is a failure code and display
+    /// the [`HRESULT`] value for diagnostics.
+    #[inline]
+    #[track_caller]
+    pub fn unwrap(self) {
+        assert!(self.is_ok(), "HRESULT 0x{:X}", self.0);
+    }
+
+    /// Converts the [`HRESULT`] to [`Result<()>`][Result<_>].
+    #[inline]
+    pub fn ok(self) -> Result<()> {
+        if self.is_ok() {
+            Ok(())
+        } else {
+            Err(self.into())
+        }
+    }
+
+    /// Calls `op` if `self` is a success code, otherwise returns [`HRESULT`]
+    /// converted to [`Result<T>`].
+    #[inline]
+    pub fn map<F, T>(self, op: F) -> Result<T>
+    where
+        F: FnOnce() -> T,
+    {
+        self.ok()?;
+        Ok(op())
+    }
+
+    /// Calls `op` if `self` is a success code, otherwise returns [`HRESULT`]
+    /// converted to [`Result<T>`].
+    #[inline]
+    pub fn and_then<F, T>(self, op: F) -> Result<T>
+    where
+        F: FnOnce() -> Result<T>,
+    {
+        self.ok()?;
+        op()
+    }
+
+    /// The error message describing the error.
+    pub fn message(&self) -> String {
+        let mut message = HeapString::default();
+        let mut code = self.0;
+        let mut module = 0;
+
+        let mut flags = FORMAT_MESSAGE_ALLOCATE_BUFFER
+            | FORMAT_MESSAGE_FROM_SYSTEM
+            | FORMAT_MESSAGE_IGNORE_INSERTS;
+
+        unsafe {
+            if self.0 & 0x1000_0000 == 0x1000_0000 {
+                code ^= 0x1000_0000;
+                flags |= FORMAT_MESSAGE_FROM_HMODULE;
+
+                module =
+                    LoadLibraryExA(b"ntdll.dll\0".as_ptr(), 0, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
+            }
+
+            let size = FormatMessageW(
+                flags,
+                module as _,
+                code as _,
+                0,
+                &mut message.0 as *mut _ as *mut _,
+                0,
+                core::ptr::null(),
+            );
+
+            if !message.0.is_null() && size > 0 {
+                String::from_utf16_lossy(wide_trim_end(core::slice::from_raw_parts(
+                    message.0,
+                    size as usize,
+                )))
+            } else {
+                String::default()
+            }
+        }
+    }
+
+    /// Maps a Win32 error code to an HRESULT value.
+    pub const fn from_win32(error: u32) -> Self {
+        Self(if error as i32 <= 0 {
+            error
+        } else {
+            (error & 0x0000_FFFF) | (7 << 16) | 0x8000_0000
+        } as i32)
+    }
+
+    /// Maps an NT error code to an HRESULT value.
+    pub const fn from_nt(error: i32) -> Self {
+        Self(if error >= 0 {
+            error
+        } else {
+            error | 0x1000_0000
+        })
+    }
+}
+
+impl<T> From<Result<T>> for HRESULT {
+    fn from(result: Result<T>) -> Self {
+        if let Err(error) = result {
+            return error.into();
+        }
+        HRESULT(0)
+    }
+}
+
+impl core::fmt::Display for HRESULT {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.write_fmt(format_args!("{:#010X}", self.0))
+    }
+}
+
+impl core::fmt::Debug for HRESULT {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.write_fmt(format_args!("HRESULT({})", self))
+    }
+}

vendor/windows-result-0.1.2/src/lib.rs

@@ -0,0 +1,32 @@
+/*!
+Learn more about Rust for Windows here: <https://github.com/microsoft/windows-rs>
+*/
+
+#![cfg_attr(
+    windows_debugger_visualizer,
+    debugger_visualizer(natvis_file = "../.natvis")
+)]
+#![cfg_attr(all(not(test), not(feature = "std")), no_std)]
+
+extern crate alloc;
+
+use alloc::string::String;
+use alloc::vec::Vec;
+
+mod bindings;
+use bindings::*;
+
+mod com;
+use com::*;
+
+mod strings;
+use strings::*;
+
+mod error;
+pub use error::Error;
+
+mod hresult;
+pub use hresult::HRESULT;
+
+/// A specialized [`Result`] type that provides Windows error information.
+pub type Result<T> = core::result::Result<T, Error>;

vendor/windows-result-0.1.2/src/strings.rs

@@ -0,0 +1,78 @@
+use super::*;
+
+pub struct HeapString(pub *mut u16);
+
+impl Default for HeapString {
+    fn default() -> Self {
+        Self(core::ptr::null_mut())
+    }
+}
+
+impl Drop for HeapString {
+    fn drop(&mut self) {
+        if !self.0.is_null() {
+            unsafe {
+                HeapFree(GetProcessHeap(), 0, self.0 as _);
+            }
+        }
+    }
+}
+
+#[repr(transparent)]
+pub struct BasicString(*const u16);
+
+impl BasicString {
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    pub fn len(&self) -> usize {
+        if self.0.is_null() {
+            0
+        } else {
+            unsafe { SysStringLen(self.0) as usize }
+        }
+    }
+
+    pub fn as_wide(&self) -> &[u16] {
+        let len = self.len();
+        if len != 0 {
+            unsafe { core::slice::from_raw_parts(self.as_ptr(), len) }
+        } else {
+            &[]
+        }
+    }
+
+    pub fn as_ptr(&self) -> *const u16 {
+        if !self.is_empty() {
+            self.0
+        } else {
+            const EMPTY: [u16; 1] = [0];
+            EMPTY.as_ptr()
+        }
+    }
+}
+
+impl Default for BasicString {
+    fn default() -> Self {
+        Self(core::ptr::null_mut())
+    }
+}
+
+impl Drop for BasicString {
+    fn drop(&mut self) {
+        if !self.0.is_null() {
+            unsafe { SysFreeString(self.0) }
+        }
+    }
+}
+
+pub fn wide_trim_end(mut wide: &[u16]) -> &[u16] {
+    while let Some(last) = wide.last() {
+        match last {
+            32 | 9..=13 => wide = &wide[..wide.len() - 1],
+            _ => break,
+        }
+    }
+    wide
+}