facet_msgpack/
parser.rs

1//! MsgPack parser implementing FormatParser.
2//!
3//! This implements full FormatParser support for MsgPack deserialization.
4
5extern crate alloc;
6
7use alloc::{borrow::Cow, format, vec::Vec};
8
9use crate::error::codes;
10use facet_format::{
11    ContainerKind, DeserializeErrorKind, FieldKey, FieldLocationHint, FormatParser, ParseError,
12    ParseEvent, ParseEventKind, SavePoint, ScalarValue,
13};
14use facet_reflect::Span;
15
16// MsgPack format constants
17const MSGPACK_NIL: u8 = 0xc0;
18const MSGPACK_FALSE: u8 = 0xc2;
19const MSGPACK_TRUE: u8 = 0xc3;
20const MSGPACK_BIN8: u8 = 0xc4;
21const MSGPACK_BIN16: u8 = 0xc5;
22const MSGPACK_BIN32: u8 = 0xc6;
23const MSGPACK_FLOAT32: u8 = 0xca;
24const MSGPACK_FLOAT64: u8 = 0xcb;
25const MSGPACK_UINT8: u8 = 0xcc;
26const MSGPACK_UINT16: u8 = 0xcd;
27const MSGPACK_UINT32: u8 = 0xce;
28const MSGPACK_UINT64: u8 = 0xcf;
29const MSGPACK_INT8: u8 = 0xd0;
30const MSGPACK_INT16: u8 = 0xd1;
31const MSGPACK_INT32: u8 = 0xd2;
32const MSGPACK_INT64: u8 = 0xd3;
33const MSGPACK_STR8: u8 = 0xd9;
34const MSGPACK_STR16: u8 = 0xda;
35const MSGPACK_STR32: u8 = 0xdb;
36const MSGPACK_ARRAY16: u8 = 0xdc;
37const MSGPACK_ARRAY32: u8 = 0xdd;
38const MSGPACK_MAP16: u8 = 0xde;
39const MSGPACK_MAP32: u8 = 0xdf;
40
41const MSGPACK_POSFIXINT_MAX: u8 = 0x7f;
42const MSGPACK_FIXMAP_MIN: u8 = 0x80;
43const MSGPACK_FIXMAP_MAX: u8 = 0x8f;
44const MSGPACK_FIXARRAY_MIN: u8 = 0x90;
45const MSGPACK_FIXARRAY_MAX: u8 = 0x9f;
46const MSGPACK_FIXSTR_MIN: u8 = 0xa0;
47const MSGPACK_FIXSTR_MAX: u8 = 0xbf;
48const MSGPACK_NEGFIXINT_MIN: u8 = 0xe0;
49
50/// MsgPack parser for deserialization.
51pub struct MsgPackParser<'de> {
52    input: &'de [u8],
53    pos: usize,
54    /// Stack tracking nested containers and their remaining items
55    stack: Vec<ContextState>,
56    /// Cached event for peek_event
57    event_peek: Option<ParseEvent<'de>>,
58}
59
60#[derive(Debug, Clone, Copy)]
61enum ContextState {
62    /// Inside a map, waiting for a key (remaining pairs)
63    MapKey { remaining: usize },
64    /// Inside a map, waiting for a value (remaining pairs after this one)
65    MapValue { remaining: usize },
66    /// Inside an array (remaining items)
67    Array { remaining: usize },
68}
69
70/// Create a ParseError from an error code and position.
71fn error_from_code(code: i32, pos: usize) -> ParseError {
72    let message = match code {
73        codes::UNEXPECTED_EOF => "unexpected end of input",
74        codes::EXPECTED_BOOL => "expected bool (0xC2 or 0xC3)",
75        codes::EXPECTED_ARRAY => "expected array tag (fixarray/array16/array32)",
76        codes::EXPECTED_BIN => "expected bin tag (bin8/bin16/bin32)",
77        codes::EXPECTED_INT => "expected integer tag",
78        codes::INT_OVERFLOW => "integer value overflows target type",
79        codes::COUNT_OVERFLOW => "count too large for platform",
80        codes::SEQ_UNDERFLOW => "sequence underflow (internal error)",
81        codes::UNSUPPORTED => "unsupported operation",
82        _ => "unknown error",
83    };
84    ParseError::new(
85        Span::new(pos, 1),
86        DeserializeErrorKind::InvalidValue {
87            message: message.into(),
88        },
89    )
90}
91
92impl<'de> MsgPackParser<'de> {
93    /// Create a new MsgPack parser from input bytes.
94    pub const fn new(input: &'de [u8]) -> Self {
95        Self {
96            input,
97            pos: 0,
98            stack: Vec::new(),
99            event_peek: None,
100        }
101    }
102
103    /// Peek at the next byte without consuming it.
104    fn peek_byte(&self) -> Result<u8, ParseError> {
105        self.input
106            .get(self.pos)
107            .copied()
108            .ok_or_else(|| error_from_code(codes::UNEXPECTED_EOF, self.pos))
109    }
110
111    /// Read a single byte.
112    fn read_byte(&mut self) -> Result<u8, ParseError> {
113        let byte = self.peek_byte()?;
114        self.pos += 1;
115        Ok(byte)
116    }
117
118    /// Read N bytes as a slice.
119    fn read_bytes(&mut self, n: usize) -> Result<&'de [u8], ParseError> {
120        if self.pos + n > self.input.len() {
121            return Err(error_from_code(codes::UNEXPECTED_EOF, self.pos));
122        }
123        let slice = &self.input[self.pos..self.pos + n];
124        self.pos += n;
125        Ok(slice)
126    }
127
128    /// Read a u16 in big-endian.
129    fn read_u16(&mut self) -> Result<u16, ParseError> {
130        let bytes = self.read_bytes(2)?;
131        Ok(u16::from_be_bytes([bytes[0], bytes[1]]))
132    }
133
134    /// Read a u32 in big-endian.
135    fn read_u32(&mut self) -> Result<u32, ParseError> {
136        let bytes = self.read_bytes(4)?;
137        Ok(u32::from_be_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]))
138    }
139
140    /// Read a u64 in big-endian.
141    fn read_u64(&mut self) -> Result<u64, ParseError> {
142        let bytes = self.read_bytes(8)?;
143        Ok(u64::from_be_bytes([
144            bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
145        ]))
146    }
147
148    /// Read an i8.
149    fn read_i8(&mut self) -> Result<i8, ParseError> {
150        Ok(self.read_byte()? as i8)
151    }
152
153    /// Read an i16 in big-endian.
154    fn read_i16(&mut self) -> Result<i16, ParseError> {
155        let bytes = self.read_bytes(2)?;
156        Ok(i16::from_be_bytes([bytes[0], bytes[1]]))
157    }
158
159    /// Read an i32 in big-endian.
160    fn read_i32(&mut self) -> Result<i32, ParseError> {
161        let bytes = self.read_bytes(4)?;
162        Ok(i32::from_be_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]))
163    }
164
165    /// Read an i64 in big-endian.
166    fn read_i64(&mut self) -> Result<i64, ParseError> {
167        let bytes = self.read_bytes(8)?;
168        Ok(i64::from_be_bytes([
169            bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
170        ]))
171    }
172
173    /// Read an f32 in big-endian.
174    fn read_f32(&mut self) -> Result<f32, ParseError> {
175        let bytes = self.read_bytes(4)?;
176        Ok(f32::from_be_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]))
177    }
178
179    /// Read an f64 in big-endian.
180    fn read_f64(&mut self) -> Result<f64, ParseError> {
181        let bytes = self.read_bytes(8)?;
182        Ok(f64::from_be_bytes([
183            bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
184        ]))
185    }
186
187    /// Read a string length based on prefix.
188    fn read_str_len(&mut self, prefix: u8) -> Result<usize, ParseError> {
189        match prefix {
190            MSGPACK_FIXSTR_MIN..=MSGPACK_FIXSTR_MAX => Ok((prefix & 0x1f) as usize),
191            MSGPACK_STR8 => Ok(self.read_byte()? as usize),
192            MSGPACK_STR16 => Ok(self.read_u16()? as usize),
193            MSGPACK_STR32 => Ok(self.read_u32()? as usize),
194            _ => Err(ParseError::new(
195                Span::new(self.pos, 1),
196                DeserializeErrorKind::InvalidValue {
197                    message: format!("expected string, got 0x{:02x}", prefix).into(),
198                },
199            )),
200        }
201    }
202
203    /// Read a string value.
204    fn read_string(&mut self) -> Result<Cow<'de, str>, ParseError> {
205        let prefix = self.read_byte()?;
206        let len = self.read_str_len(prefix)?;
207        let bytes = self.read_bytes(len)?;
208        core::str::from_utf8(bytes).map(Cow::Borrowed).map_err(|_| {
209            let mut context = [0u8; 16];
210            let context_len = len.min(16);
211            context[..context_len].copy_from_slice(&bytes[..context_len]);
212            ParseError::new(
213                Span::new(self.pos - len, len),
214                DeserializeErrorKind::InvalidUtf8 {
215                    context,
216                    context_len: context_len as u8,
217                },
218            )
219        })
220    }
221
222    /// Read an array length.
223    fn read_array_len(&mut self, prefix: u8) -> Result<usize, ParseError> {
224        match prefix {
225            MSGPACK_FIXARRAY_MIN..=MSGPACK_FIXARRAY_MAX => Ok((prefix & 0x0f) as usize),
226            MSGPACK_ARRAY16 => Ok(self.read_u16()? as usize),
227            MSGPACK_ARRAY32 => Ok(self.read_u32()? as usize),
228            _ => Err(error_from_code(codes::EXPECTED_ARRAY, self.pos)),
229        }
230    }
231
232    /// Read a map length.
233    fn read_map_len(&mut self, prefix: u8) -> Result<usize, ParseError> {
234        match prefix {
235            MSGPACK_FIXMAP_MIN..=MSGPACK_FIXMAP_MAX => Ok((prefix & 0x0f) as usize),
236            MSGPACK_MAP16 => Ok(self.read_u16()? as usize),
237            MSGPACK_MAP32 => Ok(self.read_u32()? as usize),
238            _ => Err(ParseError::new(
239                Span::new(self.pos, 1),
240                DeserializeErrorKind::InvalidValue {
241                    message: format!("expected map, got 0x{:02x}", prefix).into(),
242                },
243            )),
244        }
245    }
246
247    /// Finish processing a value and update parent container state.
248    fn finish_value(&mut self) {
249        if let Some(context) = self.stack.last_mut() {
250            match context {
251                ContextState::MapValue { remaining } => {
252                    // Finished a value, go back to expecting a key (or end)
253                    *context = ContextState::MapKey {
254                        remaining: *remaining,
255                    };
256                }
257                ContextState::MapKey { remaining } => {
258                    // This shouldn't happen (keys transition to values), but handle it
259                    if *remaining > 0 {
260                        *remaining -= 1;
261                    }
262                }
263                ContextState::Array { remaining } => {
264                    if *remaining > 0 {
265                        *remaining -= 1;
266                    }
267                }
268            }
269        }
270    }
271
272    /// Produce the next parse event.
273    fn produce_event(&mut self) -> Result<Option<ParseEvent<'de>>, ParseError> {
274        // Check if we need to emit container end events
275        // This can happen when a container has been fully consumed
276        if let Some(context) = self.stack.last() {
277            match context {
278                ContextState::MapKey { remaining: 0 } => {
279                    self.stack.pop();
280                    self.finish_value();
281                    return Ok(Some(self.event(ParseEventKind::StructEnd)));
282                }
283                ContextState::Array { remaining: 0 } => {
284                    self.stack.pop();
285                    self.finish_value();
286                    return Ok(Some(self.event(ParseEventKind::SequenceEnd)));
287                }
288                _ => {}
289            }
290        }
291
292        // Check if we're at EOF
293        if self.pos >= self.input.len() {
294            return Ok(None);
295        }
296
297        // Determine what to do based on context
298        // Check if we're expecting a map key and get the remaining count
299        let expecting_key_remaining = match self.stack.last() {
300            Some(ContextState::MapKey { remaining }) => Some(*remaining),
301            _ => None,
302        };
303
304        if let Some(remaining) = expecting_key_remaining {
305            // We expect a key (string)
306            let key = self.read_string()?;
307
308            // Update the stack: decrement remaining and transition to expecting value
309            let new_remaining = remaining - 1;
310            if let Some(state) = self.stack.last_mut() {
311                *state = ContextState::MapValue {
312                    remaining: new_remaining,
313                };
314            }
315
316            return Ok(Some(self.event(ParseEventKind::FieldKey(FieldKey::new(
317                key,
318                FieldLocationHint::KeyValue,
319            )))));
320        }
321
322        // Parse the next value
323        let prefix = self.read_byte()?;
324
325        match prefix {
326            // Nil
327            MSGPACK_NIL => {
328                self.finish_value();
329                Ok(Some(self.event(ParseEventKind::Scalar(ScalarValue::Null))))
330            }
331
332            // Boolean
333            MSGPACK_FALSE => {
334                self.finish_value();
335                Ok(Some(
336                    self.event(ParseEventKind::Scalar(ScalarValue::Bool(false))),
337                ))
338            }
339            MSGPACK_TRUE => {
340                self.finish_value();
341                Ok(Some(
342                    self.event(ParseEventKind::Scalar(ScalarValue::Bool(true))),
343                ))
344            }
345
346            // Positive fixint (0x00-0x7f)
347            0x00..=MSGPACK_POSFIXINT_MAX => {
348                self.finish_value();
349                Ok(Some(self.event(ParseEventKind::Scalar(ScalarValue::U64(
350                    prefix as u64,
351                )))))
352            }
353
354            // Negative fixint (0xe0-0xff)
355            MSGPACK_NEGFIXINT_MIN..=0xff => {
356                self.finish_value();
357                Ok(Some(self.event(ParseEventKind::Scalar(ScalarValue::I64(
358                    prefix as i8 as i64,
359                )))))
360            }
361
362            // Unsigned integers
363            MSGPACK_UINT8 => {
364                let v = self.read_byte()? as u64;
365                self.finish_value();
366                Ok(Some(
367                    self.event(ParseEventKind::Scalar(ScalarValue::U64(v))),
368                ))
369            }
370            MSGPACK_UINT16 => {
371                let v = self.read_u16()? as u64;
372                self.finish_value();
373                Ok(Some(
374                    self.event(ParseEventKind::Scalar(ScalarValue::U64(v))),
375                ))
376            }
377            MSGPACK_UINT32 => {
378                let v = self.read_u32()? as u64;
379                self.finish_value();
380                Ok(Some(
381                    self.event(ParseEventKind::Scalar(ScalarValue::U64(v))),
382                ))
383            }
384            MSGPACK_UINT64 => {
385                let v = self.read_u64()?;
386                self.finish_value();
387                Ok(Some(
388                    self.event(ParseEventKind::Scalar(ScalarValue::U64(v))),
389                ))
390            }
391
392            // Signed integers
393            MSGPACK_INT8 => {
394                let v = self.read_i8()? as i64;
395                self.finish_value();
396                Ok(Some(
397                    self.event(ParseEventKind::Scalar(ScalarValue::I64(v))),
398                ))
399            }
400            MSGPACK_INT16 => {
401                let v = self.read_i16()? as i64;
402                self.finish_value();
403                Ok(Some(
404                    self.event(ParseEventKind::Scalar(ScalarValue::I64(v))),
405                ))
406            }
407            MSGPACK_INT32 => {
408                let v = self.read_i32()? as i64;
409                self.finish_value();
410                Ok(Some(
411                    self.event(ParseEventKind::Scalar(ScalarValue::I64(v))),
412                ))
413            }
414            MSGPACK_INT64 => {
415                let v = self.read_i64()?;
416                self.finish_value();
417                Ok(Some(
418                    self.event(ParseEventKind::Scalar(ScalarValue::I64(v))),
419                ))
420            }
421
422            // Floats
423            MSGPACK_FLOAT32 => {
424                let v = self.read_f32()? as f64;
425                self.finish_value();
426                Ok(Some(
427                    self.event(ParseEventKind::Scalar(ScalarValue::F64(v))),
428                ))
429            }
430            MSGPACK_FLOAT64 => {
431                let v = self.read_f64()?;
432                self.finish_value();
433                Ok(Some(
434                    self.event(ParseEventKind::Scalar(ScalarValue::F64(v))),
435                ))
436            }
437
438            // Strings (fixstr, str8, str16, str32)
439            MSGPACK_FIXSTR_MIN..=MSGPACK_FIXSTR_MAX
440            | MSGPACK_STR8
441            | MSGPACK_STR16
442            | MSGPACK_STR32 => {
443                let len = self.read_str_len(prefix)?;
444                let bytes = self.read_bytes(len)?;
445                let s = core::str::from_utf8(bytes)
446                    .map(Cow::Borrowed)
447                    .map_err(|_| {
448                        let mut context = [0u8; 16];
449                        let context_len = len.min(16);
450                        context[..context_len].copy_from_slice(&bytes[..context_len]);
451                        ParseError::new(
452                            Span::new(self.pos - len, len),
453                            DeserializeErrorKind::InvalidUtf8 {
454                                context,
455                                context_len: context_len as u8,
456                            },
457                        )
458                    })?;
459                self.finish_value();
460                Ok(Some(
461                    self.event(ParseEventKind::Scalar(ScalarValue::Str(s))),
462                ))
463            }
464
465            // Binary data
466            MSGPACK_BIN8 => {
467                let len = self.read_byte()? as usize;
468                let bytes = self.read_bytes(len)?;
469                self.finish_value();
470                Ok(Some(self.event(ParseEventKind::Scalar(
471                    ScalarValue::Bytes(Cow::Borrowed(bytes)),
472                ))))
473            }
474            MSGPACK_BIN16 => {
475                let len = self.read_u16()? as usize;
476                let bytes = self.read_bytes(len)?;
477                self.finish_value();
478                Ok(Some(self.event(ParseEventKind::Scalar(
479                    ScalarValue::Bytes(Cow::Borrowed(bytes)),
480                ))))
481            }
482            MSGPACK_BIN32 => {
483                let len = self.read_u32()? as usize;
484                let bytes = self.read_bytes(len)?;
485                self.finish_value();
486                Ok(Some(self.event(ParseEventKind::Scalar(
487                    ScalarValue::Bytes(Cow::Borrowed(bytes)),
488                ))))
489            }
490
491            // Arrays
492            MSGPACK_FIXARRAY_MIN..=MSGPACK_FIXARRAY_MAX | MSGPACK_ARRAY16 | MSGPACK_ARRAY32 => {
493                let len = self.read_array_len(prefix)?;
494                self.stack.push(ContextState::Array { remaining: len });
495                Ok(Some(self.event(ParseEventKind::SequenceStart(
496                    ContainerKind::Array,
497                ))))
498            }
499
500            // Maps
501            MSGPACK_FIXMAP_MIN..=MSGPACK_FIXMAP_MAX | MSGPACK_MAP16 | MSGPACK_MAP32 => {
502                let len = self.read_map_len(prefix)?;
503                self.stack.push(ContextState::MapKey { remaining: len });
504                Ok(Some(
505                    self.event(ParseEventKind::StructStart(ContainerKind::Object)),
506                ))
507            }
508
509            // Unsupported types (ext, etc.)
510            _ => Err(ParseError::new(
511                Span::new(self.pos - 1, 1),
512                DeserializeErrorKind::InvalidValue {
513                    message: format!("unsupported MsgPack type: 0x{:02x}", prefix).into(),
514                },
515            )),
516        }
517    }
518
519    /// Skip a complete value (used for skip_value and probing).
520    fn skip_value_internal(&mut self) -> Result<(), ParseError> {
521        let prefix = self.read_byte()?;
522
523        match prefix {
524            // Nil, booleans - already consumed
525            MSGPACK_NIL | MSGPACK_FALSE | MSGPACK_TRUE => Ok(()),
526
527            // Positive fixint - already consumed
528            0x00..=MSGPACK_POSFIXINT_MAX => Ok(()),
529
530            // Negative fixint - already consumed
531            MSGPACK_NEGFIXINT_MIN..=0xff => Ok(()),
532
533            // Unsigned integers
534            MSGPACK_UINT8 => {
535                self.pos += 1;
536                Ok(())
537            }
538            MSGPACK_UINT16 => {
539                self.pos += 2;
540                Ok(())
541            }
542            MSGPACK_UINT32 => {
543                self.pos += 4;
544                Ok(())
545            }
546            MSGPACK_UINT64 => {
547                self.pos += 8;
548                Ok(())
549            }
550
551            // Signed integers
552            MSGPACK_INT8 => {
553                self.pos += 1;
554                Ok(())
555            }
556            MSGPACK_INT16 => {
557                self.pos += 2;
558                Ok(())
559            }
560            MSGPACK_INT32 => {
561                self.pos += 4;
562                Ok(())
563            }
564            MSGPACK_INT64 => {
565                self.pos += 8;
566                Ok(())
567            }
568
569            // Floats
570            MSGPACK_FLOAT32 => {
571                self.pos += 4;
572                Ok(())
573            }
574            MSGPACK_FLOAT64 => {
575                self.pos += 8;
576                Ok(())
577            }
578
579            // Strings
580            MSGPACK_FIXSTR_MIN..=MSGPACK_FIXSTR_MAX => {
581                let len = (prefix & 0x1f) as usize;
582                self.pos += len;
583                Ok(())
584            }
585            MSGPACK_STR8 => {
586                let len = self.read_byte()? as usize;
587                self.pos += len;
588                Ok(())
589            }
590            MSGPACK_STR16 => {
591                let len = self.read_u16()? as usize;
592                self.pos += len;
593                Ok(())
594            }
595            MSGPACK_STR32 => {
596                let len = self.read_u32()? as usize;
597                self.pos += len;
598                Ok(())
599            }
600
601            // Binary
602            MSGPACK_BIN8 => {
603                let len = self.read_byte()? as usize;
604                self.pos += len;
605                Ok(())
606            }
607            MSGPACK_BIN16 => {
608                let len = self.read_u16()? as usize;
609                self.pos += len;
610                Ok(())
611            }
612            MSGPACK_BIN32 => {
613                let len = self.read_u32()? as usize;
614                self.pos += len;
615                Ok(())
616            }
617
618            // Arrays - skip all elements
619            MSGPACK_FIXARRAY_MIN..=MSGPACK_FIXARRAY_MAX => {
620                let len = (prefix & 0x0f) as usize;
621                for _ in 0..len {
622                    self.skip_value_internal()?;
623                }
624                Ok(())
625            }
626            MSGPACK_ARRAY16 => {
627                let len = self.read_u16()? as usize;
628                for _ in 0..len {
629                    self.skip_value_internal()?;
630                }
631                Ok(())
632            }
633            MSGPACK_ARRAY32 => {
634                let len = self.read_u32()? as usize;
635                for _ in 0..len {
636                    self.skip_value_internal()?;
637                }
638                Ok(())
639            }
640
641            // Maps - skip all key-value pairs
642            MSGPACK_FIXMAP_MIN..=MSGPACK_FIXMAP_MAX => {
643                let len = (prefix & 0x0f) as usize;
644                for _ in 0..len {
645                    self.skip_value_internal()?; // key
646                    self.skip_value_internal()?; // value
647                }
648                Ok(())
649            }
650            MSGPACK_MAP16 => {
651                let len = self.read_u16()? as usize;
652                for _ in 0..len {
653                    self.skip_value_internal()?; // key
654                    self.skip_value_internal()?; // value
655                }
656                Ok(())
657            }
658            MSGPACK_MAP32 => {
659                let len = self.read_u32()? as usize;
660                for _ in 0..len {
661                    self.skip_value_internal()?; // key
662                    self.skip_value_internal()?; // value
663                }
664                Ok(())
665            }
666
667            // Extension types - skip
668            0xc7 => {
669                // ext8
670                let len = self.read_byte()? as usize;
671                self.pos += 1 + len; // type byte + data
672                Ok(())
673            }
674            0xc8 => {
675                // ext16
676                let len = self.read_u16()? as usize;
677                self.pos += 1 + len;
678                Ok(())
679            }
680            0xc9 => {
681                // ext32
682                let len = self.read_u32()? as usize;
683                self.pos += 1 + len;
684                Ok(())
685            }
686            0xd4 => {
687                // fixext1
688                self.pos += 2;
689                Ok(())
690            }
691            0xd5 => {
692                // fixext2
693                self.pos += 3;
694                Ok(())
695            }
696            0xd6 => {
697                // fixext4
698                self.pos += 5;
699                Ok(())
700            }
701            0xd7 => {
702                // fixext8
703                self.pos += 9;
704                Ok(())
705            }
706            0xd8 => {
707                // fixext16
708                self.pos += 17;
709                Ok(())
710            }
711
712            _ => Err(ParseError::new(
713                Span::new(self.pos - 1, 1),
714                DeserializeErrorKind::InvalidValue {
715                    message: format!("unsupported MsgPack type: 0x{:02x}", prefix).into(),
716                },
717            )),
718        }
719    }
720}
721
722impl<'de> MsgPackParser<'de> {
723    /// Create an event with the current span.
724    #[inline]
725    fn event(&self, kind: ParseEventKind<'de>) -> ParseEvent<'de> {
726        ParseEvent::new(kind, Span::new(self.pos, 1))
727    }
728}
729
730impl<'de> FormatParser<'de> for MsgPackParser<'de> {
731    fn next_event(&mut self) -> Result<Option<ParseEvent<'de>>, ParseError> {
732        if let Some(event) = self.event_peek.take() {
733            return Ok(Some(event));
734        }
735        self.produce_event()
736    }
737
738    fn peek_event(&mut self) -> Result<Option<ParseEvent<'de>>, ParseError> {
739        if let Some(event) = self.event_peek.clone() {
740            return Ok(Some(event));
741        }
742        let event = self.produce_event()?;
743        if let Some(ref e) = event {
744            self.event_peek = Some(e.clone());
745        }
746        Ok(event)
747    }
748
749    fn skip_value(&mut self) -> Result<(), ParseError> {
750        debug_assert!(
751            self.event_peek.is_none(),
752            "skip_value called while an event is buffered"
753        );
754        self.skip_value_internal()?;
755        self.finish_value();
756        Ok(())
757    }
758
759    fn save(&mut self) -> SavePoint {
760        // MsgPack is self-describing but save/restore would need full state cloning
761        // For now, unimplemented - can be added if needed for solver support
762        unimplemented!("save/restore not yet implemented for MsgPack")
763    }
764
765    fn restore(&mut self, _save_point: SavePoint) {
766        unimplemented!("save/restore not yet implemented for MsgPack")
767    }
768}
facet_msgpack/parser.rs

facet_msgpack/
parser.rs
