Skip to content

Commit 06e0dd4

Browse files
ValeryAntopolValeryAntopol
authored
feat!: pass a context object through the API to the wasm engine functions (#34)
1 parent da020b8 commit 06e0dd4

25 files changed

+688
-383
lines changed

‎crates/it-lilo/src/lifter/lift_array.rs

+55-42
Original file line numberDiff line numberDiff line change
@@ -24,8 +24,13 @@ use crate::IValue;
2424

2525
use it_memory_traits::MemoryView;
2626

27-
pub fn array_lift_memory<R: RecordResolvable, MV: MemoryView>(
28-
lifter: &ILifter<'_, R, MV>,
27+
pub fn array_lift_memory<
28+
R: RecordResolvable,
29+
MV: MemoryView<Store>,
30+
Store: it_memory_traits::Store,
31+
>(
32+
store: &mut <Store as it_memory_traits::Store>::ActualStore<'_>,
33+
lifter: &ILifter<'_, R, MV, Store>,
2934
value_type: &IType,
3035
offset: u32,
3136
elements_count: u32,
@@ -37,90 +42,98 @@ pub fn array_lift_memory<R: RecordResolvable, MV: MemoryView>(
3742
let reader = &lifter.reader;
3843

3944
let ivalues = match value_type {
40-
IType::Boolean => reader.read_bool_array(offset, elements_count)?,
41-
IType::S8 => reader.read_s8_array(offset, elements_count)?,
42-
IType::S16 => reader.read_s16_array(offset, elements_count)?,
43-
IType::S32 => reader.read_s32_array(offset, elements_count)?,
44-
IType::S64 => reader.read_s64_array(offset, elements_count)?,
45-
IType::I32 => reader.read_i32_array(offset, elements_count)?,
46-
IType::I64 => reader.read_i64_array(offset, elements_count)?,
47-
IType::U8 => reader.read_u8_array(offset, elements_count)?,
48-
IType::U16 => reader.read_u16_array(offset, elements_count)?,
49-
IType::U32 => reader.read_u32_array(offset, elements_count)?,
50-
IType::U64 => reader.read_u64_array(offset, elements_count)?,
51-
IType::F32 => reader.read_f32_array(offset, elements_count)?,
52-
IType::F64 => reader.read_f64_array(offset, elements_count)?,
53-
IType::String => read_string_array(lifter, offset, elements_count)?,
54-
IType::ByteArray => read_array_array(lifter, &IType::U8, offset, elements_count)?,
55-
IType::Array(ty) => read_array_array(lifter, &ty, offset, elements_count)?,
45+
IType::Boolean => reader.read_bool_array(store, offset, elements_count)?,
46+
IType::S8 => reader.read_s8_array(store, offset, elements_count)?,
47+
IType::S16 => reader.read_s16_array(store, offset, elements_count)?,
48+
IType::S32 => reader.read_s32_array(store, offset, elements_count)?,
49+
IType::S64 => reader.read_s64_array(store, offset, elements_count)?,
50+
IType::I32 => reader.read_i32_array(store, offset, elements_count)?,
51+
IType::I64 => reader.read_i64_array(store, offset, elements_count)?,
52+
IType::U8 => reader.read_u8_array(store, offset, elements_count)?,
53+
IType::U16 => reader.read_u16_array(store, offset, elements_count)?,
54+
IType::U32 => reader.read_u32_array(store, offset, elements_count)?,
55+
IType::U64 => reader.read_u64_array(store, offset, elements_count)?,
56+
IType::F32 => reader.read_f32_array(store, offset, elements_count)?,
57+
IType::F64 => reader.read_f64_array(store, offset, elements_count)?,
58+
IType::String => read_string_array(store, lifter, offset, elements_count)?,
59+
IType::ByteArray => read_array_array(store, lifter, &IType::U8, offset, elements_count)?,
60+
IType::Array(ty) => read_array_array(store, lifter, &ty, offset, elements_count)?,
5661
IType::Record(record_type_id) => {
57-
read_record_array(lifter, *record_type_id, offset, elements_count)?
62+
read_record_array(store, lifter, *record_type_id, offset, elements_count)?
5863
}
5964
};
6065

6166
Ok(IValue::Array(ivalues))
6267
}
6368

64-
fn read_string_array<R: RecordResolvable, MV: MemoryView>(
65-
lifter: &ILifter<'_, R, MV>,
69+
fn read_string_array<R: RecordResolvable, MV: MemoryView<Store>, Store: it_memory_traits::Store>(
70+
store: &mut <Store as it_memory_traits::Store>::ActualStore<'_>,
71+
lifter: &ILifter<'_, R, MV, Store>,
6672
offset: u32,
6773
elements_count: u32,
6874
) -> LiResult<Vec<IValue>> {
6975
let mut result = Vec::with_capacity(elements_count as usize);
70-
let seq_reader = lifter
71-
.reader
72-
.sequential_reader(offset, ser_type_size(&IType::String) * elements_count)?;
76+
let seq_reader = lifter.reader.sequential_reader(
77+
store,
78+
offset,
79+
ser_type_size(&IType::String) * elements_count,
80+
)?;
7381

7482
for _ in 0..elements_count {
75-
let offset = seq_reader.read_u32();
76-
let size = seq_reader.read_u32();
83+
let offset = seq_reader.read_u32(store);
84+
let size = seq_reader.read_u32(store);
7785

78-
let raw_str = lifter.reader.read_raw_u8_array(offset, size)?;
86+
let raw_str = lifter.reader.read_raw_u8_array(store, offset, size)?;
7987
let str = String::from_utf8(raw_str)?;
8088
result.push(IValue::String(str));
8189
}
8290

8391
Ok(result)
8492
}
8593

86-
fn read_array_array<R: RecordResolvable, MV: MemoryView>(
87-
lifter: &ILifter<'_, R, MV>,
94+
fn read_array_array<R: RecordResolvable, MV: MemoryView<Store>, Store: it_memory_traits::Store>(
95+
store: &mut <Store as it_memory_traits::Store>::ActualStore<'_>,
96+
lifter: &ILifter<'_, R, MV, Store>,
8897
ty: &IType,
8998
offset: u32,
9099
elements_count: u32,
91100
) -> LiResult<Vec<IValue>> {
92101
let mut result = Vec::with_capacity(elements_count as usize);
93-
let seq_reader = lifter
94-
.reader
95-
.sequential_reader(offset, ser_type_size(ty) * elements_count)?;
102+
let seq_reader =
103+
lifter
104+
.reader
105+
.sequential_reader(store, offset, ser_type_size(ty) * elements_count)?;
96106

97107
for _ in 0..elements_count {
98-
let offset = seq_reader.read_u32();
99-
let size = seq_reader.read_u32();
108+
let offset = seq_reader.read_u32(store);
109+
let size = seq_reader.read_u32(store);
100110

101-
let array = array_lift_memory(lifter, ty, offset, size)?;
111+
let array = array_lift_memory(store, lifter, ty, offset, size)?;
102112
result.push(array);
103113
}
104114

105115
Ok(result)
106116
}
107117

108-
fn read_record_array<R: RecordResolvable, MV: MemoryView>(
109-
lifter: &ILifter<'_, R, MV>,
118+
fn read_record_array<R: RecordResolvable, MV: MemoryView<Store>, Store: it_memory_traits::Store>(
119+
store: &mut <Store as it_memory_traits::Store>::ActualStore<'_>,
120+
lifter: &ILifter<'_, R, MV, Store>,
110121
record_type_id: u64,
111122
offset: u32,
112123
elements_count: u32,
113124
) -> LiResult<Vec<IValue>> {
114125
let mut result = Vec::with_capacity(elements_count as usize);
115-
let seq_reader = lifter
116-
.reader
117-
.sequential_reader(offset, ser_type_size(&IType::Record(0)) * elements_count)?;
126+
let seq_reader = lifter.reader.sequential_reader(
127+
store,
128+
offset,
129+
ser_type_size(&IType::Record(0)) * elements_count,
130+
)?;
118131

119132
for _ in 0..elements_count {
120-
let offset = seq_reader.read_u32();
133+
let offset = seq_reader.read_u32(store);
121134
let record_ty = lifter.resolver.resolve_record(record_type_id)?;
122135

123-
let record = record_lift_memory(lifter, &record_ty, offset)?;
136+
let record = record_lift_memory(store, lifter, &record_ty, offset)?;
124137
result.push(record);
125138
}
126139

‎crates/it-lilo/src/lifter/lift_record.rs

+52-43
Original file line numberDiff line numberDiff line change
@@ -28,37 +28,42 @@ use crate::NEVec;
2828

2929
use it_memory_traits::MemoryView;
3030

31-
pub fn record_lift_memory<R: RecordResolvable, MV: MemoryView>(
32-
lifter: &ILifter<'_, R, MV>,
31+
pub fn record_lift_memory<
32+
R: RecordResolvable,
33+
MV: MemoryView<Store>,
34+
Store: it_memory_traits::Store,
35+
>(
36+
store: &mut <Store as it_memory_traits::Store>::ActualStore<'_>,
37+
lifter: &ILifter<'_, R, MV, Store>,
3338
record_type: &IRecordType,
3439
offset: u32,
3540
) -> LiResult<IValue> {
3641
let mut values = Vec::with_capacity(record_type.fields.len());
3742

3843
let size = record_size(record_type);
3944
let reader = &lifter.reader;
40-
let seq_reader = reader.sequential_reader(offset, size)?;
45+
let seq_reader = reader.sequential_reader(store, offset, size)?;
4146

4247
for field in (*record_type.fields).iter() {
4348
match &field.ty {
44-
IType::Boolean => values.push(IValue::Boolean(seq_reader.read_u8() != 0)),
45-
IType::S8 => values.push(IValue::S8(seq_reader.read_i8())),
46-
IType::S16 => values.push(IValue::S16(seq_reader.read_i16())),
47-
IType::S32 => values.push(IValue::S32(seq_reader.read_i32())),
48-
IType::S64 => values.push(IValue::S64(seq_reader.read_i64())),
49-
IType::I32 => values.push(IValue::I32(seq_reader.read_i32())),
50-
IType::I64 => values.push(IValue::I64(seq_reader.read_i64())),
51-
IType::U8 => values.push(IValue::U8(seq_reader.read_u8())),
52-
IType::U16 => values.push(IValue::U16(seq_reader.read_u16())),
53-
IType::U32 => values.push(IValue::U32(seq_reader.read_u32())),
54-
IType::U64 => values.push(IValue::U64(seq_reader.read_u64())),
55-
IType::F32 => values.push(IValue::F32(seq_reader.read_f32())),
56-
IType::F64 => values.push(IValue::F64(seq_reader.read_f64())),
57-
IType::String => values.push(IValue::String(read_string(reader, &seq_reader)?)),
58-
IType::ByteArray => values.push(read_byte_array(reader, &seq_reader)?),
59-
IType::Array(ty) => values.push(read_array(&lifter, &seq_reader, &**ty)?),
49+
IType::Boolean => values.push(IValue::Boolean(seq_reader.read_u8(store) != 0)),
50+
IType::S8 => values.push(IValue::S8(seq_reader.read_i8(store))),
51+
IType::S16 => values.push(IValue::S16(seq_reader.read_i16(store))),
52+
IType::S32 => values.push(IValue::S32(seq_reader.read_i32(store))),
53+
IType::S64 => values.push(IValue::S64(seq_reader.read_i64(store))),
54+
IType::I32 => values.push(IValue::I32(seq_reader.read_i32(store))),
55+
IType::I64 => values.push(IValue::I64(seq_reader.read_i64(store))),
56+
IType::U8 => values.push(IValue::U8(seq_reader.read_u8(store))),
57+
IType::U16 => values.push(IValue::U16(seq_reader.read_u16(store))),
58+
IType::U32 => values.push(IValue::U32(seq_reader.read_u32(store))),
59+
IType::U64 => values.push(IValue::U64(seq_reader.read_u64(store))),
60+
IType::F32 => values.push(IValue::F32(seq_reader.read_f32(store))),
61+
IType::F64 => values.push(IValue::F64(seq_reader.read_f64(store))),
62+
IType::String => values.push(IValue::String(read_string(store, reader, &seq_reader)?)),
63+
IType::ByteArray => values.push(read_byte_array(store, reader, &seq_reader)?),
64+
IType::Array(ty) => values.push(read_array(store, &lifter, &seq_reader, &**ty)?),
6065
IType::Record(record_type_id) => {
61-
values.push(read_record(lifter, &seq_reader, *record_type_id)?)
66+
values.push(read_record(store, lifter, &seq_reader, *record_type_id)?)
6267
}
6368
}
6469
}
@@ -69,50 +74,54 @@ pub fn record_lift_memory<R: RecordResolvable, MV: MemoryView>(
6974
Ok(IValue::Record(record))
7075
}
7176

72-
fn read_string<MV: MemoryView>(
73-
reader: &MemoryReader<MV>,
74-
seq_reader: &SequentialReader<'_, MV>,
77+
fn read_string<MV: MemoryView<Store>, Store: it_memory_traits::Store>(
78+
store: &mut <Store as it_memory_traits::Store>::ActualStore<'_>,
79+
reader: &MemoryReader<MV, Store>,
80+
seq_reader: &SequentialReader<'_, MV, Store>,
7581
) -> LiResult<String> {
76-
let offset = seq_reader.read_u32();
77-
let size = seq_reader.read_u32();
82+
let offset = seq_reader.read_u32(store);
83+
let size = seq_reader.read_u32(store);
7884

79-
let string_mem = reader.read_raw_u8_array(offset, size)?;
85+
let string_mem = reader.read_raw_u8_array(store, offset, size)?;
8086

8187
let string = String::from_utf8(string_mem)?;
8288
Ok(string)
8389
}
8490

85-
fn read_byte_array<MV: MemoryView>(
86-
reader: &MemoryReader<MV>,
87-
seq_reader: &SequentialReader<'_, MV>,
91+
fn read_byte_array<MV: MemoryView<Store>, Store: it_memory_traits::Store>(
92+
store: &mut <Store as it_memory_traits::Store>::ActualStore<'_>,
93+
reader: &MemoryReader<MV, Store>,
94+
seq_reader: &SequentialReader<'_, MV, Store>,
8895
) -> LiResult<IValue> {
89-
let offset = seq_reader.read_u32();
90-
let size = seq_reader.read_u32();
96+
let offset = seq_reader.read_u32(store);
97+
let size = seq_reader.read_u32(store);
9198

92-
let array = reader.read_raw_u8_array(offset, size)?;
99+
let array = reader.read_raw_u8_array(store, offset, size)?;
93100

94101
Ok(IValue::ByteArray(array))
95102
}
96103

97-
fn read_array<R: RecordResolvable, MV: MemoryView>(
98-
lifter: &ILifter<'_, R, MV>,
99-
seq_reader: &SequentialReader<'_, MV>,
104+
fn read_array<R: RecordResolvable, MV: MemoryView<Store>, Store: it_memory_traits::Store>(
105+
store: &mut <Store as it_memory_traits::Store>::ActualStore<'_>,
106+
lifter: &ILifter<'_, R, MV, Store>,
107+
seq_reader: &SequentialReader<'_, MV, Store>,
100108
value_type: &IType,
101109
) -> LiResult<IValue> {
102-
let offset = seq_reader.read_u32();
103-
let size = seq_reader.read_u32();
110+
let offset = seq_reader.read_u32(store);
111+
let size = seq_reader.read_u32(store);
104112

105-
super::array_lift_memory(lifter, value_type, offset, size)
113+
super::array_lift_memory(store, lifter, value_type, offset, size)
106114
}
107115

108-
fn read_record<R: RecordResolvable, MV: MemoryView>(
109-
lifter: &ILifter<'_, R, MV>,
110-
seq_reader: &SequentialReader<'_, MV>,
116+
fn read_record<R: RecordResolvable, MV: MemoryView<Store>, Store: it_memory_traits::Store>(
117+
store: &mut <Store as it_memory_traits::Store>::ActualStore<'_>,
118+
lifter: &ILifter<'_, R, MV, Store>,
119+
seq_reader: &SequentialReader<'_, MV, Store>,
111120
record_type_id: u64,
112121
) -> LiResult<IValue> {
113-
let offset = seq_reader.read_u32();
122+
let offset = seq_reader.read_u32(store);
114123

115124
let record_type = lifter.resolver.resolve_record(record_type_id)?;
116125

117-
record_lift_memory(lifter, &record_type, offset)
126+
record_lift_memory(store, lifter, &record_type, offset)
118127
}

0 commit comments

Comments
 (0)