windows_metadata/reader/
blob.rs

1use super::*;
2
3pub struct Blob<'a> {
4    index: &'a Index,
5    file: usize,
6    slice: &'a [u8],
7}
8
9impl Drop for Blob<'_> {
10    fn drop(&mut self) {
11        debug_assert_eq!(self.len(), 0);
12    }
13}
14
15impl std::fmt::Debug for Blob<'_> {
16    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17        write!(f, "{:?}", self.slice)
18    }
19}
20
21impl std::ops::Deref for Blob<'_> {
22    type Target = [u8];
23
24    fn deref(&self) -> &[u8] {
25        self.slice
26    }
27}
28
29impl<'a> Blob<'a> {
30    pub fn new(index: &'a Index, file: usize, slice: &'a [u8]) -> Self {
31        Self { index, file, slice }
32    }
33
34    fn peek(&self) -> (usize, usize) {
35        if self[0] & 0x80 == 0 {
36            (self[0] as usize, 1)
37        } else if self[0] & 0xC0 == 0x80 {
38            ((((self[0] & 0x3F) as usize) << 8) | self[1] as usize, 2)
39        } else {
40            (
41                (((self[0] & 0x1F) as usize) << 24)
42                    | ((self[1] as usize) << 16)
43                    | ((self[2] as usize) << 8)
44                    | self[3] as usize,
45                4,
46            )
47        }
48    }
49
50    pub fn decode<D: Decode<'a>>(&mut self) -> D {
51        D::decode(self.index, self.file, self.read_compressed())
52    }
53
54    pub fn try_read(&mut self, expected: usize) -> bool {
55        let (value, offset) = self.peek();
56        if value == expected {
57            self.offset(offset);
58            true
59        } else {
60            false
61        }
62    }
63
64    pub fn read_modifiers(&mut self) -> Vec<TypeDefOrRef> {
65        let mut mods = vec![];
66        loop {
67            let (value, offset) = self.peek();
68            if value != ELEMENT_TYPE_CMOD_OPT as usize && value != ELEMENT_TYPE_CMOD_REQD as usize {
69                break;
70            } else {
71                self.offset(offset);
72                mods.push(TypeDefOrRef::decode(
73                    self.index,
74                    self.file,
75                    self.read_compressed(),
76                ))
77            }
78        }
79        mods
80    }
81
82    pub fn read_method_signature(&mut self, generics: &[Type]) -> Signature {
83        let flags = MethodCallAttributes(self.read_u8());
84        let param_count = self.read_compressed();
85        let return_type = self.read_type_signature(generics);
86
87        let mut types = vec![];
88
89        for _ in 0..param_count {
90            types.push(self.read_type_signature(generics));
91        }
92
93        Signature {
94            flags,
95            return_type,
96            types,
97        }
98    }
99
100    // Used to parse field and methods type signatures
101    pub fn read_type_signature(&mut self, generics: &[Type]) -> Type {
102        let is_const = self.read_modifiers().iter().any(|def| {
103            def.namespace() == "System.Runtime.CompilerServices" && def.name() == "IsConst"
104        });
105
106        let is_ref = self.try_read(ELEMENT_TYPE_BYREF as usize);
107
108        if self.try_read(ELEMENT_TYPE_VOID as usize) {
109            return Type::Void;
110        }
111
112        let is_array = self.try_read(ELEMENT_TYPE_SZARRAY as usize);
113
114        let mut pointers = 0;
115
116        while self.try_read(ELEMENT_TYPE_PTR as usize) {
117            pointers += 1;
118        }
119
120        let ty = self.read_type_code(generics);
121
122        // TODO: why don't we just use IsConst to decide whether pointers are const?
123        if pointers > 0 {
124            Type::PtrMut(Box::new(ty), pointers)
125        } else if is_const {
126            Type::ConstRef(Box::new(ty))
127        } else if is_array {
128            if is_ref {
129                Type::ArrayRef(Box::new(ty))
130            } else {
131                Type::Array(Box::new(ty))
132            }
133        } else {
134            ty
135        }
136    }
137
138    pub fn read_type_code(&mut self, generics: &[Type]) -> Type {
139        match self.read_u8() {
140            ELEMENT_TYPE_VOID => Type::Void,
141            ELEMENT_TYPE_BOOLEAN => Type::Bool,
142            ELEMENT_TYPE_CHAR => Type::Char,
143            ELEMENT_TYPE_I1 => Type::I8,
144            ELEMENT_TYPE_U1 => Type::U8,
145            ELEMENT_TYPE_I2 => Type::I16,
146            ELEMENT_TYPE_U2 => Type::U16,
147            ELEMENT_TYPE_I4 => Type::I32,
148            ELEMENT_TYPE_U4 => Type::U32,
149            ELEMENT_TYPE_I8 => Type::I64,
150            ELEMENT_TYPE_U8 => Type::U64,
151            ELEMENT_TYPE_R4 => Type::F32,
152            ELEMENT_TYPE_R8 => Type::F64,
153            ELEMENT_TYPE_I => Type::ISize,
154            ELEMENT_TYPE_U => Type::USize,
155            ELEMENT_TYPE_STRING => Type::String,
156            ELEMENT_TYPE_OBJECT => Type::Object,
157            ELEMENT_TYPE_VALUETYPE | ELEMENT_TYPE_CLASS => {
158                self.decode::<TypeDefOrRef>().ty(generics)
159            }
160            ELEMENT_TYPE_VAR => generics[self.read_compressed()].clone(),
161            ELEMENT_TYPE_ARRAY => {
162                // See II.23.2.13 ArrayShape
163                let ty = self.read_type_signature(generics);
164                let rank = self.read_compressed();
165                debug_assert_eq!(rank, 1);
166                let num_sizes = self.read_compressed();
167                debug_assert_eq!(num_sizes, 1);
168                let size = self.read_compressed();
169                let num_lo_bounds = self.read_compressed();
170                debug_assert!(num_lo_bounds == 0 || num_lo_bounds == 1);
171
172                for _ in 0..num_lo_bounds {
173                    let lo_bounds = self.read_compressed();
174                    debug_assert_eq!(lo_bounds, 0);
175                }
176
177                Type::ArrayFixed(Box::new(ty), size)
178            }
179            ELEMENT_TYPE_GENERICINST => {
180                let type_code = self.read_u8();
181
182                debug_assert!(matches!(
183                    type_code,
184                    ELEMENT_TYPE_VALUETYPE | ELEMENT_TYPE_CLASS
185                ));
186
187                let ty = self.decode::<TypeDefOrRef>();
188                let mut ty_generics = vec![];
189
190                for _ in 0..self.read_compressed() {
191                    ty_generics.push(self.read_type_code(generics));
192                }
193
194                Type::Name(TypeName {
195                    namespace: ty.namespace().to_string(),
196                    name: ty.name().to_string(),
197                    generics: ty_generics,
198                })
199            }
200            0x55 => Type::AttributeEnum,
201            rest => panic!("{rest:?}"),
202        }
203    }
204
205    pub fn read_compressed(&mut self) -> usize {
206        let (value, offset) = self.peek();
207        self.offset(offset);
208        value
209    }
210
211    pub fn read_utf8(&mut self) -> String {
212        let len = self.read_compressed();
213        let value = unsafe { std::str::from_utf8_unchecked(&self.slice[..len]) };
214        self.offset(len);
215        value.to_string()
216    }
217
218    pub fn read_utf16(&mut self) -> String {
219        let slice = self.slice;
220
221        let value = if slice.as_ptr().align_offset(std::mem::align_of::<u16>()) > 0 {
222            let slice = slice
223                .chunks_exact(2)
224                .take(slice.len() / 2)
225                .map(|chunk| u16::from_le_bytes(chunk.try_into().unwrap()))
226                .collect::<Vec<u16>>();
227
228            String::from_utf16_lossy(&slice)
229        } else {
230            let slice = unsafe {
231                std::slice::from_raw_parts(slice.as_ptr() as *const u16, slice.len() / 2)
232            };
233
234            String::from_utf16_lossy(slice)
235        };
236
237        self.offset(slice.len());
238        value
239    }
240
241    pub fn read_bool(&mut self) -> bool {
242        // A bool is specified as "a single byte with value 0 (false) or 1 (true)".
243        match self.read_u8() {
244            0 => false,
245            1 => true,
246            _ => panic!(),
247        }
248    }
249
250    pub fn read_i8(&mut self) -> i8 {
251        let value = i8::from_le_bytes(self[..1].try_into().unwrap());
252        self.offset(1);
253        value
254    }
255
256    pub fn read_u8(&mut self) -> u8 {
257        let value = u8::from_le_bytes(self[..1].try_into().unwrap());
258        self.offset(1);
259        value
260    }
261
262    pub fn read_i16(&mut self) -> i16 {
263        let value = i16::from_le_bytes(self[..2].try_into().unwrap());
264        self.offset(2);
265        value
266    }
267
268    pub fn read_u16(&mut self) -> u16 {
269        let value = u16::from_le_bytes(self[..2].try_into().unwrap());
270        self.offset(2);
271        value
272    }
273
274    pub fn read_i32(&mut self) -> i32 {
275        let value = i32::from_le_bytes(self[..4].try_into().unwrap());
276        self.offset(4);
277        value
278    }
279
280    pub fn read_u32(&mut self) -> u32 {
281        let value = u32::from_le_bytes(self[..4].try_into().unwrap());
282        self.offset(4);
283        value
284    }
285
286    pub fn read_i64(&mut self) -> i64 {
287        let value = i64::from_le_bytes(self[..8].try_into().unwrap());
288        self.offset(8);
289        value
290    }
291
292    pub fn read_u64(&mut self) -> u64 {
293        let value = u64::from_le_bytes(self[..8].try_into().unwrap());
294        self.offset(8);
295        value
296    }
297
298    pub fn read_f32(&mut self) -> f32 {
299        let value = f32::from_le_bytes(self[..4].try_into().unwrap());
300        self.offset(4);
301        value
302    }
303
304    pub fn read_f64(&mut self) -> f64 {
305        let value = f64::from_le_bytes(self[..8].try_into().unwrap());
306        self.offset(8);
307        value
308    }
309
310    fn offset(&mut self, offset: usize) {
311        self.slice = &self.slice[offset..];
312    }
313}
windows_metadata/reader/blob.rs

windows_metadata/reader/
blob.rs
