Skip to content
This repository was archived by the owner on Jun 3, 2025. It is now read-only.

Commit b432899

Browse files
fasterthanlimefasterthanlime
committed
fix: Proper starter handling in merde_msgpack
(Also, remove debug prints / backtraces in merde_json, because I needed more coffee when I pulled the trigger on that.)
1 parent 1c31efc commit b432899

File tree

3 files changed

+57
-45
lines changed

3 files changed

+57
-45
lines changed

‎merde/src/lib.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1097,6 +1097,7 @@ mod json_tests {
10971097

10981098
// used to test out doc-tests
10991099
mod doctest_playground {
1100+
11001101
#[allow(unused_imports)]
11011102
use crate as merde;
11021103

‎merde_json/src/deserialize.rs

Lines changed: 0 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -63,12 +63,6 @@ impl<'s> Deserializer<'s> for JsonDeserializer<'s> {
6363
return Ok(ev);
6464
}
6565

66-
eprintln!("stack first: {:?}", self.stack.first());
67-
// Print native code backtrace
68-
println!("Native Code Backtrace:");
69-
let backtrace = std::backtrace::Backtrace::capture();
70-
println!("{}", backtrace);
71-
7266
let peek: Option<Peek> = match self.stack.pop() {
7367
Some(StackItem::ObjectKey(maybe_key)) => match maybe_key {
7468
Some(key) => {
@@ -319,7 +313,6 @@ mod tests {
319313
let mut deser = LoggingDeserializer::new(deser);
320314

321315
let value = deser.deserialize::<merde_core::Value>().unwrap();
322-
eprintln!("value = {:#?}", value);
323316

324317
assert_eq!(
325318
value,

‎merde_msgpack/src/lib.rs

Lines changed: 56 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,14 @@
11
#![deny(missing_docs)]
22
#![doc = include_str!("../README.md")]
33

4-
use merde_core::{Deserialize, DeserializeOwned, Deserializer};
4+
use merde_core::{Deserialize, DeserializeOwned, Deserializer, Event};
55

66
/// A MessagePack deserializer, that implements [`merde_core::Deserializer`].
77
pub struct MsgpackDeserializer<'s> {
88
source: &'s [u8],
99
offset: usize,
1010
stack: Vec<StackItem>,
11+
starter: Option<Event<'s>>,
1112
}
1213

1314
#[derive(Debug)]
@@ -23,6 +24,7 @@ impl<'s> MsgpackDeserializer<'s> {
2324
source,
2425
offset: 0,
2526
stack: Vec::new(),
27+
starter: None,
2628
}
2729
}
2830
}
@@ -75,20 +77,24 @@ impl<'s> From<merde_core::MerdeError<'s>> for MsgpackError<'s> {
7577
impl<'s> merde_core::Deserializer<'s> for MsgpackDeserializer<'s> {
7678
type Error<'es> = MsgpackError<'es>;
7779

78-
fn next(&mut self) -> Result<merde_core::Event<'s>, Self::Error<'s>> {
80+
fn next(&mut self) -> Result<Event<'s>, Self::Error<'s>> {
81+
if let Some(ev) = self.starter.take() {
82+
return Ok(ev);
83+
}
84+
7985
if let Some(stack_item) = self.stack.last_mut() {
8086
match stack_item {
8187
StackItem::Array(count) => {
8288
if *count == 0 {
8389
self.stack.pop();
84-
return Ok(merde_core::Event::ArrayEnd);
90+
return Ok(Event::ArrayEnd);
8591
}
8692
*count -= 1;
8793
}
8894
StackItem::Map(count) => {
8995
if *count == 0 {
9096
self.stack.pop();
91-
return Ok(merde_core::Event::MapEnd);
97+
return Ok(Event::MapEnd);
9298
}
9399
*count -= 1;
94100
}
@@ -103,22 +109,22 @@ impl<'s> merde_core::Deserializer<'s> for MsgpackDeserializer<'s> {
103109
self.offset += 1;
104110

105111
match byte {
106-
0xc0 => Ok(merde_core::Event::Null),
107-
0xc2 => Ok(merde_core::Event::Bool(false)),
108-
0xc3 => Ok(merde_core::Event::Bool(true)),
112+
0xc0 => Ok(Event::Null),
113+
0xc2 => Ok(Event::Bool(false)),
114+
0xc3 => Ok(Event::Bool(true)),
109115
0xc4 => self.read_bytes_8(),
110116
0xc5 => self.read_bytes_16(),
111117
0xc6 => self.read_bytes_32(),
112-
0xcc => self.read_u8().map(|v| merde_core::Event::U64(v as u64)),
113-
0xcd => self.read_u16().map(|v| merde_core::Event::U64(v as u64)),
114-
0xce => self.read_u32().map(|v| merde_core::Event::U64(v as u64)),
115-
0xcf => self.read_u64().map(merde_core::Event::U64),
116-
0xd0 => self.read_i8().map(|v| merde_core::Event::I64(v as i64)),
117-
0xd1 => self.read_i16().map(|v| merde_core::Event::I64(v as i64)),
118-
0xd2 => self.read_i32().map(|v| merde_core::Event::I64(v as i64)),
119-
0xd3 => self.read_i64().map(merde_core::Event::I64),
120-
0xca => self.read_f32().map(|v| merde_core::Event::Float(v as f64)),
121-
0xcb => self.read_f64().map(merde_core::Event::Float),
118+
0xcc => self.read_u8().map(|v| Event::U64(v as u64)),
119+
0xcd => self.read_u16().map(|v| Event::U64(v as u64)),
120+
0xce => self.read_u32().map(|v| Event::U64(v as u64)),
121+
0xcf => self.read_u64().map(Event::U64),
122+
0xd0 => self.read_i8().map(|v| Event::I64(v as i64)),
123+
0xd1 => self.read_i16().map(|v| Event::I64(v as i64)),
124+
0xd2 => self.read_i32().map(|v| Event::I64(v as i64)),
125+
0xd3 => self.read_i64().map(Event::I64),
126+
0xca => self.read_f32().map(|v| Event::Float(v as f64)),
127+
0xcb => self.read_f64().map(Event::Float),
122128
0xa0..=0xbf => {
123129
let len = (byte & 0x1f) as usize;
124130
self.read_str(len)
@@ -129,7 +135,7 @@ impl<'s> merde_core::Deserializer<'s> for MsgpackDeserializer<'s> {
129135
0x90..=0x9f => {
130136
let len = (byte & 0x0f) as usize;
131137
self.stack.push(StackItem::Array(len));
132-
Ok(merde_core::Event::ArrayStart(merde_core::ArrayStart {
138+
Ok(Event::ArrayStart(merde_core::ArrayStart {
133139
size_hint: Some(len),
134140
}))
135141
}
@@ -138,29 +144,41 @@ impl<'s> merde_core::Deserializer<'s> for MsgpackDeserializer<'s> {
138144
0x80..=0x8f => {
139145
let len = (byte & 0x0f) as usize;
140146
self.stack.push(StackItem::Map(len * 2));
141-
Ok(merde_core::Event::MapStart)
147+
Ok(Event::MapStart)
142148
}
143149
0xde => {
144150
let len = self.read_u16()?;
145151
self.stack.push(StackItem::Map(len as usize * 2));
146-
Ok(merde_core::Event::MapStart)
152+
Ok(Event::MapStart)
147153
}
148154
0xdf => {
149155
let len = self.read_u32()?;
150156
self.stack.push(StackItem::Map(len as usize * 2));
151-
Ok(merde_core::Event::MapStart)
157+
Ok(Event::MapStart)
152158
}
153-
0x00..=0x7f => Ok(merde_core::Event::U64(byte as u64)),
154-
0xe0..=0xff => Ok(merde_core::Event::I64((byte as i8) as i64)),
159+
0x00..=0x7f => Ok(Event::U64(byte as u64)),
160+
0xe0..=0xff => Ok(Event::I64((byte as i8) as i64)),
155161
0xd4..=0xd8 | 0xc7..=0xc9 => Err(MsgpackError::UnsupportedExtType(byte)),
156162
_ => Err(MsgpackError::UnsupportedType(byte)),
157163
}
158164
}
159165

160166
async fn t_starting_with<T: Deserialize<'s>>(
161167
&mut self,
162-
_starter: Option<merde_core::Event<'s>>,
168+
starter: Option<Event<'s>>,
163169
) -> Result<T, Self::Error<'s>> {
170+
if let Some(starter) = starter {
171+
if self.starter.is_some() {
172+
unreachable!("setting starter when it's already set? shouldn't happen")
173+
}
174+
self.starter = Some(starter);
175+
}
176+
177+
// TODO: when too much stack space is used, stash this,
178+
// return Poll::Pending, to continue deserializing with
179+
// a shallower stack.
180+
181+
// that's the whole trick — for now, we just recurse as usual
164182
T::deserialize(self).await
165183
}
166184
}
@@ -240,67 +258,67 @@ impl<'s> MsgpackDeserializer<'s> {
240258
self.read_u64().map(f64::from_bits)
241259
}
242260

243-
fn read_str(&mut self, len: usize) -> Result<merde_core::Event<'s>, MsgpackError<'s>> {
261+
fn read_str(&mut self, len: usize) -> Result<Event<'s>, MsgpackError<'s>> {
244262
if self.offset + len > self.source.len() {
245263
return Err(MsgpackError::Eof);
246264
}
247265
let s = std::str::from_utf8(&self.source[self.offset..self.offset + len])
248266
.map_err(|_| MsgpackError::DecodeError("Invalid UTF-8 string"))?;
249267
self.offset += len;
250-
Ok(merde_core::Event::Str(s.into()))
268+
Ok(Event::Str(s.into()))
251269
}
252270

253-
fn read_str_8(&mut self) -> Result<merde_core::Event<'s>, MsgpackError<'s>> {
271+
fn read_str_8(&mut self) -> Result<Event<'s>, MsgpackError<'s>> {
254272
let len = self.read_u8()? as usize;
255273
self.read_str(len)
256274
}
257275

258-
fn read_str_16(&mut self) -> Result<merde_core::Event<'s>, MsgpackError<'s>> {
276+
fn read_str_16(&mut self) -> Result<Event<'s>, MsgpackError<'s>> {
259277
let len = self.read_u16()? as usize;
260278
self.read_str(len)
261279
}
262280

263-
fn read_str_32(&mut self) -> Result<merde_core::Event<'s>, MsgpackError<'s>> {
281+
fn read_str_32(&mut self) -> Result<Event<'s>, MsgpackError<'s>> {
264282
let len = self.read_u32()? as usize;
265283
self.read_str(len)
266284
}
267285

268-
fn read_bytes(&mut self, len: usize) -> Result<merde_core::Event<'s>, MsgpackError<'s>> {
286+
fn read_bytes(&mut self, len: usize) -> Result<Event<'s>, MsgpackError<'s>> {
269287
if self.offset + len > self.source.len() {
270288
return Err(MsgpackError::Eof);
271289
}
272290
let bytes = &self.source[self.offset..self.offset + len];
273291
self.offset += len;
274-
Ok(merde_core::Event::Bytes(bytes.into()))
292+
Ok(Event::Bytes(bytes.into()))
275293
}
276294

277-
fn read_bytes_8(&mut self) -> Result<merde_core::Event<'s>, MsgpackError<'s>> {
295+
fn read_bytes_8(&mut self) -> Result<Event<'s>, MsgpackError<'s>> {
278296
let len = self.read_u8()? as usize;
279297
self.read_bytes(len)
280298
}
281299

282-
fn read_bytes_16(&mut self) -> Result<merde_core::Event<'s>, MsgpackError<'s>> {
300+
fn read_bytes_16(&mut self) -> Result<Event<'s>, MsgpackError<'s>> {
283301
let len = self.read_u16()? as usize;
284302
self.read_bytes(len)
285303
}
286304

287-
fn read_bytes_32(&mut self) -> Result<merde_core::Event<'s>, MsgpackError<'s>> {
305+
fn read_bytes_32(&mut self) -> Result<Event<'s>, MsgpackError<'s>> {
288306
let len = self.read_u32()? as usize;
289307
self.read_bytes(len)
290308
}
291309

292-
fn read_array_16(&mut self) -> Result<merde_core::Event<'s>, MsgpackError<'s>> {
310+
fn read_array_16(&mut self) -> Result<Event<'s>, MsgpackError<'s>> {
293311
let len = self.read_u16()? as usize;
294312
self.stack.push(StackItem::Array(len));
295-
Ok(merde_core::Event::ArrayStart(merde_core::ArrayStart {
313+
Ok(Event::ArrayStart(merde_core::ArrayStart {
296314
size_hint: Some(len),
297315
}))
298316
}
299317

300-
fn read_array_32(&mut self) -> Result<merde_core::Event<'s>, MsgpackError<'s>> {
318+
fn read_array_32(&mut self) -> Result<Event<'s>, MsgpackError<'s>> {
301319
let len = self.read_u32()? as usize;
302320
self.stack.push(StackItem::Array(len));
303-
Ok(merde_core::Event::ArrayStart(merde_core::ArrayStart {
321+
Ok(Event::ArrayStart(merde_core::ArrayStart {
304322
size_hint: Some(len),
305323
}))
306324
}

0 commit comments

Comments
 (0)