facet_msgpack/
parser.rs

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

facet_msgpack/
parser.rs
