windows_metadata/reader/
blob.rs

1use super::*;
2
3pub struct Blob<'a> {
4    index: &'a TypeIndex,
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 TypeIndex, 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<'a>> {
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        if pointers > 0 {
123            if is_const {
124                Type::PtrConst(Box::new(ty), pointers)
125            } else {
126                Type::PtrMut(Box::new(ty), pointers)
127            }
128        } else if is_const {
129            Type::RefConst(Box::new(ty))
130        } else if is_array {
131            if is_ref {
132                Type::ArrayRef(Box::new(ty))
133            } else {
134                Type::Array(Box::new(ty))
135            }
136        } else if is_ref {
137            Type::RefMut(Box::new(ty))
138        } else {
139            ty
140        }
141    }
142
143    pub fn read_type_code(&mut self, generics: &[Type]) -> Type {
144        match self.read_u8() {
145            ELEMENT_TYPE_VOID => Type::Void,
146            ELEMENT_TYPE_BOOLEAN => Type::Bool,
147            ELEMENT_TYPE_CHAR => Type::Char,
148            ELEMENT_TYPE_I1 => Type::I8,
149            ELEMENT_TYPE_U1 => Type::U8,
150            ELEMENT_TYPE_I2 => Type::I16,
151            ELEMENT_TYPE_U2 => Type::U16,
152            ELEMENT_TYPE_I4 => Type::I32,
153            ELEMENT_TYPE_U4 => Type::U32,
154            ELEMENT_TYPE_I8 => Type::I64,
155            ELEMENT_TYPE_U8 => Type::U64,
156            ELEMENT_TYPE_R4 => Type::F32,
157            ELEMENT_TYPE_R8 => Type::F64,
158            ELEMENT_TYPE_I => Type::ISize,
159            ELEMENT_TYPE_U => Type::USize,
160            ELEMENT_TYPE_STRING => Type::String,
161            ELEMENT_TYPE_OBJECT => Type::Object,
162            ELEMENT_TYPE_VALUETYPE | ELEMENT_TYPE_CLASS => {
163                self.decode::<TypeDefOrRef>().ty(generics)
164            }
165            ELEMENT_TYPE_VAR => generics[self.read_compressed()].clone(),
166            ELEMENT_TYPE_ARRAY => {
167                // See II.23.2.13 ArrayShape
168                let ty = self.read_type_signature(generics);
169                let rank = self.read_compressed();
170                debug_assert_eq!(rank, 1);
171                let num_sizes = self.read_compressed();
172                debug_assert_eq!(num_sizes, 1);
173                let size = self.read_compressed();
174                let num_lo_bounds = self.read_compressed();
175                debug_assert!(num_lo_bounds == 0 || num_lo_bounds == 1);
176
177                for _ in 0..num_lo_bounds {
178                    let lo_bounds = self.read_compressed();
179                    debug_assert_eq!(lo_bounds, 0);
180                }
181
182                Type::ArrayFixed(Box::new(ty), size)
183            }
184            ELEMENT_TYPE_GENERICINST => {
185                let type_code = self.read_u8();
186
187                debug_assert!(matches!(
188                    type_code,
189                    ELEMENT_TYPE_VALUETYPE | ELEMENT_TYPE_CLASS
190                ));
191
192                let ty = self.decode::<TypeDefOrRef>();
193                let mut ty_generics = vec![];
194
195                for _ in 0..self.read_compressed() {
196                    ty_generics.push(self.read_type_code(generics));
197                }
198
199                Type::Name(TypeName {
200                    namespace: ty.namespace().to_string(),
201                    name: ty.name().to_string(),
202                    generics: ty_generics,
203                })
204            }
205            0x55 => Type::AttributeEnum,
206            rest => panic!("{rest:?}"),
207        }
208    }
209
210    pub fn read_compressed(&mut self) -> usize {
211        let (value, offset) = self.peek();
212        self.offset(offset);
213        value
214    }
215
216    pub fn read_utf8(&mut self) -> String {
217        let len = self.read_compressed();
218        let value = unsafe { std::str::from_utf8_unchecked(&self.slice[..len]) };
219        self.offset(len);
220        value.to_string()
221    }
222
223    pub fn read_utf16(&mut self) -> String {
224        let slice = self.slice;
225
226        let value = if slice.as_ptr().align_offset(align_of::<u16>()) > 0 {
227            let slice = slice
228                .chunks_exact(2)
229                .take(slice.len() / 2)
230                .map(|chunk| u16::from_le_bytes(chunk.try_into().unwrap()))
231                .collect::<Vec<u16>>();
232
233            String::from_utf16_lossy(&slice)
234        } else {
235            let slice = unsafe {
236                std::slice::from_raw_parts(slice.as_ptr() as *const u16, slice.len() / 2)
237            };
238
239            String::from_utf16_lossy(slice)
240        };
241
242        self.offset(slice.len());
243        value
244    }
245
246    pub fn read_bool(&mut self) -> bool {
247        // A bool is specified as "a single byte with value 0 (false) or 1 (true)".
248        match self.read_u8() {
249            0 => false,
250            1 => true,
251            _ => panic!(),
252        }
253    }
254
255    pub fn read_i8(&mut self) -> i8 {
256        let value = i8::from_le_bytes(self[..1].try_into().unwrap());
257        self.offset(1);
258        value
259    }
260
261    pub fn read_u8(&mut self) -> u8 {
262        let value = u8::from_le_bytes(self[..1].try_into().unwrap());
263        self.offset(1);
264        value
265    }
266
267    pub fn read_i16(&mut self) -> i16 {
268        let value = i16::from_le_bytes(self[..2].try_into().unwrap());
269        self.offset(2);
270        value
271    }
272
273    pub fn read_u16(&mut self) -> u16 {
274        let value = u16::from_le_bytes(self[..2].try_into().unwrap());
275        self.offset(2);
276        value
277    }
278
279    pub fn read_i32(&mut self) -> i32 {
280        let value = i32::from_le_bytes(self[..4].try_into().unwrap());
281        self.offset(4);
282        value
283    }
284
285    pub fn read_u32(&mut self) -> u32 {
286        let value = u32::from_le_bytes(self[..4].try_into().unwrap());
287        self.offset(4);
288        value
289    }
290
291    pub fn read_i64(&mut self) -> i64 {
292        let value = i64::from_le_bytes(self[..8].try_into().unwrap());
293        self.offset(8);
294        value
295    }
296
297    pub fn read_u64(&mut self) -> u64 {
298        let value = u64::from_le_bytes(self[..8].try_into().unwrap());
299        self.offset(8);
300        value
301    }
302
303    pub fn read_f32(&mut self) -> f32 {
304        let value = f32::from_le_bytes(self[..4].try_into().unwrap());
305        self.offset(4);
306        value
307    }
308
309    pub fn read_f64(&mut self) -> f64 {
310        let value = f64::from_le_bytes(self[..8].try_into().unwrap());
311        self.offset(8);
312        value
313    }
314
315    fn offset(&mut self, offset: usize) {
316        self.slice = &self.slice[offset..];
317    }
318}
windows_metadata/reader/blob.rs

windows_metadata/reader/
blob.rs
