wdext 0.1.0

A DbgEng wrapper framework
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

// SPDX-FileCopyrightText: 2026 takubokudori
// SPDX-License-Identifier: MIT OR Apache-2.0
use crate::{
    dbgeng::WinResult,
    dbgmodel::{
        DbgModelSymbolKind, DebugHostContext, DebugHostSymbol,
        DebugHostSymbolEnumerator, DebugHostType,
    },
    *,
};

impl_debug_interface!(
    DebugHostModule,
    DebugHostModuleRef,
    IDebugHostModule2,
    IDebugHostModule
);

// Derived from IDebugHostSymbol
impl DebugHostModule {
    pub fn get_context(&self) -> WinResult<DebugHostContext> {
        unsafe { Ok(self.0.GetContext()?.into()) }
    }

    pub fn enumerate_children(
        &self,
        kind: impl Into<DbgModelSymbolKind>,
        name: impl AsRef<WStr>,
    ) -> WinResult<DebugHostSymbolEnumerator> {
        unsafe {
            Ok(self
                .0
                .EnumerateChildren(kind.into().into(), pcw!(name))?
                .into())
        }
    }

    pub fn get_symbol_kind(&self) -> WinResult<DbgModelSymbolKind> {
        unsafe { Ok(self.0.GetSymbolKind()?.into()) }
    }

    pub fn get_name(&self) -> WinResult<WString> {
        unsafe {
            Ok(WString::from_vec_with_nul_unchecked(
                self.0.GetName()?.as_ref(),
            ))
        }
    }

    pub fn get_type(&self) -> WinResult<DebugHostType> {
        unsafe { Ok(self.0.GetType()?.into()) }
    }

    pub fn get_containing_module(&self) -> WinResult<DebugHostModule> {
        unsafe { Ok(self.0.GetContainingModule()?.into()) }
    }

    pub fn compare_against(
        &self,
        comparison_symbol: &DebugHostSymbol, /* comparison_flags: u32 is reserved. */
    ) -> WinResult<bool> {
        unsafe { self.0.CompareAgainst(comparison_symbol.as_raw(), 0) }
    }
}

// IDebugHostModule
impl DebugHostModule {
    pub fn get_image_name(&self, allow_path: bool) -> WinResult<WString> {
        unsafe {
            Ok(WString::from_vec_with_nul_unchecked(
                self.0.GetImageName(allow_path.into())?.as_ref(),
            ))
        }
    }

    pub fn get_base_location(&self) -> WinResult<Location> {
        unsafe { self.0.GetBaseLocation() }
    }

    /// Returns `(fileVersion, productVersion)`.
    pub fn get_version(&self) -> WinResult<(u64, u64)> {
        unsafe {
            let mut file_version = 0;
            let mut product_version = 0;
            self.0.GetVersion(
                Some(&mut file_version),
                Some(&mut product_version),
            )?;
            Ok((file_version, product_version))
        }
    }

    pub fn _get_file_version(&self) -> WinResult<u64> {
        unsafe {
            let mut file_version = 0;
            self.0.GetVersion(Some(&mut file_version), None)?;
            Ok(file_version)
        }
    }

    pub fn _get_product_version(&self) -> WinResult<u64> {
        unsafe {
            let mut product_version = 0;
            self.0.GetVersion(None, Some(&mut product_version))?;
            Ok(product_version)
        }
    }

    pub fn find_type_by_name(
        &self,
        type_name: impl AsRef<WStr>,
    ) -> WinResult<DebugHostType> {
        unsafe { Ok(self.0.FindTypeByName(pcw!(type_name))?.into()) }
    }

    pub fn find_symbol_by_rva(&self, rva: u64) -> WinResult<DebugHostSymbol> {
        unsafe { Ok(self.0.FindSymbolByRVA(rva)?.into()) }
    }

    pub fn find_symbol_by_name(
        &self,
        symbol_name: impl AsRef<WStr>,
    ) -> WinResult<DebugHostSymbol> {
        unsafe { Ok(self.0.FindSymbolByName(pcw!(symbol_name))?.into()) }
    }
}

// IDebugHostModule2
impl DebugHostModule {
    pub fn find_containing_symbol_by_rva(
        &self,
        rva: u64,
    ) -> WinResult<(DebugHostSymbol, DebuggeeOffset)> {
        let mut symbol = None;
        let mut offset = 0;
        unsafe {
            self.0
                .FindContainingSymbolByRVA(rva, &mut symbol, &mut offset)?;
        }

        Ok((symbol.unwrap().into(), offset))
    }
}

// IDebugHostModule3
impl DebugHostModule {
    // GetRange
}

// IDebugHostModule4
impl DebugHostModule {
    // FindTypeByName2
}

// IDebugHostModule5
impl DebugHostModule {
    // GetPrimaryCompilerInformation
}