1use std::io;
4use std::marker::PhantomData;
5use std::result;
6use std::str::FromStr;
7use std::{i32, u64};
8
9use serde::de::{self, Expected, Unexpected};
10
11use super::error::{Error, ErrorCode, Result};
12
13use read::{self, Reference};
14
15pub use read::{IoRead, Read, SliceRead, StrRead};
16
17use number::Number;
18#[cfg(feature = "arbitrary_precision")]
19use number::NumberDeserializer;
20
21pub struct Deserializer<R> {
25 read: R,
26 scratch: Vec<u8>,
27 remaining_depth: u8,
28 #[cfg(feature = "unbounded_depth")]
29 disable_recursion_limit: bool,
30}
31
32impl<'de, R> Deserializer<R>
33where
34 R: read::Read<'de>,
35{
36 pub fn new(read: R) -> Self {
45 #[cfg(not(feature = "unbounded_depth"))]
46 {
47 Deserializer {
48 read: read,
49 scratch: Vec::new(),
50 remaining_depth: 128,
51 }
52 }
53
54 #[cfg(feature = "unbounded_depth")]
55 {
56 Deserializer {
57 read: read,
58 scratch: Vec::new(),
59 remaining_depth: 128,
60 disable_recursion_limit: false,
61 }
62 }
63 }
64}
65
66impl<R> Deserializer<read::IoRead<R>>
67where
68 R: io::Read,
69{
70 pub fn from_reader(reader: R) -> Self {
76 Deserializer::new(read::IoRead::new(reader))
77 }
78}
79
80impl<'a> Deserializer<read::SliceRead<'a>> {
81 pub fn from_slice(bytes: &'a [u8]) -> Self {
83 Deserializer::new(read::SliceRead::new(bytes))
84 }
85}
86
87impl<'a> Deserializer<read::StrRead<'a>> {
88 pub fn from_str(s: &'a str) -> Self {
90 Deserializer::new(read::StrRead::new(s))
91 }
92}
93
94macro_rules! overflow {
95 ($a:ident * 10 + $b:ident, $c:expr) => {
96 $a >= $c / 10 && ($a > $c / 10 || $b > $c % 10)
97 };
98}
99
100#[doc(hidden)]
102pub enum ParserNumber {
103 F64(f64),
104 U64(u64),
105 I64(i64),
106 #[cfg(feature = "arbitrary_precision")]
107 String(String),
108}
109
110impl ParserNumber {
111 fn visit<'de, V>(self, visitor: V) -> Result<V::Value>
112 where
113 V: de::Visitor<'de>,
114 {
115 match self {
116 ParserNumber::F64(x) => visitor.visit_f64(x),
117 ParserNumber::U64(x) => visitor.visit_u64(x),
118 ParserNumber::I64(x) => visitor.visit_i64(x),
119 #[cfg(feature = "arbitrary_precision")]
120 ParserNumber::String(x) => visitor.visit_map(NumberDeserializer { number: x.into() }),
121 }
122 }
123
124 fn invalid_type(self, exp: &Expected) -> Error {
125 match self {
126 ParserNumber::F64(x) => de::Error::invalid_type(Unexpected::Float(x), exp),
127 ParserNumber::U64(x) => de::Error::invalid_type(Unexpected::Unsigned(x), exp),
128 ParserNumber::I64(x) => de::Error::invalid_type(Unexpected::Signed(x), exp),
129 #[cfg(feature = "arbitrary_precision")]
130 ParserNumber::String(_) => de::Error::invalid_type(Unexpected::Other("number"), exp),
131 }
132 }
133}
134
135impl<'de, R: Read<'de>> Deserializer<R> {
136 pub fn end(&mut self) -> Result<()> {
140 match try!(self.parse_whitespace()) {
141 Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)),
142 None => Ok(()),
143 }
144 }
145
146 pub fn into_iter<T>(self) -> StreamDeserializer<'de, R, T>
148 where
149 T: de::Deserialize<'de>,
150 {
151 let offset = self.read.byte_offset();
154 StreamDeserializer {
155 de: self,
156 offset: offset,
157 output: PhantomData,
158 lifetime: PhantomData,
159 }
160 }
161
162 #[cfg(feature = "unbounded_depth")]
206 pub fn disable_recursion_limit(&mut self) {
207 self.disable_recursion_limit = true;
208 }
209
210 fn peek(&mut self) -> Result<Option<u8>> {
211 self.read.peek()
212 }
213
214 fn peek_or_null(&mut self) -> Result<u8> {
215 Ok(try!(self.peek()).unwrap_or(b'\x00'))
216 }
217
218 fn eat_char(&mut self) {
219 self.read.discard();
220 }
221
222 fn next_char(&mut self) -> Result<Option<u8>> {
223 self.read.next()
224 }
225
226 fn next_char_or_null(&mut self) -> Result<u8> {
227 Ok(try!(self.next_char()).unwrap_or(b'\x00'))
228 }
229
230 #[cold]
232 fn error(&self, reason: ErrorCode) -> Error {
233 let position = self.read.position();
234 Error::syntax(reason, position.line, position.column)
235 }
236
237 #[cold]
239 fn peek_error(&self, reason: ErrorCode) -> Error {
240 let position = self.read.peek_position();
241 Error::syntax(reason, position.line, position.column)
242 }
243
244 fn parse_whitespace(&mut self) -> Result<Option<u8>> {
247 loop {
248 match try!(self.peek()) {
249 Some(b' ') | Some(b'\n') | Some(b'\t') | Some(b'\r') => {
250 self.eat_char();
251 }
252 other => {
253 return Ok(other);
254 }
255 }
256 }
257 }
258
259 #[cold]
260 fn peek_invalid_type(&mut self, exp: &Expected) -> Error {
261 let err = match self.peek_or_null().unwrap_or(b'\x00') {
262 b'n' => {
263 self.eat_char();
264 if let Err(err) = self.parse_ident(b"ull") {
265 return err;
266 }
267 de::Error::invalid_type(Unexpected::Unit, exp)
268 }
269 b't' => {
270 self.eat_char();
271 if let Err(err) = self.parse_ident(b"rue") {
272 return err;
273 }
274 de::Error::invalid_type(Unexpected::Bool(true), exp)
275 }
276 b'f' => {
277 self.eat_char();
278 if let Err(err) = self.parse_ident(b"alse") {
279 return err;
280 }
281 de::Error::invalid_type(Unexpected::Bool(false), exp)
282 }
283 b'-' => {
284 self.eat_char();
285 match self.parse_any_number(false) {
286 Ok(n) => n.invalid_type(exp),
287 Err(err) => return err,
288 }
289 }
290 b'0'...b'9' => match self.parse_any_number(true) {
291 Ok(n) => n.invalid_type(exp),
292 Err(err) => return err,
293 },
294 b'"' => {
295 self.eat_char();
296 self.scratch.clear();
297 match self.read.parse_str(&mut self.scratch) {
298 Ok(s) => de::Error::invalid_type(Unexpected::Str(&s), exp),
299 Err(err) => return err,
300 }
301 }
302 b'[' => de::Error::invalid_type(Unexpected::Seq, exp),
303 b'{' => de::Error::invalid_type(Unexpected::Map, exp),
304 _ => self.peek_error(ErrorCode::ExpectedSomeValue),
305 };
306
307 self.fix_position(err)
308 }
309
310 fn deserialize_prim_number<V>(&mut self, visitor: V) -> Result<V::Value>
311 where
312 V: de::Visitor<'de>,
313 {
314 let peek = match try!(self.parse_whitespace()) {
315 Some(b) => b,
316 None => {
317 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
318 }
319 };
320
321 let value = match peek {
322 b'-' => {
323 self.eat_char();
324 try!(self.parse_integer(false)).visit(visitor)
325 }
326 b'0'...b'9' => try!(self.parse_integer(true)).visit(visitor),
327 _ => Err(self.peek_invalid_type(&visitor)),
328 };
329
330 match value {
331 Ok(value) => Ok(value),
332 Err(err) => Err(self.fix_position(err)),
333 }
334 }
335
336 serde_if_integer128! {
337 fn scan_integer128(&mut self, buf: &mut String) -> Result<()> {
338 match try!(self.next_char_or_null()) {
339 b'0' => {
340 buf.push('0');
341 match try!(self.peek_or_null()) {
343 b'0'...b'9' => {
344 Err(self.peek_error(ErrorCode::InvalidNumber))
345 }
346 _ => Ok(()),
347 }
348 }
349 c @ b'1'...b'9' => {
350 buf.push(c as char);
351 while let c @ b'0'...b'9' = try!(self.peek_or_null()) {
352 self.eat_char();
353 buf.push(c as char);
354 }
355 Ok(())
356 }
357 _ => {
358 Err(self.error(ErrorCode::InvalidNumber))
359 }
360 }
361 }
362 }
363
364 #[cold]
365 fn fix_position(&self, err: Error) -> Error {
366 err.fix_position(move |code| self.error(code))
367 }
368
369 fn parse_ident(&mut self, ident: &[u8]) -> Result<()> {
370 for expected in ident {
371 match try!(self.next_char()) {
372 None => {
373 return Err(self.error(ErrorCode::EofWhileParsingValue));
374 }
375 Some(next) => {
376 if next != *expected {
377 return Err(self.error(ErrorCode::ExpectedSomeIdent));
378 }
379 }
380 }
381 }
382
383 Ok(())
384 }
385
386 fn parse_integer(&mut self, positive: bool) -> Result<ParserNumber> {
387 let next = match try!(self.next_char()) {
388 Some(b) => b,
389 None => {
390 return Err(self.error(ErrorCode::EofWhileParsingValue));
391 }
392 };
393
394 match next {
395 b'0' => {
396 match try!(self.peek_or_null()) {
398 b'0'...b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)),
399 _ => self.parse_number(positive, 0),
400 }
401 }
402 c @ b'1'...b'9' => {
403 let mut res = (c - b'0') as u64;
404
405 loop {
406 match try!(self.peek_or_null()) {
407 c @ b'0'...b'9' => {
408 self.eat_char();
409 let digit = (c - b'0') as u64;
410
411 if overflow!(res * 10 + digit, u64::max_value()) {
415 return Ok(ParserNumber::F64(try!(self.parse_long_integer(
416 positive,
417 res,
418 1, ))));
420 }
421
422 res = res * 10 + digit;
423 }
424 _ => {
425 return self.parse_number(positive, res);
426 }
427 }
428 }
429 }
430 _ => Err(self.error(ErrorCode::InvalidNumber)),
431 }
432 }
433
434 fn parse_long_integer(
435 &mut self,
436 positive: bool,
437 significand: u64,
438 mut exponent: i32,
439 ) -> Result<f64> {
440 loop {
441 match try!(self.peek_or_null()) {
442 b'0'...b'9' => {
443 self.eat_char();
444 exponent += 1;
447 }
448 b'.' => {
449 return self.parse_decimal(positive, significand, exponent);
450 }
451 b'e' | b'E' => {
452 return self.parse_exponent(positive, significand, exponent);
453 }
454 _ => {
455 return self.f64_from_parts(positive, significand, exponent);
456 }
457 }
458 }
459 }
460
461 fn parse_number(&mut self, positive: bool, significand: u64) -> Result<ParserNumber> {
462 Ok(match try!(self.peek_or_null()) {
463 b'.' => ParserNumber::F64(try!(self.parse_decimal(positive, significand, 0))),
464 b'e' | b'E' => ParserNumber::F64(try!(self.parse_exponent(positive, significand, 0))),
465 _ => {
466 if positive {
467 ParserNumber::U64(significand)
468 } else {
469 let neg = (significand as i64).wrapping_neg();
470
471 if neg > 0 {
473 ParserNumber::F64(-(significand as f64))
474 } else {
475 ParserNumber::I64(neg)
476 }
477 }
478 }
479 })
480 }
481
482 fn parse_decimal(
483 &mut self,
484 positive: bool,
485 mut significand: u64,
486 mut exponent: i32,
487 ) -> Result<f64> {
488 self.eat_char();
489
490 let mut at_least_one_digit = false;
491 while let c @ b'0'...b'9' = try!(self.peek_or_null()) {
492 self.eat_char();
493 let digit = (c - b'0') as u64;
494 at_least_one_digit = true;
495
496 if overflow!(significand * 10 + digit, u64::max_value()) {
497 while let b'0'...b'9' = try!(self.peek_or_null()) {
500 self.eat_char();
501 }
502 break;
503 }
504
505 significand = significand * 10 + digit;
506 exponent -= 1;
507 }
508
509 if !at_least_one_digit {
510 match try!(self.peek()) {
511 Some(_) => return Err(self.peek_error(ErrorCode::InvalidNumber)),
512 None => return Err(self.peek_error(ErrorCode::EofWhileParsingValue)),
513 }
514 }
515
516 match try!(self.peek_or_null()) {
517 b'e' | b'E' => self.parse_exponent(positive, significand, exponent),
518 _ => self.f64_from_parts(positive, significand, exponent),
519 }
520 }
521
522 fn parse_exponent(
523 &mut self,
524 positive: bool,
525 significand: u64,
526 starting_exp: i32,
527 ) -> Result<f64> {
528 self.eat_char();
529
530 let positive_exp = match try!(self.peek_or_null()) {
531 b'+' => {
532 self.eat_char();
533 true
534 }
535 b'-' => {
536 self.eat_char();
537 false
538 }
539 _ => true,
540 };
541
542 let next = match try!(self.next_char()) {
543 Some(b) => b,
544 None => {
545 return Err(self.error(ErrorCode::EofWhileParsingValue));
546 }
547 };
548
549 let mut exp = match next {
551 c @ b'0'...b'9' => (c - b'0') as i32,
552 _ => {
553 return Err(self.error(ErrorCode::InvalidNumber));
554 }
555 };
556
557 while let c @ b'0'...b'9' = try!(self.peek_or_null()) {
558 self.eat_char();
559 let digit = (c - b'0') as i32;
560
561 if overflow!(exp * 10 + digit, i32::max_value()) {
562 return self.parse_exponent_overflow(positive, significand, positive_exp);
563 }
564
565 exp = exp * 10 + digit;
566 }
567
568 let final_exp = if positive_exp {
569 starting_exp.saturating_add(exp)
570 } else {
571 starting_exp.saturating_sub(exp)
572 };
573
574 self.f64_from_parts(positive, significand, final_exp)
575 }
576
577 #[cold]
580 #[inline(never)]
581 fn parse_exponent_overflow(
582 &mut self,
583 positive: bool,
584 significand: u64,
585 positive_exp: bool,
586 ) -> Result<f64> {
587 if significand != 0 && positive_exp {
589 return Err(self.error(ErrorCode::NumberOutOfRange));
590 }
591
592 while let b'0'...b'9' = try!(self.peek_or_null()) {
593 self.eat_char();
594 }
595 Ok(if positive { 0.0 } else { -0.0 })
596 }
597
598 fn parse_any_signed_number(&mut self) -> Result<ParserNumber> {
599 let peek = match try!(self.peek()) {
600 Some(b) => b,
601 None => {
602 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
603 }
604 };
605
606 let value = match peek {
607 b'-' => {
608 self.eat_char();
609 self.parse_any_number(false)
610 }
611 b'0'...b'9' => self.parse_any_number(true),
612 _ => Err(self.peek_error(ErrorCode::InvalidNumber)),
613 };
614
615 let value = match try!(self.peek()) {
616 Some(_) => Err(self.peek_error(ErrorCode::InvalidNumber)),
617 None => value,
618 };
619
620 match value {
621 Ok(value) => Ok(value),
622 Err(err) => Err(self.fix_position(err)),
628 }
629 }
630
631 #[cfg(not(feature = "arbitrary_precision"))]
632 fn parse_any_number(&mut self, positive: bool) -> Result<ParserNumber> {
633 self.parse_integer(positive)
634 }
635
636 #[cfg(feature = "arbitrary_precision")]
637 fn parse_any_number(&mut self, positive: bool) -> Result<ParserNumber> {
638 let mut buf = String::with_capacity(16);
639 if !positive {
640 buf.push('-');
641 }
642 self.scan_integer(&mut buf)?;
643 Ok(ParserNumber::String(buf))
644 }
645
646 #[cfg(feature = "arbitrary_precision")]
647 fn scan_or_eof(&mut self, buf: &mut String) -> Result<u8> {
648 match try!(self.next_char()) {
649 Some(b) => {
650 buf.push(b as char);
651 Ok(b)
652 }
653 None => Err(self.error(ErrorCode::EofWhileParsingValue)),
654 }
655 }
656
657 #[cfg(feature = "arbitrary_precision")]
658 fn scan_integer(&mut self, buf: &mut String) -> Result<()> {
659 match try!(self.scan_or_eof(buf)) {
660 b'0' => {
661 match try!(self.peek_or_null()) {
663 b'0'...b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)),
664 _ => self.scan_number(buf),
665 }
666 }
667 b'1'...b'9' => loop {
668 match try!(self.peek_or_null()) {
669 c @ b'0'...b'9' => {
670 self.eat_char();
671 buf.push(c as char);
672 }
673 _ => {
674 return self.scan_number(buf);
675 }
676 }
677 },
678 _ => Err(self.error(ErrorCode::InvalidNumber)),
679 }
680 }
681
682 #[cfg(feature = "arbitrary_precision")]
683 fn scan_number(&mut self, buf: &mut String) -> Result<()> {
684 match try!(self.peek_or_null()) {
685 b'.' => self.scan_decimal(buf),
686 b'e' | b'E' => self.scan_exponent(buf),
687 _ => Ok(()),
688 }
689 }
690
691 #[cfg(feature = "arbitrary_precision")]
692 fn scan_decimal(&mut self, buf: &mut String) -> Result<()> {
693 self.eat_char();
694 buf.push('.');
695
696 let mut at_least_one_digit = false;
697 while let c @ b'0'...b'9' = try!(self.peek_or_null()) {
698 self.eat_char();
699 buf.push(c as char);
700 at_least_one_digit = true;
701 }
702
703 if !at_least_one_digit {
704 match try!(self.peek()) {
705 Some(_) => return Err(self.peek_error(ErrorCode::InvalidNumber)),
706 None => return Err(self.peek_error(ErrorCode::EofWhileParsingValue)),
707 }
708 }
709
710 match try!(self.peek_or_null()) {
711 b'e' | b'E' => self.scan_exponent(buf),
712 _ => Ok(()),
713 }
714 }
715
716 #[cfg(feature = "arbitrary_precision")]
717 fn scan_exponent(&mut self, buf: &mut String) -> Result<()> {
718 self.eat_char();
719 buf.push('e');
720
721 match try!(self.peek_or_null()) {
722 b'+' => {
723 self.eat_char();
724 }
725 b'-' => {
726 self.eat_char();
727 buf.push('-');
728 }
729 _ => {}
730 }
731
732 match try!(self.scan_or_eof(buf)) {
734 b'0'...b'9' => {}
735 _ => {
736 return Err(self.error(ErrorCode::InvalidNumber));
737 }
738 }
739
740 while let c @ b'0'...b'9' = try!(self.peek_or_null()) {
741 self.eat_char();
742 buf.push(c as char);
743 }
744
745 Ok(())
746 }
747
748 fn f64_from_parts(
749 &mut self,
750 positive: bool,
751 significand: u64,
752 mut exponent: i32,
753 ) -> Result<f64> {
754 let mut f = significand as f64;
755 loop {
756 match POW10.get(exponent.wrapping_abs() as usize) {
757 Some(&pow) => {
758 if exponent >= 0 {
759 f *= pow;
760 if f.is_infinite() {
761 return Err(self.error(ErrorCode::NumberOutOfRange));
762 }
763 } else {
764 f /= pow;
765 }
766 break;
767 }
768 None => {
769 if f == 0.0 {
770 break;
771 }
772 if exponent >= 0 {
773 return Err(self.error(ErrorCode::NumberOutOfRange));
774 }
775 f /= 1e308;
776 exponent += 308;
777 }
778 }
779 }
780 Ok(if positive { f } else { -f })
781 }
782
783 fn parse_object_colon(&mut self) -> Result<()> {
784 match try!(self.parse_whitespace()) {
785 Some(b':') => {
786 self.eat_char();
787 Ok(())
788 }
789 Some(_) => Err(self.peek_error(ErrorCode::ExpectedColon)),
790 None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
791 }
792 }
793
794 fn end_seq(&mut self) -> Result<()> {
795 match try!(self.parse_whitespace()) {
796 Some(b']') => {
797 self.eat_char();
798 Ok(())
799 }
800 Some(b',') => {
801 self.eat_char();
802 match self.parse_whitespace() {
803 Ok(Some(b']')) => Err(self.peek_error(ErrorCode::TrailingComma)),
804 _ => Err(self.peek_error(ErrorCode::TrailingCharacters)),
805 }
806 }
807 Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)),
808 None => Err(self.peek_error(ErrorCode::EofWhileParsingList)),
809 }
810 }
811
812 fn end_map(&mut self) -> Result<()> {
813 match try!(self.parse_whitespace()) {
814 Some(b'}') => {
815 self.eat_char();
816 Ok(())
817 }
818 Some(b',') => Err(self.peek_error(ErrorCode::TrailingComma)),
819 Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)),
820 None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
821 }
822 }
823
824 fn ignore_value(&mut self) -> Result<()> {
825 self.scratch.clear();
826 let mut enclosing = None;
827
828 loop {
829 let peek = match try!(self.parse_whitespace()) {
830 Some(b) => b,
831 None => {
832 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
833 }
834 };
835
836 let frame = match peek {
837 b'n' => {
838 self.eat_char();
839 try!(self.parse_ident(b"ull"));
840 None
841 }
842 b't' => {
843 self.eat_char();
844 try!(self.parse_ident(b"rue"));
845 None
846 }
847 b'f' => {
848 self.eat_char();
849 try!(self.parse_ident(b"alse"));
850 None
851 }
852 b'-' => {
853 self.eat_char();
854 try!(self.ignore_integer());
855 None
856 }
857 b'0'...b'9' => {
858 try!(self.ignore_integer());
859 None
860 }
861 b'"' => {
862 self.eat_char();
863 try!(self.read.ignore_str());
864 None
865 }
866 frame @ b'[' | frame @ b'{' => {
867 self.scratch.extend(enclosing.take());
868 self.eat_char();
869 Some(frame)
870 }
871 _ => return Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
872 };
873
874 let (mut accept_comma, mut frame) = match frame {
875 Some(frame) => (false, frame),
876 None => match enclosing.take() {
877 Some(frame) => (true, frame),
878 None => match self.scratch.pop() {
879 Some(frame) => (true, frame),
880 None => return Ok(()),
881 },
882 },
883 };
884
885 loop {
886 match try!(self.parse_whitespace()) {
887 Some(b',') if accept_comma => {
888 self.eat_char();
889 break;
890 }
891 Some(b']') if frame == b'[' => {}
892 Some(b'}') if frame == b'{' => {}
893 Some(_) => {
894 if accept_comma {
895 return Err(self.peek_error(match frame {
896 b'[' => ErrorCode::ExpectedListCommaOrEnd,
897 b'{' => ErrorCode::ExpectedObjectCommaOrEnd,
898 _ => unreachable!(),
899 }));
900 } else {
901 break;
902 }
903 }
904 None => {
905 return Err(self.peek_error(match frame {
906 b'[' => ErrorCode::EofWhileParsingList,
907 b'{' => ErrorCode::EofWhileParsingObject,
908 _ => unreachable!(),
909 }));
910 }
911 }
912
913 self.eat_char();
914 frame = match self.scratch.pop() {
915 Some(frame) => frame,
916 None => return Ok(()),
917 };
918 accept_comma = true;
919 }
920
921 if frame == b'{' {
922 match try!(self.parse_whitespace()) {
923 Some(b'"') => self.eat_char(),
924 Some(_) => return Err(self.peek_error(ErrorCode::KeyMustBeAString)),
925 None => return Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
926 }
927 try!(self.read.ignore_str());
928 match try!(self.parse_whitespace()) {
929 Some(b':') => self.eat_char(),
930 Some(_) => return Err(self.peek_error(ErrorCode::ExpectedColon)),
931 None => return Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
932 }
933 }
934
935 enclosing = Some(frame);
936 }
937 }
938
939 fn ignore_integer(&mut self) -> Result<()> {
940 match try!(self.next_char_or_null()) {
941 b'0' => {
942 if let b'0'...b'9' = try!(self.peek_or_null()) {
944 return Err(self.peek_error(ErrorCode::InvalidNumber));
945 }
946 }
947 b'1'...b'9' => {
948 while let b'0'...b'9' = try!(self.peek_or_null()) {
949 self.eat_char();
950 }
951 }
952 _ => {
953 return Err(self.error(ErrorCode::InvalidNumber));
954 }
955 }
956
957 match try!(self.peek_or_null()) {
958 b'.' => self.ignore_decimal(),
959 b'e' | b'E' => self.ignore_exponent(),
960 _ => Ok(()),
961 }
962 }
963
964 fn ignore_decimal(&mut self) -> Result<()> {
965 self.eat_char();
966
967 let mut at_least_one_digit = false;
968 while let b'0'...b'9' = try!(self.peek_or_null()) {
969 self.eat_char();
970 at_least_one_digit = true;
971 }
972
973 if !at_least_one_digit {
974 return Err(self.peek_error(ErrorCode::InvalidNumber));
975 }
976
977 match try!(self.peek_or_null()) {
978 b'e' | b'E' => self.ignore_exponent(),
979 _ => Ok(()),
980 }
981 }
982
983 fn ignore_exponent(&mut self) -> Result<()> {
984 self.eat_char();
985
986 match try!(self.peek_or_null()) {
987 b'+' | b'-' => self.eat_char(),
988 _ => {}
989 }
990
991 match try!(self.next_char_or_null()) {
993 b'0'...b'9' => {}
994 _ => {
995 return Err(self.error(ErrorCode::InvalidNumber));
996 }
997 }
998
999 while let b'0'...b'9' = try!(self.peek_or_null()) {
1000 self.eat_char();
1001 }
1002
1003 Ok(())
1004 }
1005
1006 #[cfg(feature = "raw_value")]
1007 fn deserialize_raw_value<V>(&mut self, visitor: V) -> Result<V::Value>
1008 where
1009 V: de::Visitor<'de>,
1010 {
1011 self.parse_whitespace()?;
1012 self.read.begin_raw_buffering();
1013 self.ignore_value()?;
1014 self.read.end_raw_buffering(visitor)
1015 }
1016}
1017
1018impl FromStr for Number {
1019 type Err = Error;
1020
1021 fn from_str(s: &str) -> result::Result<Self, Self::Err> {
1022 Deserializer::from_str(s)
1023 .parse_any_signed_number()
1024 .map(Into::into)
1025 }
1026}
1027
1028static POW10: [f64; 309] = [
1029 1e000, 1e001, 1e002, 1e003, 1e004, 1e005, 1e006, 1e007, 1e008, 1e009, 1e010, 1e011, 1e012, 1e013, 1e014, 1e015, 1e016, 1e017, 1e018, 1e019, 1e020, 1e021, 1e022, 1e023, 1e024, 1e025, 1e026, 1e027, 1e028, 1e029, 1e030, 1e031, 1e032, 1e033, 1e034, 1e035, 1e036, 1e037, 1e038, 1e039, 1e040, 1e041, 1e042, 1e043, 1e044, 1e045, 1e046, 1e047, 1e048, 1e049, 1e050, 1e051, 1e052, 1e053, 1e054, 1e055, 1e056, 1e057, 1e058, 1e059, 1e060, 1e061, 1e062, 1e063, 1e064, 1e065, 1e066, 1e067, 1e068, 1e069, 1e070, 1e071, 1e072, 1e073, 1e074, 1e075, 1e076, 1e077, 1e078, 1e079, 1e080, 1e081, 1e082, 1e083, 1e084, 1e085, 1e086, 1e087, 1e088, 1e089, 1e090, 1e091, 1e092, 1e093, 1e094, 1e095, 1e096, 1e097, 1e098, 1e099, 1e100, 1e101, 1e102, 1e103, 1e104, 1e105, 1e106, 1e107, 1e108, 1e109, 1e110, 1e111, 1e112, 1e113, 1e114, 1e115, 1e116, 1e117, 1e118, 1e119, 1e120, 1e121, 1e122, 1e123, 1e124, 1e125, 1e126, 1e127, 1e128, 1e129, 1e130, 1e131, 1e132, 1e133, 1e134, 1e135, 1e136, 1e137, 1e138, 1e139, 1e140, 1e141, 1e142, 1e143, 1e144, 1e145, 1e146, 1e147, 1e148, 1e149, 1e150, 1e151, 1e152, 1e153, 1e154, 1e155, 1e156, 1e157, 1e158, 1e159, 1e160, 1e161, 1e162, 1e163, 1e164, 1e165, 1e166, 1e167, 1e168, 1e169, 1e170, 1e171, 1e172, 1e173, 1e174, 1e175, 1e176, 1e177, 1e178, 1e179, 1e180, 1e181, 1e182, 1e183, 1e184, 1e185, 1e186, 1e187, 1e188, 1e189, 1e190, 1e191, 1e192, 1e193, 1e194, 1e195, 1e196, 1e197, 1e198, 1e199, 1e200, 1e201, 1e202, 1e203, 1e204, 1e205, 1e206, 1e207, 1e208, 1e209, 1e210, 1e211, 1e212, 1e213, 1e214, 1e215, 1e216, 1e217, 1e218, 1e219, 1e220, 1e221, 1e222, 1e223, 1e224, 1e225, 1e226, 1e227, 1e228, 1e229, 1e230, 1e231, 1e232, 1e233, 1e234, 1e235, 1e236, 1e237, 1e238, 1e239, 1e240, 1e241, 1e242, 1e243, 1e244, 1e245, 1e246, 1e247, 1e248, 1e249, 1e250, 1e251, 1e252, 1e253, 1e254, 1e255, 1e256, 1e257, 1e258, 1e259, 1e260, 1e261, 1e262, 1e263, 1e264, 1e265, 1e266, 1e267, 1e268, 1e269, 1e270, 1e271, 1e272, 1e273, 1e274, 1e275, 1e276, 1e277, 1e278, 1e279, 1e280, 1e281, 1e282, 1e283, 1e284, 1e285, 1e286, 1e287, 1e288, 1e289, 1e290, 1e291, 1e292, 1e293, 1e294, 1e295, 1e296, 1e297, 1e298, 1e299, 1e300, 1e301, 1e302, 1e303, 1e304, 1e305, 1e306, 1e307, 1e308,
1060];
1061
1062macro_rules! deserialize_prim_number {
1063 ($method:ident) => {
1064 fn $method<V>(self, visitor: V) -> Result<V::Value>
1065 where
1066 V: de::Visitor<'de>,
1067 {
1068 self.deserialize_prim_number(visitor)
1069 }
1070 }
1071}
1072
1073#[cfg(not(feature = "unbounded_depth"))]
1074macro_rules! if_checking_recursion_limit {
1075 ($($body:tt)*) => {
1076 $($body)*
1077 };
1078}
1079
1080#[cfg(feature = "unbounded_depth")]
1081macro_rules! if_checking_recursion_limit {
1082 ($this:ident $($body:tt)*) => {
1083 if !$this.disable_recursion_limit {
1084 $this $($body)*
1085 }
1086 };
1087}
1088
1089macro_rules! check_recursion {
1090 ($this:ident $($body:tt)*) => {
1091 if_checking_recursion_limit! {
1092 $this.remaining_depth -= 1;
1093 if $this.remaining_depth == 0 {
1094 return Err($this.peek_error(ErrorCode::RecursionLimitExceeded));
1095 }
1096 }
1097
1098 $this $($body)*
1099
1100 if_checking_recursion_limit! {
1101 $this.remaining_depth += 1;
1102 }
1103 };
1104}
1105
1106impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
1107 type Error = Error;
1108
1109 #[inline]
1110 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
1111 where
1112 V: de::Visitor<'de>,
1113 {
1114 let peek = match try!(self.parse_whitespace()) {
1115 Some(b) => b,
1116 None => {
1117 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1118 }
1119 };
1120
1121 let value = match peek {
1122 b'n' => {
1123 self.eat_char();
1124 try!(self.parse_ident(b"ull"));
1125 visitor.visit_unit()
1126 }
1127 b't' => {
1128 self.eat_char();
1129 try!(self.parse_ident(b"rue"));
1130 visitor.visit_bool(true)
1131 }
1132 b'f' => {
1133 self.eat_char();
1134 try!(self.parse_ident(b"alse"));
1135 visitor.visit_bool(false)
1136 }
1137 b'-' => {
1138 self.eat_char();
1139 try!(self.parse_any_number(false)).visit(visitor)
1140 }
1141 b'0'...b'9' => try!(self.parse_any_number(true)).visit(visitor),
1142 b'"' => {
1143 self.eat_char();
1144 self.scratch.clear();
1145 match try!(self.read.parse_str(&mut self.scratch)) {
1146 Reference::Borrowed(s) => visitor.visit_borrowed_str(s),
1147 Reference::Copied(s) => visitor.visit_str(s),
1148 }
1149 }
1150 b'[' => {
1151 check_recursion! {
1152 self.eat_char();
1153 let ret = visitor.visit_seq(SeqAccess::new(self));
1154 }
1155
1156 match (ret, self.end_seq()) {
1157 (Ok(ret), Ok(())) => Ok(ret),
1158 (Err(err), _) | (_, Err(err)) => Err(err),
1159 }
1160 }
1161 b'{' => {
1162 check_recursion! {
1163 self.eat_char();
1164 let ret = visitor.visit_map(MapAccess::new(self));
1165 }
1166
1167 match (ret, self.end_map()) {
1168 (Ok(ret), Ok(())) => Ok(ret),
1169 (Err(err), _) | (_, Err(err)) => Err(err),
1170 }
1171 }
1172 _ => Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
1173 };
1174
1175 match value {
1176 Ok(value) => Ok(value),
1177 Err(err) => Err(self.fix_position(err)),
1183 }
1184 }
1185
1186 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
1187 where
1188 V: de::Visitor<'de>,
1189 {
1190 let peek = match try!(self.parse_whitespace()) {
1191 Some(b) => b,
1192 None => {
1193 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1194 }
1195 };
1196
1197 let value = match peek {
1198 b't' => {
1199 self.eat_char();
1200 try!(self.parse_ident(b"rue"));
1201 visitor.visit_bool(true)
1202 }
1203 b'f' => {
1204 self.eat_char();
1205 try!(self.parse_ident(b"alse"));
1206 visitor.visit_bool(false)
1207 }
1208 _ => Err(self.peek_invalid_type(&visitor)),
1209 };
1210
1211 match value {
1212 Ok(value) => Ok(value),
1213 Err(err) => Err(self.fix_position(err)),
1214 }
1215 }
1216
1217 deserialize_prim_number!(deserialize_i8);
1218 deserialize_prim_number!(deserialize_i16);
1219 deserialize_prim_number!(deserialize_i32);
1220 deserialize_prim_number!(deserialize_i64);
1221 deserialize_prim_number!(deserialize_u8);
1222 deserialize_prim_number!(deserialize_u16);
1223 deserialize_prim_number!(deserialize_u32);
1224 deserialize_prim_number!(deserialize_u64);
1225 deserialize_prim_number!(deserialize_f32);
1226 deserialize_prim_number!(deserialize_f64);
1227
1228 serde_if_integer128! {
1229 fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value>
1230 where
1231 V: de::Visitor<'de>,
1232 {
1233 let mut buf = String::new();
1234
1235 match try!(self.parse_whitespace()) {
1236 Some(b'-') => {
1237 self.eat_char();
1238 buf.push('-');
1239 }
1240 Some(_) => {}
1241 None => {
1242 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1243 }
1244 };
1245
1246 try!(self.scan_integer128(&mut buf));
1247
1248 let value = match buf.parse() {
1249 Ok(int) => visitor.visit_i128(int),
1250 Err(_) => {
1251 return Err(self.error(ErrorCode::NumberOutOfRange));
1252 }
1253 };
1254
1255 match value {
1256 Ok(value) => Ok(value),
1257 Err(err) => Err(self.fix_position(err)),
1258 }
1259 }
1260
1261 fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value>
1262 where
1263 V: de::Visitor<'de>,
1264 {
1265 match try!(self.parse_whitespace()) {
1266 Some(b'-') => {
1267 return Err(self.peek_error(ErrorCode::NumberOutOfRange));
1268 }
1269 Some(_) => {}
1270 None => {
1271 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1272 }
1273 }
1274
1275 let mut buf = String::new();
1276 try!(self.scan_integer128(&mut buf));
1277
1278 let value = match buf.parse() {
1279 Ok(int) => visitor.visit_u128(int),
1280 Err(_) => {
1281 return Err(self.error(ErrorCode::NumberOutOfRange));
1282 }
1283 };
1284
1285 match value {
1286 Ok(value) => Ok(value),
1287 Err(err) => Err(self.fix_position(err)),
1288 }
1289 }
1290 }
1291
1292 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
1293 where
1294 V: de::Visitor<'de>,
1295 {
1296 self.deserialize_str(visitor)
1297 }
1298
1299 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
1300 where
1301 V: de::Visitor<'de>,
1302 {
1303 let peek = match try!(self.parse_whitespace()) {
1304 Some(b) => b,
1305 None => {
1306 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1307 }
1308 };
1309
1310 let value = match peek {
1311 b'"' => {
1312 self.eat_char();
1313 self.scratch.clear();
1314 match try!(self.read.parse_str(&mut self.scratch)) {
1315 Reference::Borrowed(s) => visitor.visit_borrowed_str(s),
1316 Reference::Copied(s) => visitor.visit_str(s),
1317 }
1318 }
1319 _ => Err(self.peek_invalid_type(&visitor)),
1320 };
1321
1322 match value {
1323 Ok(value) => Ok(value),
1324 Err(err) => Err(self.fix_position(err)),
1325 }
1326 }
1327
1328 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
1329 where
1330 V: de::Visitor<'de>,
1331 {
1332 self.deserialize_str(visitor)
1333 }
1334
1335 fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
1407 where
1408 V: de::Visitor<'de>,
1409 {
1410 let peek = match try!(self.parse_whitespace()) {
1411 Some(b) => b,
1412 None => {
1413 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1414 }
1415 };
1416
1417 let value = match peek {
1418 b'"' => {
1419 self.eat_char();
1420 self.scratch.clear();
1421 match try!(self.read.parse_str_raw(&mut self.scratch)) {
1422 Reference::Borrowed(b) => visitor.visit_borrowed_bytes(b),
1423 Reference::Copied(b) => visitor.visit_bytes(b),
1424 }
1425 }
1426 b'[' => self.deserialize_seq(visitor),
1427 _ => Err(self.peek_invalid_type(&visitor)),
1428 };
1429
1430 match value {
1431 Ok(value) => Ok(value),
1432 Err(err) => Err(self.fix_position(err)),
1433 }
1434 }
1435
1436 #[inline]
1437 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
1438 where
1439 V: de::Visitor<'de>,
1440 {
1441 self.deserialize_bytes(visitor)
1442 }
1443
1444 #[inline]
1446 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
1447 where
1448 V: de::Visitor<'de>,
1449 {
1450 match try!(self.parse_whitespace()) {
1451 Some(b'n') => {
1452 self.eat_char();
1453 try!(self.parse_ident(b"ull"));
1454 visitor.visit_none()
1455 }
1456 _ => visitor.visit_some(self),
1457 }
1458 }
1459
1460 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
1461 where
1462 V: de::Visitor<'de>,
1463 {
1464 let peek = match try!(self.parse_whitespace()) {
1465 Some(b) => b,
1466 None => {
1467 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1468 }
1469 };
1470
1471 let value = match peek {
1472 b'n' => {
1473 self.eat_char();
1474 try!(self.parse_ident(b"ull"));
1475 visitor.visit_unit()
1476 }
1477 _ => Err(self.peek_invalid_type(&visitor)),
1478 };
1479
1480 match value {
1481 Ok(value) => Ok(value),
1482 Err(err) => Err(self.fix_position(err)),
1483 }
1484 }
1485
1486 fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
1487 where
1488 V: de::Visitor<'de>,
1489 {
1490 self.deserialize_unit(visitor)
1491 }
1492
1493 #[inline]
1495 fn deserialize_newtype_struct<V>(self, name: &str, visitor: V) -> Result<V::Value>
1496 where
1497 V: de::Visitor<'de>,
1498 {
1499 #[cfg(feature = "raw_value")]
1500 {
1501 if name == ::raw::TOKEN {
1502 return self.deserialize_raw_value(visitor);
1503 }
1504 }
1505
1506 let _ = name;
1507 visitor.visit_newtype_struct(self)
1508 }
1509
1510 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
1511 where
1512 V: de::Visitor<'de>,
1513 {
1514 let peek = match try!(self.parse_whitespace()) {
1515 Some(b) => b,
1516 None => {
1517 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1518 }
1519 };
1520
1521 let value = match peek {
1522 b'[' => {
1523 check_recursion! {
1524 self.eat_char();
1525 let ret = visitor.visit_seq(SeqAccess::new(self));
1526 }
1527
1528 match (ret, self.end_seq()) {
1529 (Ok(ret), Ok(())) => Ok(ret),
1530 (Err(err), _) | (_, Err(err)) => Err(err),
1531 }
1532 }
1533 _ => Err(self.peek_invalid_type(&visitor)),
1534 };
1535
1536 match value {
1537 Ok(value) => Ok(value),
1538 Err(err) => Err(self.fix_position(err)),
1539 }
1540 }
1541
1542 fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
1543 where
1544 V: de::Visitor<'de>,
1545 {
1546 self.deserialize_seq(visitor)
1547 }
1548
1549 fn deserialize_tuple_struct<V>(
1550 self,
1551 _name: &'static str,
1552 _len: usize,
1553 visitor: V,
1554 ) -> Result<V::Value>
1555 where
1556 V: de::Visitor<'de>,
1557 {
1558 self.deserialize_seq(visitor)
1559 }
1560
1561 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
1562 where
1563 V: de::Visitor<'de>,
1564 {
1565 let peek = match try!(self.parse_whitespace()) {
1566 Some(b) => b,
1567 None => {
1568 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1569 }
1570 };
1571
1572 let value = match peek {
1573 b'{' => {
1574 check_recursion! {
1575 self.eat_char();
1576 let ret = visitor.visit_map(MapAccess::new(self));
1577 }
1578
1579 match (ret, self.end_map()) {
1580 (Ok(ret), Ok(())) => Ok(ret),
1581 (Err(err), _) | (_, Err(err)) => Err(err),
1582 }
1583 }
1584 _ => Err(self.peek_invalid_type(&visitor)),
1585 };
1586
1587 match value {
1588 Ok(value) => Ok(value),
1589 Err(err) => Err(self.fix_position(err)),
1590 }
1591 }
1592
1593 fn deserialize_struct<V>(
1594 self,
1595 _name: &'static str,
1596 _fields: &'static [&'static str],
1597 visitor: V,
1598 ) -> Result<V::Value>
1599 where
1600 V: de::Visitor<'de>,
1601 {
1602 let peek = match try!(self.parse_whitespace()) {
1603 Some(b) => b,
1604 None => {
1605 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1606 }
1607 };
1608
1609 let value = match peek {
1610 b'[' => {
1611 check_recursion! {
1612 self.eat_char();
1613 let ret = visitor.visit_seq(SeqAccess::new(self));
1614 }
1615
1616 match (ret, self.end_seq()) {
1617 (Ok(ret), Ok(())) => Ok(ret),
1618 (Err(err), _) | (_, Err(err)) => Err(err),
1619 }
1620 }
1621 b'{' => {
1622 check_recursion! {
1623 self.eat_char();
1624 let ret = visitor.visit_map(MapAccess::new(self));
1625 }
1626
1627 match (ret, self.end_map()) {
1628 (Ok(ret), Ok(())) => Ok(ret),
1629 (Err(err), _) | (_, Err(err)) => Err(err),
1630 }
1631 }
1632 _ => Err(self.peek_invalid_type(&visitor)),
1633 };
1634
1635 match value {
1636 Ok(value) => Ok(value),
1637 Err(err) => Err(self.fix_position(err)),
1638 }
1639 }
1640
1641 #[inline]
1644 fn deserialize_enum<V>(
1645 self,
1646 _name: &str,
1647 _variants: &'static [&'static str],
1648 visitor: V,
1649 ) -> Result<V::Value>
1650 where
1651 V: de::Visitor<'de>,
1652 {
1653 match try!(self.parse_whitespace()) {
1654 Some(b'{') => {
1655 check_recursion! {
1656 self.eat_char();
1657 let value = try!(visitor.visit_enum(VariantAccess::new(self)));
1658 }
1659
1660 match try!(self.parse_whitespace()) {
1661 Some(b'}') => {
1662 self.eat_char();
1663 Ok(value)
1664 }
1665 Some(_) => Err(self.error(ErrorCode::ExpectedSomeValue)),
1666 None => Err(self.error(ErrorCode::EofWhileParsingObject)),
1667 }
1668 }
1669 Some(b'"') => visitor.visit_enum(UnitVariantAccess::new(self)),
1670 Some(_) => Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
1671 None => Err(self.peek_error(ErrorCode::EofWhileParsingValue)),
1672 }
1673 }
1674
1675 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
1676 where
1677 V: de::Visitor<'de>,
1678 {
1679 self.deserialize_str(visitor)
1680 }
1681
1682 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
1683 where
1684 V: de::Visitor<'de>,
1685 {
1686 try!(self.ignore_value());
1687 visitor.visit_unit()
1688 }
1689}
1690
1691struct SeqAccess<'a, R: 'a> {
1692 de: &'a mut Deserializer<R>,
1693 first: bool,
1694}
1695
1696impl<'a, R: 'a> SeqAccess<'a, R> {
1697 fn new(de: &'a mut Deserializer<R>) -> Self {
1698 SeqAccess {
1699 de: de,
1700 first: true,
1701 }
1702 }
1703}
1704
1705impl<'de, 'a, R: Read<'de> + 'a> de::SeqAccess<'de> for SeqAccess<'a, R> {
1706 type Error = Error;
1707
1708 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
1709 where
1710 T: de::DeserializeSeed<'de>,
1711 {
1712 let peek = match try!(self.de.parse_whitespace()) {
1713 Some(b']') => {
1714 return Ok(None);
1715 }
1716 Some(b',') if !self.first => {
1717 self.de.eat_char();
1718 try!(self.de.parse_whitespace())
1719 }
1720 Some(b) => {
1721 if self.first {
1722 self.first = false;
1723 Some(b)
1724 } else {
1725 return Err(self.de.peek_error(ErrorCode::ExpectedListCommaOrEnd));
1726 }
1727 }
1728 None => {
1729 return Err(self.de.peek_error(ErrorCode::EofWhileParsingList));
1730 }
1731 };
1732
1733 match peek {
1734 Some(b']') => Err(self.de.peek_error(ErrorCode::TrailingComma)),
1735 Some(_) => Ok(Some(try!(seed.deserialize(&mut *self.de)))),
1736 None => Err(self.de.peek_error(ErrorCode::EofWhileParsingValue)),
1737 }
1738 }
1739}
1740
1741struct MapAccess<'a, R: 'a> {
1742 de: &'a mut Deserializer<R>,
1743 first: bool,
1744}
1745
1746impl<'a, R: 'a> MapAccess<'a, R> {
1747 fn new(de: &'a mut Deserializer<R>) -> Self {
1748 MapAccess {
1749 de: de,
1750 first: true,
1751 }
1752 }
1753}
1754
1755impl<'de, 'a, R: Read<'de> + 'a> de::MapAccess<'de> for MapAccess<'a, R> {
1756 type Error = Error;
1757
1758 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
1759 where
1760 K: de::DeserializeSeed<'de>,
1761 {
1762 let peek = match try!(self.de.parse_whitespace()) {
1763 Some(b'}') => {
1764 return Ok(None);
1765 }
1766 Some(b',') if !self.first => {
1767 self.de.eat_char();
1768 try!(self.de.parse_whitespace())
1769 }
1770 Some(b) => {
1771 if self.first {
1772 self.first = false;
1773 Some(b)
1774 } else {
1775 return Err(self.de.peek_error(ErrorCode::ExpectedObjectCommaOrEnd));
1776 }
1777 }
1778 None => {
1779 return Err(self.de.peek_error(ErrorCode::EofWhileParsingObject));
1780 }
1781 };
1782
1783 match peek {
1784 Some(b'"') => seed.deserialize(MapKey { de: &mut *self.de }).map(Some),
1785 Some(b'}') => Err(self.de.peek_error(ErrorCode::TrailingComma)),
1786 Some(_) => Err(self.de.peek_error(ErrorCode::KeyMustBeAString)),
1787 None => Err(self.de.peek_error(ErrorCode::EofWhileParsingValue)),
1788 }
1789 }
1790
1791 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
1792 where
1793 V: de::DeserializeSeed<'de>,
1794 {
1795 try!(self.de.parse_object_colon());
1796
1797 seed.deserialize(&mut *self.de)
1798 }
1799}
1800
1801struct VariantAccess<'a, R: 'a> {
1802 de: &'a mut Deserializer<R>,
1803}
1804
1805impl<'a, R: 'a> VariantAccess<'a, R> {
1806 fn new(de: &'a mut Deserializer<R>) -> Self {
1807 VariantAccess { de: de }
1808 }
1809}
1810
1811impl<'de, 'a, R: Read<'de> + 'a> de::EnumAccess<'de> for VariantAccess<'a, R> {
1812 type Error = Error;
1813 type Variant = Self;
1814
1815 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self)>
1816 where
1817 V: de::DeserializeSeed<'de>,
1818 {
1819 let val = try!(seed.deserialize(&mut *self.de));
1820 try!(self.de.parse_object_colon());
1821 Ok((val, self))
1822 }
1823}
1824
1825impl<'de, 'a, R: Read<'de> + 'a> de::VariantAccess<'de> for VariantAccess<'a, R> {
1826 type Error = Error;
1827
1828 fn unit_variant(self) -> Result<()> {
1829 de::Deserialize::deserialize(self.de)
1830 }
1831
1832 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
1833 where
1834 T: de::DeserializeSeed<'de>,
1835 {
1836 seed.deserialize(self.de)
1837 }
1838
1839 fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
1840 where
1841 V: de::Visitor<'de>,
1842 {
1843 de::Deserializer::deserialize_seq(self.de, visitor)
1844 }
1845
1846 fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value>
1847 where
1848 V: de::Visitor<'de>,
1849 {
1850 de::Deserializer::deserialize_struct(self.de, "", fields, visitor)
1851 }
1852}
1853
1854struct UnitVariantAccess<'a, R: 'a> {
1855 de: &'a mut Deserializer<R>,
1856}
1857
1858impl<'a, R: 'a> UnitVariantAccess<'a, R> {
1859 fn new(de: &'a mut Deserializer<R>) -> Self {
1860 UnitVariantAccess { de: de }
1861 }
1862}
1863
1864impl<'de, 'a, R: Read<'de> + 'a> de::EnumAccess<'de> for UnitVariantAccess<'a, R> {
1865 type Error = Error;
1866 type Variant = Self;
1867
1868 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self)>
1869 where
1870 V: de::DeserializeSeed<'de>,
1871 {
1872 let variant = try!(seed.deserialize(&mut *self.de));
1873 Ok((variant, self))
1874 }
1875}
1876
1877impl<'de, 'a, R: Read<'de> + 'a> de::VariantAccess<'de> for UnitVariantAccess<'a, R> {
1878 type Error = Error;
1879
1880 fn unit_variant(self) -> Result<()> {
1881 Ok(())
1882 }
1883
1884 fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value>
1885 where
1886 T: de::DeserializeSeed<'de>,
1887 {
1888 Err(de::Error::invalid_type(
1889 Unexpected::UnitVariant,
1890 &"newtype variant",
1891 ))
1892 }
1893
1894 fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value>
1895 where
1896 V: de::Visitor<'de>,
1897 {
1898 Err(de::Error::invalid_type(
1899 Unexpected::UnitVariant,
1900 &"tuple variant",
1901 ))
1902 }
1903
1904 fn struct_variant<V>(self, _fields: &'static [&'static str], _visitor: V) -> Result<V::Value>
1905 where
1906 V: de::Visitor<'de>,
1907 {
1908 Err(de::Error::invalid_type(
1909 Unexpected::UnitVariant,
1910 &"struct variant",
1911 ))
1912 }
1913}
1914
1915struct MapKey<'a, R: 'a> {
1918 de: &'a mut Deserializer<R>,
1919}
1920
1921macro_rules! deserialize_integer_key {
1922 ($method:ident => $visit:ident) => {
1923 fn $method<V>(self, visitor: V) -> Result<V::Value>
1924 where
1925 V: de::Visitor<'de>,
1926 {
1927 self.de.eat_char();
1928 self.de.scratch.clear();
1929 let string = try!(self.de.read.parse_str(&mut self.de.scratch));
1930 match (string.parse(), string) {
1931 (Ok(integer), _) => visitor.$visit(integer),
1932 (Err(_), Reference::Borrowed(s)) => visitor.visit_borrowed_str(s),
1933 (Err(_), Reference::Copied(s)) => visitor.visit_str(s),
1934 }
1935 }
1936 }
1937}
1938
1939impl<'de, 'a, R> de::Deserializer<'de> for MapKey<'a, R>
1940where
1941 R: Read<'de>,
1942{
1943 type Error = Error;
1944
1945 #[inline]
1946 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
1947 where
1948 V: de::Visitor<'de>,
1949 {
1950 self.de.eat_char();
1951 self.de.scratch.clear();
1952 match try!(self.de.read.parse_str(&mut self.de.scratch)) {
1953 Reference::Borrowed(s) => visitor.visit_borrowed_str(s),
1954 Reference::Copied(s) => visitor.visit_str(s),
1955 }
1956 }
1957
1958 deserialize_integer_key!(deserialize_i8 => visit_i8);
1959 deserialize_integer_key!(deserialize_i16 => visit_i16);
1960 deserialize_integer_key!(deserialize_i32 => visit_i32);
1961 deserialize_integer_key!(deserialize_i64 => visit_i64);
1962 deserialize_integer_key!(deserialize_u8 => visit_u8);
1963 deserialize_integer_key!(deserialize_u16 => visit_u16);
1964 deserialize_integer_key!(deserialize_u32 => visit_u32);
1965 deserialize_integer_key!(deserialize_u64 => visit_u64);
1966
1967 serde_if_integer128! {
1968 deserialize_integer_key!(deserialize_i128 => visit_i128);
1969 deserialize_integer_key!(deserialize_u128 => visit_u128);
1970 }
1971
1972 #[inline]
1973 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
1974 where
1975 V: de::Visitor<'de>,
1976 {
1977 visitor.visit_some(self)
1979 }
1980
1981 #[inline]
1982 fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
1983 where
1984 V: de::Visitor<'de>,
1985 {
1986 visitor.visit_newtype_struct(self)
1987 }
1988
1989 #[inline]
1990 fn deserialize_enum<V>(
1991 self,
1992 name: &'static str,
1993 variants: &'static [&'static str],
1994 visitor: V,
1995 ) -> Result<V::Value>
1996 where
1997 V: de::Visitor<'de>,
1998 {
1999 self.de.deserialize_enum(name, variants, visitor)
2000 }
2001
2002 #[inline]
2003 fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
2004 where
2005 V: de::Visitor<'de>,
2006 {
2007 self.de.deserialize_bytes(visitor)
2008 }
2009
2010 #[inline]
2011 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
2012 where
2013 V: de::Visitor<'de>,
2014 {
2015 self.de.deserialize_bytes(visitor)
2016 }
2017
2018 forward_to_deserialize_any! {
2019 bool f32 f64 char str string unit unit_struct seq tuple tuple_struct map
2020 struct identifier ignored_any
2021 }
2022}
2023
2024pub struct StreamDeserializer<'de, R, T> {
2048 de: Deserializer<R>,
2049 offset: usize,
2050 output: PhantomData<T>,
2051 lifetime: PhantomData<&'de ()>,
2052}
2053
2054impl<'de, R, T> StreamDeserializer<'de, R, T>
2055where
2056 R: read::Read<'de>,
2057 T: de::Deserialize<'de>,
2058{
2059 pub fn new(read: R) -> Self {
2068 let offset = read.byte_offset();
2069 StreamDeserializer {
2070 de: Deserializer::new(read),
2071 offset: offset,
2072 output: PhantomData,
2073 lifetime: PhantomData,
2074 }
2075 }
2076
2077 pub fn byte_offset(&self) -> usize {
2109 self.offset
2110 }
2111
2112 fn peek_end_of_value(&mut self) -> Result<()> {
2113 match try!(self.de.peek()) {
2114 Some(b' ') | Some(b'\n') | Some(b'\t') | Some(b'\r') | Some(b'"') | Some(b'[')
2115 | Some(b']') | Some(b'{') | Some(b'}') | Some(b',') | Some(b':') | None => Ok(()),
2116 Some(_) => {
2117 let position = self.de.read.peek_position();
2118 Err(Error::syntax(
2119 ErrorCode::TrailingCharacters,
2120 position.line,
2121 position.column,
2122 ))
2123 }
2124 }
2125 }
2126}
2127
2128impl<'de, R, T> Iterator for StreamDeserializer<'de, R, T>
2129where
2130 R: Read<'de>,
2131 T: de::Deserialize<'de>,
2132{
2133 type Item = Result<T>;
2134
2135 fn next(&mut self) -> Option<Result<T>> {
2136 match self.de.parse_whitespace() {
2140 Ok(None) => {
2141 self.offset = self.de.read.byte_offset();
2142 None
2143 }
2144 Ok(Some(b)) => {
2145 let self_delineated_value = match b {
2149 b'[' | b'"' | b'{' => true,
2150 _ => false,
2151 };
2152 self.offset = self.de.read.byte_offset();
2153 let result = de::Deserialize::deserialize(&mut self.de);
2154
2155 Some(match result {
2156 Ok(value) => {
2157 self.offset = self.de.read.byte_offset();
2158 if self_delineated_value {
2159 Ok(value)
2160 } else {
2161 self.peek_end_of_value().map(|_| value)
2162 }
2163 }
2164 Err(e) => Err(e),
2165 })
2166 }
2167 Err(e) => Some(Err(e)),
2168 }
2169 }
2170}
2171
2172fn from_trait<'de, R, T>(read: R) -> Result<T>
2175where
2176 R: Read<'de>,
2177 T: de::Deserialize<'de>,
2178{
2179 let mut de = Deserializer::new(read);
2180 let value = try!(de::Deserialize::deserialize(&mut de));
2181
2182 try!(de.end());
2184 Ok(value)
2185}
2186
2187pub fn from_reader<R, T>(rdr: R) -> Result<T>
2291where
2292 R: io::Read,
2293 T: de::DeserializeOwned,
2294{
2295 from_trait(read::IoRead::new(rdr))
2296}
2297
2298pub fn from_slice<'a, T>(v: &'a [u8]) -> Result<T>
2334where
2335 T: de::Deserialize<'a>,
2336{
2337 from_trait(read::SliceRead::new(v))
2338}
2339
2340pub fn from_str<'a, T>(s: &'a str) -> Result<T>
2376where
2377 T: de::Deserialize<'a>,
2378{
2379 from_trait(read::StrRead::new(s))
2380}