From e8a11468fefd81c2d9181ca15bceaf71e09a5345 Mon Sep 17 00:00:00 2001 From: SoniEx2 Date: Tue, 11 Oct 2022 09:50:36 -0300 Subject: Initial support for empty and simple patterns --- src/vm/de.rs | 148 ++++++++++++++++++++++++++++++++++++++--------------------- 1 file changed, 95 insertions(+), 53 deletions(-) (limited to 'src/vm/de.rs') diff --git a/src/vm/de.rs b/src/vm/de.rs index 640b1aa..3290ab0 100644 --- a/src/vm/de.rs +++ b/src/vm/de.rs @@ -38,11 +38,11 @@ pub(crate) struct Packer<'pat, 'state, O: Serialize> { } struct FramesMut<'packer, 'pat> { - frames: std::cell::RefMut<'packer, Vec>>, + frames: &'packer mut Vec>, } struct Frames<'packer, 'pat> { - frames: std::cell::Ref<'packer, Vec>>, + frames: &'packer Vec>, } impl<'packer, 'pat> FramesMut<'packer, 'pat> { @@ -52,9 +52,47 @@ impl<'packer, 'pat> FramesMut<'packer, 'pat> { fn iter_active_mut<'a>(&'a mut self) -> impl Iterator> where 'packer: 'a { self.iter_mut().filter(|frame| { - frame.matches + frame.matches() }) } + + /// Steps the VM into the next operation. + fn step_in(&mut self) { + self.iter_mut().for_each(|frame| { + if let Some(ref mut overstep) = frame.overstep { + *overstep += 1; + } else { + if !frame.next() { + frame.overstep = Some(1); + } else if matches!( + frame.op(), + PatternElement::ValueSubtree { .. }, + ) { + todo!() + } + } + }); + } + + fn step_out<'de>(&mut self, pack: Pack<'pat, 'de>) -> Pack<'pat, 'de> { + self.iter_mut().for_each(|frame| { + if let Some(ref mut overstep) = frame.overstep { + if *overstep > 0 { + *overstep -= 1; + } + } else { + if let Some(0) = frame.overstep { + frame.overstep = None; + } + if frame.overstep.is_none() { + if frame.prev() { + todo!(); + } + } + } + }); + pack + } } impl<'packer, 'pat> Frames<'packer, 'pat> { @@ -64,7 +102,7 @@ impl<'packer, 'pat> Frames<'packer, 'pat> { fn iter_active<'a>(&'a self) -> impl Iterator> where 'packer: 'a { self.iter().filter(|frame| { - frame.matches + frame.matches() }) } } @@ -84,13 +122,13 @@ impl<'pat, 'state, 'de, O: Serialize> Packer<'pat, 'state, O> { fn frames_mut(&mut self) -> FramesMut<'_, 'pat> { FramesMut { - frames: self.interp.frames.borrow_mut(), + frames: &mut *self.interp.frames, } } fn frames(&mut self) -> Frames<'_, 'pat> { Frames { - frames: self.interp.frames.borrow(), + frames: &*self.interp.frames, } } } @@ -115,7 +153,7 @@ impl<'pat, 'state, 'de, O: Serialize> Packer<'pat, 'state, O> { // override it in the relevant Pattern call. impl<'pat, 'state, 'de, O> serde::de::DeserializeSeed<'de> -for Packer<'pat, 'state, O> +for &mut Packer<'pat, 'state, O> where O: Serialize, { @@ -127,11 +165,7 @@ where where D: serde::Deserializer<'de> { - self.frames_mut().iter_mut().for_each(|frame| { - if !frame.next() { - frame.matches = false; - } - }); + self.frames_mut().step_in(); let pat = self.interp.pat; let target_type = self.frames().iter_active().fold( Type::IgnoredAny, @@ -159,54 +193,62 @@ where }, ); match target_type { - Type::Any => deserializer.deserialize_any(self), - Type::IgnoredAny => deserializer.deserialize_ignored_any(self), - Type::Bool => deserializer.deserialize_bool(self), - Type::I8 => deserializer.deserialize_i8(self), - Type::I16 => deserializer.deserialize_i16(self), - Type::I32 => deserializer.deserialize_i32(self), - Type::I64 => deserializer.deserialize_i64(self), - Type::I128 => deserializer.deserialize_i128(self), - Type::U8 => deserializer.deserialize_u8(self), - Type::U16 => deserializer.deserialize_u16(self), - Type::U32 => deserializer.deserialize_u32(self), - Type::U64 => deserializer.deserialize_u64(self), - Type::U128 => deserializer.deserialize_u128(self), - Type::F32 => deserializer.deserialize_f32(self), - Type::F64 => deserializer.deserialize_f64(self), - Type::Char => deserializer.deserialize_char(self), + Type::Any => deserializer.deserialize_any(&mut *self), + Type::IgnoredAny => { + deserializer.deserialize_ignored_any(&mut *self) + }, + Type::Bool => deserializer.deserialize_bool(&mut *self), + Type::I8 => deserializer.deserialize_i8(&mut *self), + Type::I16 => deserializer.deserialize_i16(&mut *self), + Type::I32 => deserializer.deserialize_i32(&mut *self), + Type::I64 => deserializer.deserialize_i64(&mut *self), + Type::I128 => deserializer.deserialize_i128(&mut *self), + Type::U8 => deserializer.deserialize_u8(&mut *self), + Type::U16 => deserializer.deserialize_u16(&mut *self), + Type::U32 => deserializer.deserialize_u32(&mut *self), + Type::U64 => deserializer.deserialize_u64(&mut *self), + Type::U128 => deserializer.deserialize_u128(&mut *self), + Type::F32 => deserializer.deserialize_f32(&mut *self), + Type::F64 => deserializer.deserialize_f64(&mut *self), + Type::Char => deserializer.deserialize_char(&mut *self), Type::Str if !self.collecting => { - deserializer.deserialize_str(self) + deserializer.deserialize_str(&mut *self) + }, + Type::Str | Type::String => { + deserializer.deserialize_string(&mut *self) }, - Type::Str | Type::String => deserializer.deserialize_string(self), Type::Bytes if !self.collecting => { - deserializer.deserialize_bytes(self) + deserializer.deserialize_bytes(&mut *self) }, Type::Bytes | Type::ByteBuf => { - deserializer.deserialize_byte_buf(self) + deserializer.deserialize_byte_buf(&mut *self) + }, + Type::Option => deserializer.deserialize_option(&mut *self), + Type::Unit => deserializer.deserialize_unit(&mut *self), + Type::Seq => deserializer.deserialize_seq(&mut *self), + Type::Map => deserializer.deserialize_map(&mut *self), + Type::Identifier => { + deserializer.deserialize_identifier(&mut *self) + }, + Type::Tuple(len) => { + deserializer.deserialize_tuple(len, &mut *self) }, - Type::Option => deserializer.deserialize_option(self), - Type::Unit => deserializer.deserialize_unit(self), - Type::Seq => deserializer.deserialize_seq(self), - Type::Map => deserializer.deserialize_map(self), - Type::Identifier => deserializer.deserialize_identifier(self), - Type::Tuple(len) => deserializer.deserialize_tuple(len, self), Type::UnitStruct(name) => { - deserializer.deserialize_unit_struct(name, self) + deserializer.deserialize_unit_struct(name, &mut *self) }, Type::NewtypeStruct(name) => { - deserializer.deserialize_newtype_struct(name, self) + deserializer.deserialize_newtype_struct(name, &mut *self) }, Type::TupleStruct { name, len } => { - deserializer.deserialize_tuple_struct(name, len, self) + deserializer.deserialize_tuple_struct(name, len, &mut *self) }, Type::Struct { name, fields } => { - deserializer.deserialize_struct(name, fields, self) + deserializer.deserialize_struct(name, fields, &mut *self) }, Type::Enum { name, variants } => { - deserializer.deserialize_enum(name, variants, self) + deserializer.deserialize_enum(name, variants, &mut *self) }, - } + }.map(|(pack, obj)| (self.frames_mut().step_out(pack), obj)) } } @@ -238,7 +280,7 @@ macro_rules! vs { } impl<'pat, 'state, 'de, O> serde::de::Visitor<'de> -for Packer<'pat, 'state, O> +for &mut Packer<'pat, 'state, O> where O: Serialize, { @@ -548,8 +590,8 @@ mod tests { fn test_broken() { let consts = PatternConstants::<()>::default(); let mut err = Default::default(); - let frames = Default::default(); - let interp = Interpreter::new(&consts, &mut err, &frames); + let mut frames = Default::default(); + let interp = Interpreter::new(&consts, &mut err, &mut frames); let _ = Packer::new(interp, MAX_CALLS); } @@ -558,8 +600,8 @@ mod tests { let mut consts = PatternConstants::<()>::default(); consts.protos.push(Vec::new()); let mut err = Default::default(); - let frames = Default::default(); - let interp = Interpreter::new(&consts, &mut err, &frames); + let mut frames = Default::default(); + let interp = Interpreter::new(&consts, &mut err, &mut frames); let _ = Packer::new(interp, MAX_CALLS); } @@ -569,8 +611,8 @@ mod tests { consts.protos.push(Vec::new()); let mut der = JsonDeserializer::from_str("{}"); let mut err = Default::default(); - let frames = Default::default(); - let interp = Interpreter::new(&consts, &mut err, &frames); + let mut frames = Default::default(); + let interp = Interpreter::new(&consts, &mut err, &mut frames); let pack = Packer::new(interp, MAX_CALLS).deserialize(&mut der).unwrap(); } @@ -588,8 +630,8 @@ mod tests { ]); let mut der = JsonDeserializer::from_str("3"); let mut err = Default::default(); - let frames = Default::default(); - let interp = Interpreter::new(&consts, &mut err, &frames); + let mut frames = Default::default(); + let interp = Interpreter::new(&consts, &mut err, &mut frames); let packed = Packer::new(interp, MAX_CALLS).deserialize(&mut der); let (pack, obj) = packed.unwrap(); assert!(obj.is_none()); -- cgit 1.4.1