wdext 0.1.0

// SPDX-FileCopyrightText: 2026 takubokudori
// SPDX-License-Identifier: MIT OR Apache-2.0
//! IDebugRegisters
use crate::dbgeng::*;
use windy::{ACPStr, ACPString, WStr, WString};

#[derive(Clone)]
pub enum RegisterGetValues<'a, I = RegisterIndex> {
    Indices(&'a [I]),
    /// Start(start index, count)
    Start(I, u32),
}

impl<'a, I> RegisterGetValues<'a, I> {
    pub fn from_index(reg: impl Into<I>) -> Self { Self::from_start(reg, 1) }

    pub fn from_indices(regs: &'a [I]) -> Self { Self::Indices(regs) }

    pub fn from_start(start: impl Into<I>, count: u32) -> Self {
        Self::Start(start.into(), count)
    }

    pub fn count(&self) -> usize {
        match self {
            Self::Indices(indices) => indices.len(),
            Self::Start(_, count) => *count as usize,
        }
    }
}

#[derive(Debug, Clone)]
pub enum RegisterSetValues<'a, I = RegisterIndex> {
    /// The index and value slices must have the same length.
    Indices(&'a [I], &'a [DebugValue]),
    /// Start(start index, values)
    Start(I, &'a [DebugValue]),
}

pub type PseudoRegisterGetValues<'a> =
    RegisterGetValues<'a, PseudoRegisterIndex>;
pub type PseudoRegisterSetValues<'a> =
    RegisterSetValues<'a, PseudoRegisterIndex>;

impl_debug_interface!(
    DebugRegisters,
    DebugRegistersRef,
    IDebugRegisters2,
    IDebugRegisters
);

// IDebugRegisters
impl DebugRegisters {
    pub fn get_number_registers(&self) -> WinResult<u32> {
        unsafe { self.0.GetNumberRegisters() }
    }

    /// Returns `(Register name, Description)`.
    pub fn get_description(
        &self,
        register: RegisterIndex,
    ) -> WinResult<(ACPString, DebugRegisterDescription)> {
        let mut desc = DebugRegisterDescription::default();
        let name = unsafe {
            astring_with_capacity2(
                16,
                |v, s| {
                    vcall!(
                        self,
                        GetDescription,
                        register.0,
                        pa!(v),
                        v.len().try_into().unwrap(),
                        s,
                        desc.as_raw_mut(),
                    )
                },
                |v, s| {
                    vcall!(
                        self,
                        GetDescription,
                        register.0,
                        pa!(v),
                        v.len().try_into().unwrap(),
                        s,
                        std::ptr::null_mut(),
                    )
                },
            )?
        };
        Ok((name, desc))
    }

    /// Returns the register description.
    pub fn _get_register_description(
        &self,
        register: RegisterIndex,
    ) -> WinResult<DebugRegisterDescription> {
        let mut desc = DebugRegisterDescription::default();
        unsafe {
            vcall!(
                self,
                GetDescription,
                register.0,
                windows::core::PSTR(std::ptr::null_mut()),
                0,
                std::ptr::null_mut(),
                desc.as_raw_mut(),
            )
            .ok()?;
        }
        Ok(desc)
    }

    pub fn get_index_by_name(
        &self,
        name: impl AsRef<ACPStr>,
    ) -> WinResult<RegisterIndex> {
        unsafe { Ok(self.0.GetIndexByName(pca!(name))?.into()) }
    }

    pub fn get_value(
        &self,
        register_index: RegisterIndex,
    ) -> WinResult<DebugValue> {
        let mut ret = DebugValue::default();
        unsafe {
            self.0.GetValue(register_index.0, &mut ret.0)?;
            Ok(ret)
        }
    }

    pub fn set_value(
        &self,
        register_index: RegisterIndex,
        value: &DebugValue,
    ) -> WinResult<()> {
        unsafe { self.0.SetValue(register_index.0, value.as_ptr()) }
    }

    /// Gets multiple register values.
    ///
    /// Each element of `out` must be initialized with [`DebugValue::default`] before calling this function.
    /// The contents of `out` remain available even if DbgEng returns an error, as some values may have been retrieved successfully.
    /// Use [`DebugValue::is_invalid`] to determine whether retrieving each individual register value failed.
    pub fn get_values(
        &self,
        values: RegisterGetValues<'_, RegisterIndex>,
        out: &mut [DebugValue],
    ) -> WinResult<()> {
        if values.count() != out.len() {
            return Err(windows::Win32::Foundation::E_INVALIDARG.into());
        }

        unsafe {
            match values {
                RegisterGetValues::Indices(indices) => self.0.GetValues(
                    indices.len().try_into()?,
                    Some(indices.as_ptr() as *const _ as *const _),
                    0,
                    out.as_mut_ptr() as *mut _ as *mut _,
                ),
                RegisterGetValues::Start(start, count) => self.0.GetValues(
                    count,
                    None,
                    start.0,
                    out.as_mut_ptr() as *mut _ as *mut _,
                ),
            }
        }
    }

    /// Sets multiple register values.
    ///
    /// DbgEng does not make this operation atomic; an error may be returned
    /// after some registers have already been changed.
    pub fn set_values(
        &self,
        values: RegisterSetValues<'_, RegisterIndex>,
    ) -> WinResult<()> {
        unsafe {
            match values {
                RegisterSetValues::Indices(indices, values) => {
                    if indices.len() != values.len() {
                        return Err(
                            windows::Win32::Foundation::E_INVALIDARG.into()
                        );
                    }
                    self.0.SetValues(
                        indices.len().try_into()?,
                        Some(indices.as_ptr() as *const _ as *const _),
                        0,
                        values.as_ptr() as *const _ as *const _,
                    )
                }
                RegisterSetValues::Start(start, values) => self.0.SetValues(
                    values.len().try_into()?,
                    None,
                    start.0,
                    values.as_ptr() as *const _ as *const _,
                ),
            }
        }
    }

    pub fn output_registers(
        &self,
        output_control: DebugOutctlFlags,
        flags: DebugRegistersFlags,
    ) -> WinResult<()> {
        unsafe { self.0.OutputRegisters(output_control.bits(), flags.bits()) }
    }

    pub fn get_instruction_offset(&self) -> WinResult<DebuggeeOffset> {
        unsafe { self.0.GetInstructionOffset() }
    }

    pub fn get_stack_offset(&self) -> WinResult<u64> {
        unsafe { self.0.GetStackOffset() }
    }

    pub fn get_frame_offset(&self) -> WinResult<u64> {
        unsafe { self.0.GetFrameOffset() }
    }
}

// IDebugRegisters2
impl DebugRegisters {
    /// Returns `(Register name, Description)`.
    pub fn get_description_wide(
        &self,
        register: RegisterIndex,
    ) -> WinResult<(WString, DebugRegisterDescription)> {
        let mut desc = DebugRegisterDescription::default();
        let name = unsafe {
            wstring_with_capacity2(
                16,
                |v, s| {
                    vcall!(
                        self,
                        GetDescriptionWide,
                        register.0,
                        pw!(v),
                        v.len().try_into().unwrap(),
                        s,
                        desc.as_raw_mut(),
                    )
                },
                |v, s| {
                    vcall!(
                        self,
                        GetDescriptionWide,
                        register.0,
                        pw!(v),
                        v.len().try_into().unwrap(),
                        s,
                        std::ptr::null_mut(),
                    )
                },
            )?
        };
        Ok((name, desc))
    }

    /// Returns the register name.
    pub fn _get_name_wide(
        &self,
        register: RegisterIndex,
    ) -> WinResult<WString> {
        unsafe {
            wstring_with_capacity(16, |v, s| {
                vcall!(
                    self,
                    GetDescriptionWide,
                    register.0,
                    pw!(v),
                    v.len().try_into().unwrap(),
                    s,
                    std::ptr::null_mut(),
                )
            })
        }
    }

    pub fn get_index_by_name_wide(
        &self,
        name: impl AsRef<WStr>,
    ) -> WinResult<RegisterIndex> {
        unsafe { Ok(self.0.GetIndexByNameWide(pcw!(name))?.into()) }
    }

    pub fn get_number_pseudo_registers(&self) -> WinResult<u32> {
        unsafe { self.0.GetNumberPseudoRegisters() }
    }

    /// Returns `(Register name, Type module, Type ID)`.
    pub fn get_pseudo_description(
        &self,
        register: PseudoRegisterIndex,
    ) -> WinResult<(ACPString, SymbolTypeId)> {
        let mut id = SymbolTypeId { module: 0, id: 0 };
        let name = unsafe {
            astring_with_capacity2(
                16,
                |v, s| {
                    vcall!(
                        self,
                        GetPseudoDescription,
                        register.0,
                        pa!(v),
                        v.len().try_into().unwrap(),
                        s,
                        &mut id.module,
                        &mut id.id,
                    )
                },
                |v, s| {
                    vcall!(
                        self,
                        GetPseudoDescription,
                        register.0,
                        pa!(v),
                        v.len().try_into().unwrap(),
                        s,
                        std::ptr::null_mut(),
                        std::ptr::null_mut(),
                    )
                },
            )?
        };
        Ok((name, id))
    }

    /// Returns `(Register name, Type module, Type ID)`.
    pub fn get_pseudo_description_wide(
        &self,
        register: PseudoRegisterIndex,
    ) -> WinResult<(WString, SymbolTypeId)> {
        let mut id = SymbolTypeId::default();
        let name = unsafe {
            wstring_with_capacity2(
                16,
                |v, s| {
                    vcall!(
                        self,
                        GetPseudoDescriptionWide,
                        register.0,
                        pw!(v),
                        v.len().try_into().unwrap(),
                        s,
                        &mut id.module,
                        &mut id.id,
                    )
                },
                |v, s| {
                    vcall!(
                        self,
                        GetPseudoDescriptionWide,
                        register.0,
                        pw!(v),
                        v.len().try_into().unwrap(),
                        s,
                        std::ptr::null_mut(),
                        std::ptr::null_mut(),
                    )
                },
            )?
        };
        Ok((name, id))
    }

    /// Returns the pseudo register name.
    pub fn _get_pseudo_name_wide(
        &self,
        register: PseudoRegisterIndex,
    ) -> WinResult<WString> {
        unsafe {
            wstring_with_capacity(16, |v, s| {
                vcall!(
                    self,
                    GetPseudoDescriptionWide,
                    register.0,
                    pw!(v),
                    v.len().try_into().unwrap(),
                    s,
                    std::ptr::null_mut(),
                    std::ptr::null_mut(),
                )
            })
        }
    }

    /// Returns the pseudo register description.
    pub fn _get_pseudo_register_type(
        &self,
        register: PseudoRegisterIndex,
    ) -> WinResult<SymbolTypeId> {
        let mut type_id = SymbolTypeId::default();
        unsafe {
            vcall!(
                self,
                GetPseudoDescriptionWide,
                register.0,
                windows::core::PWSTR(std::ptr::null_mut()),
                0,
                std::ptr::null_mut(),
                &mut type_id.module,
                &mut type_id.id
            )
            .ok()?;
        }
        Ok(type_id)
    }

    pub fn get_pseudo_index_by_name(
        &self,
        name: impl AsRef<ACPStr>,
    ) -> WinResult<PseudoRegisterIndex> {
        unsafe { Ok(self.0.GetPseudoIndexByName(pca!(name))?.into()) }
    }

    pub fn get_pseudo_index_by_name_wide(
        &self,
        name: impl AsRef<WStr>,
    ) -> WinResult<PseudoRegisterIndex> {
        unsafe { Ok(self.0.GetPseudoIndexByNameWide(pcw!(name))?.into()) }
    }

    /// Gets multiple pseudo-register values.
    ///
    /// Each element of `out` must be initialized with [`DebugValue::default`] before calling this function.
    /// The contents of `out` remain available even if DbgEng returns an error, as some values may have been retrieved successfully.
    /// Use [`DebugValue::is_invalid`] to determine whether retrieving each individual register value failed.
    pub fn get_pseudo_values(
        &self,
        source: DebugRegSrc,
        values: PseudoRegisterGetValues<'_>,
        out: &mut [DebugValue],
    ) -> WinResult<()> {
        if values.count() != out.len() {
            return Err(windows::Win32::Foundation::E_INVALIDARG.into());
        }

        unsafe {
            match values {
                RegisterGetValues::Indices(indices) => self.0.GetPseudoValues(
                    source as u32,
                    indices.len().try_into()?,
                    Some(indices.as_ptr() as *const _ as *const _),
                    0,
                    out.as_mut_ptr() as *mut _ as *mut _,
                ),
                RegisterGetValues::Start(start, count) => {
                    self.0.GetPseudoValues(
                        source as u32,
                        count,
                        None,
                        start.0,
                        out.as_mut_ptr() as *mut _ as *mut _,
                    )
                }
            }
        }
    }

    /// Sets multiple pseudo-register values.
    ///
    /// For the `Indices` form, the index and value slices must have identical
    /// lengths.
    pub fn set_pseudo_values(
        &self,
        source: DebugRegSrc,
        values: PseudoRegisterSetValues<'_>,
    ) -> WinResult<()> {
        unsafe {
            match values {
                RegisterSetValues::Indices(indices, values) => {
                    if indices.len() != values.len() {
                        return Err(
                            windows::Win32::Foundation::E_INVALIDARG.into()
                        );
                    }
                    self.0.SetPseudoValues(
                        source as u32,
                        indices.len().try_into()?,
                        Some(indices.as_ptr() as *const _ as *const _),
                        0,
                        values.as_ptr() as *const _ as *const _,
                    )
                }
                RegisterSetValues::Start(start, values) => {
                    self.0.SetPseudoValues(
                        source as u32,
                        values.len().try_into()?,
                        None,
                        start.0,
                        values.as_ptr() as *const _ as *const _,
                    )
                }
            }
        }
    }

    /// Gets multiple register values from the selected register source.
    ///
    /// Each element of `out` must be initialized with [`DebugValue::default`] before calling this function.
    /// The contents of `out` remain available even if DbgEng returns an error, as some values may have been retrieved successfully.
    /// Use [`DebugValue::is_invalid`] to determine whether retrieving each individual register value failed.
    pub fn get_values2(
        &self,
        source: DebugRegSrc,
        values: RegisterGetValues<'_, RegisterIndex>,
        out: &mut [DebugValue],
    ) -> WinResult<()> {
        if values.count() != out.len() {
            return Err(windows::Win32::Foundation::E_INVALIDARG.into());
        }

        unsafe {
            match values {
                RegisterGetValues::Indices(indices) => self.0.GetValues2(
                    source as u32,
                    indices.len().try_into()?,
                    Some(indices.as_ptr() as *const _ as *const _),
                    0,
                    out.as_mut_ptr() as *mut _ as *mut _,
                ),
                RegisterGetValues::Start(start, count) => self.0.GetValues2(
                    source as u32,
                    count,
                    None,
                    start.0,
                    out.as_mut_ptr() as *mut _ as *mut _,
                ),
            }
        }
    }

    /// Sets multiple register values in the selected register source.
    ///
    /// DbgEng does not make this operation atomic; an error may be returned
    /// after some registers have already been changed.
    pub fn set_values2(
        &self,
        source: DebugRegSrc,
        values: RegisterSetValues<'_, RegisterIndex>,
    ) -> WinResult<()> {
        unsafe {
            match values {
                RegisterSetValues::Indices(indices, values) => {
                    if indices.len() != values.len() {
                        return Err(
                            windows::Win32::Foundation::E_INVALIDARG.into()
                        );
                    }
                    self.0.SetValues2(
                        source as u32,
                        indices.len().try_into()?,
                        Some(indices.as_ptr() as *const _ as *const _),
                        0,
                        values.as_ptr() as *const _ as *const _,
                    )
                }
                RegisterSetValues::Start(start, values) => self.0.SetValues2(
                    source as u32,
                    values.len().try_into()?,
                    None,
                    start.0,
                    values.as_ptr() as *const _ as *const _,
                ),
            }
        }
    }

    pub fn output_registers2(
        &self,
        output_control: DebugOutctlFlags,
        source: DebugRegSrc,
        flags: DebugRegistersFlags,
    ) -> WinResult<()> {
        unsafe {
            self.0.OutputRegisters2(
                output_control.bits(),
                source as u32,
                flags.bits(),
            )
        }
    }

    pub fn get_instruction_offset2(
        &self,
        source: DebugRegSrc,
    ) -> WinResult<DebuggeeOffset> {
        unsafe { self.0.GetInstructionOffset2(source as u32) }
    }

    pub fn get_stack_offset2(&self, source: DebugRegSrc) -> WinResult<u64> {
        unsafe { self.0.GetStackOffset2(source as u32) }
    }

    pub fn get_frame_offset2(&self, source: DebugRegSrc) -> WinResult<u64> {
        unsafe { self.0.GetFrameOffset2(source as u32) }
    }
}