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 159 160 161 162
use crate::{ BinaryReader, BinaryReaderError, ExternalKind, Range, Result, SectionIteratorLimited, SectionReader, SectionWithLimitedItems, }; #[derive(Clone)] pub struct InstanceSectionReader<'a> { reader: BinaryReader<'a>, count: u32, } impl<'a> InstanceSectionReader<'a> { pub fn new(data: &'a [u8], offset: usize) -> Result<InstanceSectionReader<'a>> { let mut reader = BinaryReader::new_with_offset(data, offset); let count = reader.read_var_u32()?; Ok(InstanceSectionReader { reader, count }) } pub fn original_position(&self) -> usize { self.reader.original_position() } pub fn get_count(&self) -> u32 { self.count } pub fn read(&mut self) -> Result<Instance<'a>> { let instance = Instance::new( &self.reader.buffer[self.reader.position..], self.original_position(), )?; self.reader.skip_bytes(1)?; self.reader.skip_var_32()?; let count = self.reader.read_var_u32()?; for _ in 0..count { self.reader.skip_bytes(1)?; self.reader.skip_var_32()?; } Ok(instance) } } impl<'a> SectionReader for InstanceSectionReader<'a> { type Item = Instance<'a>; fn read(&mut self) -> Result<Self::Item> { InstanceSectionReader::read(self) } fn eof(&self) -> bool { self.reader.eof() } fn original_position(&self) -> usize { InstanceSectionReader::original_position(self) } fn range(&self) -> Range { self.reader.range() } } impl<'a> SectionWithLimitedItems for InstanceSectionReader<'a> { fn get_count(&self) -> u32 { InstanceSectionReader::get_count(self) } } impl<'a> IntoIterator for InstanceSectionReader<'a> { type Item = Result<Instance<'a>>; type IntoIter = SectionIteratorLimited<InstanceSectionReader<'a>>; fn into_iter(self) -> Self::IntoIter { SectionIteratorLimited::new(self) } } pub struct Instance<'a> { reader: BinaryReader<'a>, module: u32, } impl<'a> Instance<'a> { pub fn new(data: &'a [u8], offset: usize) -> Result<Instance<'a>> { let mut reader = BinaryReader::new_with_offset(data, offset); if reader.read_u8()? != 0 { return Err(BinaryReaderError::new( "instantiate instruction not found", offset, )); } let module = reader.read_var_u32()?; Ok(Instance { module, reader }) } pub fn original_position(&self) -> usize { self.reader.original_position() } pub fn module(&self) -> u32 { self.module } pub fn args(&self) -> Result<InstanceArgsReader<'a>> { let mut reader = self.reader.clone(); let count = reader.read_var_u32()?; Ok(InstanceArgsReader { count, remaining: count, reader, }) } } #[derive(Clone)] pub struct InstanceArgsReader<'a> { reader: BinaryReader<'a>, count: u32, remaining: u32, } impl<'a> InstanceArgsReader<'a> { pub fn original_position(&self) -> usize { self.reader.original_position() } pub fn read(&mut self) -> Result<(ExternalKind, u32)> { let kind = self.reader.read_external_kind()?; let index = self.reader.read_var_u32()?; self.remaining -= 1; Ok((kind, index)) } } impl<'a> SectionReader for InstanceArgsReader<'a> { type Item = (ExternalKind, u32); fn read(&mut self) -> Result<Self::Item> { InstanceArgsReader::read(self) } fn eof(&self) -> bool { self.remaining == 0 } fn original_position(&self) -> usize { InstanceArgsReader::original_position(self) } fn range(&self) -> Range { self.reader.range() } } impl<'a> SectionWithLimitedItems for InstanceArgsReader<'a> { fn get_count(&self) -> u32 { self.count } } impl<'a> IntoIterator for InstanceArgsReader<'a> { type Item = Result<(ExternalKind, u32)>; type IntoIter = SectionIteratorLimited<InstanceArgsReader<'a>>; fn into_iter(self) -> Self::IntoIter { SectionIteratorLimited::new(self) } }