de.rs - Codebrowser

1	//! Deserialize JSON data to a Rust data structure.
2
3	use crate::error::{Error, ErrorCode, Result};
4	#[cfg(feature = "float_roundtrip")]
5	use crate::lexical;
6	use crate::number::Number;
7	use crate::read::{self, Fused, Reference};
8	use alloc::string::String;
9	use alloc::vec::Vec;
10	#[cfg(feature = "float_roundtrip")]
11	use core::iter;
12	use core::iter::FusedIterator;
13	use core::marker::PhantomData;
14	use core::result;
15	use core::str::FromStr;
16	use serde::de::{self, Expected, Unexpected};
17	use serde::forward_to_deserialize_any;
18
19	#[cfg(feature = "arbitrary_precision")]
20	use crate::number::NumberDeserializer;
21
22	pub use crate::read::{Read, SliceRead, StrRead};
23
24	#[cfg(feature = "std")]
25	pub use crate::read::IoRead;
26
27	//////////////////////////////////////////////////////////////////////////////
28
29	/// A structure that deserializes JSON into Rust values.
30	pub struct Deserializer<R> {
31	read: R,
32	scratch: Vec<u8>,
33	remaining_depth: u8,
34	#[cfg(feature = "float_roundtrip")]
35	single_precision: bool,
36	#[cfg(feature = "unbounded_depth")]
37	disable_recursion_limit: bool,
38	}
39
40	impl<'de, R> Deserializer<R>
41	where
42	R: read::Read<'de>,
43	{
44	/// Create a JSON deserializer from one of the possible serde_json input
45	/// sources.
46	///
47	/// Typically it is more convenient to use one of these methods instead:
48	///
49	/// - Deserializer::from_str
50	/// - Deserializer::from_slice
51	/// - Deserializer::from_reader
52	pub fn new(read: R) -> Self {
53	Deserializer {
54	read,
55	scratch: Vec::new(),
56	remaining_depth: `128`,
57	#[cfg(feature = "float_roundtrip")]
58	single_precision: `false`,
59	#[cfg(feature = "unbounded_depth")]
60	disable_recursion_limit: `false`,
61	}
62	}
63	}
64
65	#[cfg(feature = "std")]
66	impl<R> Deserializer<read::IoRead<R>>
67	where
68	R: crate::io::Read,
69	{
70	/// Creates a JSON deserializer from an `io::Read`.
71	///
72	/// Reader-based deserializers do not support deserializing borrowed types
73	/// like `&str`, since the `std::io::Read` trait has no non-copying methods
74	/// -- everything it does involves copying bytes out of the data source.
75	pub fn from_reader(reader: R) -> Self {
76	Deserializer::new(read::IoRead::new(reader))
77	}
78	}
79
80	impl<'a> Deserializer<read::SliceRead<'a>> {
81	/// Creates a JSON deserializer from a `&[u8]`.
82	pub fn from_slice(bytes: &'a [u8]) -> Self {
83	Deserializer::new(read::SliceRead::new(bytes))
84	}
85	}
86
87	impl<'a> Deserializer<read::StrRead<'a>> {
88	/// Creates a JSON deserializer from a `&str`.
89	pub fn from_str(s: &'a str) -> Self {
90	Deserializer::new(read::StrRead::new(s))
91	}
92	}
93
94	macro_rules! overflow {
95	($a:ident * `10` + $b:ident, $c:expr) => {
96	match $c {
97	c => $a >= c / `10` && ($a > c / `10` \|\| $b > c % `10`),
98	}
99	};
100	}
101
102	pub(crate) enum ParserNumber {
103	F64(f64),
104	U64(u64),
105	I64(i64),
106	#[cfg(feature = "arbitrary_precision")]
107	String(String),
108	}
109
110	impl 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: &dyn 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
135	impl<'de, R: Read<'de>> Deserializer<R> {
136	/// The `Deserializer::end` method should be called after a value has been fully deserialized.
137	/// This allows the `Deserializer` to validate that the input stream is at the end or that it
138	/// only has trailing whitespace.
139	pub fn end(&mut self) -> Result<()> {
140	match tri!(self.parse_whitespace()) {
141	Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)),
142	None => Ok(()),
143	}
144	}
145
146	/// Turn a JSON deserializer into an iterator over values of type T.
147	pub fn into_iter<T>(self) -> StreamDeserializer<'de, R, T>
148	where
149	T: de::Deserialize<'de>,
150	{
151	// This cannot be an implementation of std::iter::IntoIterator because
152	// we need the caller to choose what T is.
153	let offset = self.read.byte_offset();
154	StreamDeserializer {
155	de: self,
156	offset,
157	failed: `false`,
158	output: PhantomData,
159	lifetime: PhantomData,
160	}
161	}
162
163	/// Parse arbitrarily deep JSON structures without any consideration for
164	/// overflowing the stack.
165	///
166	/// You will want to provide some other way to protect against stack
167	/// overflows, such as by wrapping your Deserializer in the dynamically
168	/// growing stack adapter provided by the serde_stacker crate. Additionally
169	/// you will need to be careful around other recursive operations on the
170	/// parsed result which may overflow the stack after deserialization has
171	/// completed, including, but not limited to, Display and Debug and Drop
172	/// impls.
173	///
174	/// This method is only available if serde_json is built with the*
175	/// `"unbounded_depth"` feature.*
176	///
177	/// # Examples
178	///
179	/// ```
180	/// use serde::Deserialize;
181	/// use serde_json::Value;
182	///
183	/// fn main() {
184	/// let mut json = String::new();
185	/// for _ in 0..10000 {
186	/// json = format!("[{}]", json);
187	/// }
188	///
189	/// let mut deserializer = serde_json::Deserializer::from_str(&json);
190	/// deserializer.disable_recursion_limit();
191	/// let deserializer = serde_stacker::Deserializer::new(&mut deserializer);
192	/// let value = Value::deserialize(deserializer).unwrap();
193	///
194	/// carefully_drop_nested_arrays(value);
195	/// }
196	///
197	/// fn carefully_drop_nested_arrays(value: Value) {
198	/// let mut stack = vec![value];
199	/// while let Some(value) = stack.pop() {
200	/// if let Value::Array(array) = value {
201	/// stack.extend(array);
202	/// }
203	/// }
204	/// }
205	/// ```
206	#[cfg(feature = "unbounded_depth")]
207	#[cfg_attr(docsrs, doc(cfg(feature = "unbounded_depth")))]
208	pub fn disable_recursion_limit(&mut self) {
209	self.disable_recursion_limit = `true`;
210	}
211
212	pub(crate) fn peek(&mut self) -> Result<Option<u8>> {
213	self.read.peek()
214	}
215
216	fn peek_or_null(&mut self) -> Result<u8> {
217	Ok(tri!(self.peek()).unwrap_or(b'`\x00`'))
218	}
219
220	fn eat_char(&mut self) {
221	self.read.discard();
222	}
223
224	fn next_char(&mut self) -> Result<Option<u8>> {
225	self.read.next()
226	}
227
228	fn next_char_or_null(&mut self) -> Result<u8> {
229	Ok(tri!(self.next_char()).unwrap_or(b'`\x00`'))
230	}
231
232	/// Error caused by a byte from next_char().
233	#[cold]
234	fn error(&self, reason: ErrorCode) -> Error {
235	let position = self.read.position();
236	Error::syntax(reason, position.line, position.column)
237	}
238
239	/// Error caused by a byte from peek().
240	#[cold]
241	fn peek_error(&self, reason: ErrorCode) -> Error {
242	let position = self.read.peek_position();
243	Error::syntax(reason, position.line, position.column)
244	}
245
246	/// Returns the first non-whitespace byte without consuming it, or `None` if
247	/// EOF is encountered.
248	fn parse_whitespace(&mut self) -> Result<Option<u8>> {
249	loop {
250	match tri!(self.peek()) {
251	Some(b' ' \| b'`\n`' \| b'`\t`' \| b'`\r`') => {
252	self.eat_char();
253	}
254	other => {
255	return Ok(other);
256	}
257	}
258	}
259	}
260
261	#[cold]
262	fn peek_invalid_type(&mut self, exp: &dyn Expected) -> Error {
263	let err = match self.peek_or_null().unwrap_or(b'`\x00`') {
264	b'n' => {
265	self.eat_char();
266	if let Err(err) = self.parse_ident(b"ull") {
267	return err;
268	}
269	de::Error::invalid_type(Unexpected::Unit, exp)
270	}
271	b't' => {
272	self.eat_char();
273	if let Err(err) = self.parse_ident(b"rue") {
274	return err;
275	}
276	de::Error::invalid_type(Unexpected::Bool(`true`), exp)
277	}
278	b'f' => {
279	self.eat_char();
280	if let Err(err) = self.parse_ident(b"alse") {
281	return err;
282	}
283	de::Error::invalid_type(Unexpected::Bool(`false`), exp)
284	}
285	b'-' => {
286	self.eat_char();
287	match self.parse_any_number(`false`) {
288	Ok(n) => n.invalid_type(exp),
289	Err(err) => return err,
290	}
291	}
292	b'0'..=b'9' => match self.parse_any_number(`true`) {
293	Ok(n) => n.invalid_type(exp),
294	Err(err) => return err,
295	},
296	b'"' => {
297	self.eat_char();
298	self.scratch.clear();
299	match self.read.parse_str(&mut self.scratch) {
300	Ok(s) => de::Error::invalid_type(Unexpected::Str(&s), exp),
301	Err(err) => return err,
302	}
303	}
304	b'[' => de::Error::invalid_type(Unexpected::Seq, exp),
305	b'{' => de::Error::invalid_type(Unexpected::Map, exp),
306	_ => self.peek_error(ErrorCode::ExpectedSomeValue),
307	};
308
309	self.fix_position(err)
310	}
311
312	pub(crate) fn deserialize_number<'any, V>(&mut self, visitor: V) -> Result<V::Value>
313	where
314	V: de::Visitor<'any>,
315	{
316	let peek = match tri!(self.parse_whitespace()) {
317	Some(b) => b,
318	None => {
319	return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
320	}
321	};
322
323	let value = match peek {
324	b'-' => {
325	self.eat_char();
326	tri!(self.parse_integer(`false`)).visit(visitor)
327	}
328	b'0'..=b'9' => tri!(self.parse_integer(`true`)).visit(visitor),
329	_ => Err(self.peek_invalid_type(&visitor)),
330	};
331
332	match value {
333	Ok(value) => Ok(value),
334	Err(err) => Err(self.fix_position(err)),
335	}
336	}
337
338	#[cfg(feature = "float_roundtrip")]
339	pub(crate) fn do_deserialize_f32<'any, V>(&mut self, visitor: V) -> Result<V::Value>
340	where
341	V: de::Visitor<'any>,
342	{
343	self.single_precision = `true`;
344	let val = self.deserialize_number(visitor);
345	self.single_precision = `false`;
346	val
347	}
348
349	pub(crate) fn do_deserialize_i128<'any, V>(&mut self, visitor: V) -> Result<V::Value>
350	where
351	V: de::Visitor<'any>,
352	{
353	let mut buf = String::new();
354
355	match tri!(self.parse_whitespace()) {
356	Some(b'-') => {
357	self.eat_char();
358	buf.push('-');
359	}
360	Some(_) => {}
361	None => {
362	return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
363	}
364	};
365
366	tri!(self.scan_integer128(&mut buf));
367
368	let value = match buf.parse() {
369	Ok(int) => visitor.visit_i128(int),
370	Err(_) => {
371	return Err(self.error(ErrorCode::NumberOutOfRange));
372	}
373	};
374
375	match value {
376	Ok(value) => Ok(value),
377	Err(err) => Err(self.fix_position(err)),
378	}
379	}
380
381	pub(crate) fn do_deserialize_u128<'any, V>(&mut self, visitor: V) -> Result<V::Value>
382	where
383	V: de::Visitor<'any>,
384	{
385	match tri!(self.parse_whitespace()) {
386	Some(b'-') => {
387	return Err(self.peek_error(ErrorCode::NumberOutOfRange));
388	}
389	Some(_) => {}
390	None => {
391	return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
392	}
393	}
394
395	let mut buf = String::new();
396	tri!(self.scan_integer128(&mut buf));
397
398	let value = match buf.parse() {
399	Ok(int) => visitor.visit_u128(int),
400	Err(_) => {
401	return Err(self.error(ErrorCode::NumberOutOfRange));
402	}
403	};
404
405	match value {
406	Ok(value) => Ok(value),
407	Err(err) => Err(self.fix_position(err)),
408	}
409	}
410
411	fn scan_integer128(&mut self, buf: &mut String) -> Result<()> {
412	match tri!(self.next_char_or_null()) {
413	b'0' => {
414	buf.push('0');
415	// There can be only one leading '0'.
416	match tri!(self.peek_or_null()) {
417	b'0'..=b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)),
418	_ => Ok(()),
419	}
420	}
421	c @ b'1'..=b'9' => {
422	buf.push(c as char);
423	while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
424	self.eat_char();
425	buf.push(c as char);
426	}
427	Ok(())
428	}
429	_ => Err(self.error(ErrorCode::InvalidNumber)),
430	}
431	}
432
433	#[cold]
434	fn fix_position(&self, err: Error) -> Error {
435	err.fix_position(move \|code\| self.error(code))
436	}
437
438	fn parse_ident(&mut self, ident: &[u8]) -> Result<()> {
439	for expected in ident {
440	match tri!(self.next_char()) {
441	None => {
442	return Err(self.error(ErrorCode::EofWhileParsingValue));
443	}
444	Some(next) => {
445	if next != *expected {
446	return Err(self.error(ErrorCode::ExpectedSomeIdent));
447	}
448	}
449	}
450	}
451
452	Ok(())
453	}
454
455	fn parse_integer(&mut self, positive: bool) -> Result<ParserNumber> {
456	let next = match tri!(self.next_char()) {
457	Some(b) => b,
458	None => {
459	return Err(self.error(ErrorCode::EofWhileParsingValue));
460	}
461	};
462
463	match next {
464	b'0' => {
465	// There can be only one leading '0'.
466	match tri!(self.peek_or_null()) {
467	b'0'..=b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)),
468	_ => self.parse_number(positive, `0`),
469	}
470	}
471	c @ b'1'..=b'9' => {
472	let mut significand = (c - b'0') as u64;
473
474	loop {
475	match tri!(self.peek_or_null()) {
476	c @ b'0'..=b'9' => {
477	let digit = (c - b'0') as u64;
478
479	// We need to be careful with overflow. If we can,
480	// try to keep the number as a `u64` until we grow
481	// too large. At that point, switch to parsing the
482	// value as a `f64`.
483	if overflow!(significand * `10` + digit, u64::max_value()) {
484	return Ok(ParserNumber::F64(tri!(
485	self.parse_long_integer(positive, significand),
486	)));
487	}
488
489	self.eat_char();
490	significand = significand * `10` + digit;
491	}
492	_ => {
493	return self.parse_number(positive, significand);
494	}
495	}
496	}
497	}
498	_ => Err(self.error(ErrorCode::InvalidNumber)),
499	}
500	}
501
502	fn parse_number(&mut self, positive: bool, significand: u64) -> Result<ParserNumber> {
503	Ok(match tri!(self.peek_or_null()) {
504	b'.' => ParserNumber::F64(tri!(self.parse_decimal(positive, significand, `0`))),
505	b'e' \| b'E' => ParserNumber::F64(tri!(self.parse_exponent(positive, significand, `0`))),
506	_ => {
507	if positive {
508	ParserNumber::U64(significand)
509	} else {
510	let neg = (significand as i64).wrapping_neg();
511
512	// Convert into a float if we underflow, or on `-0`.
513	if neg >= `0` {
514	ParserNumber::F64(-(significand as f64))
515	} else {
516	ParserNumber::I64(neg)
517	}
518	}
519	}
520	})
521	}
522
523	fn parse_decimal(
524	&mut self,
525	positive: bool,
526	mut significand: u64,
527	exponent_before_decimal_point: i32,
528	) -> Result<f64> {
529	self.eat_char();
530
531	let mut exponent_after_decimal_point = `0`;
532	while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
533	let digit = (c - b'0') as u64;
534
535	if overflow!(significand * `10` + digit, u64::max_value()) {
536	let exponent = exponent_before_decimal_point + exponent_after_decimal_point;
537	return self.parse_decimal_overflow(positive, significand, exponent);
538	}
539
540	self.eat_char();
541	significand = significand * `10` + digit;
542	exponent_after_decimal_point -= `1`;
543	}
544
545	// Error if there is not at least one digit after the decimal point.
546	if exponent_after_decimal_point == `0` {
547	match tri!(self.peek()) {
548	Some(_) => return Err(self.peek_error(ErrorCode::InvalidNumber)),
549	None => return Err(self.peek_error(ErrorCode::EofWhileParsingValue)),
550	}
551	}
552
553	let exponent = exponent_before_decimal_point + exponent_after_decimal_point;
554	match tri!(self.peek_or_null()) {
555	b'e' \| b'E' => self.parse_exponent(positive, significand, exponent),
556	_ => self.f64_from_parts(positive, significand, exponent),
557	}
558	}
559
560	fn parse_exponent(
561	&mut self,
562	positive: bool,
563	significand: u64,
564	starting_exp: i32,
565	) -> Result<f64> {
566	self.eat_char();
567
568	let positive_exp = match tri!(self.peek_or_null()) {
569	b'+' => {
570	self.eat_char();
571	`true`
572	}
573	b'-' => {
574	self.eat_char();
575	`false`
576	}
577	_ => `true`,
578	};
579
580	let next = match tri!(self.next_char()) {
581	Some(b) => b,
582	None => {
583	return Err(self.error(ErrorCode::EofWhileParsingValue));
584	}
585	};
586
587	// Make sure a digit follows the exponent place.
588	let mut exp = match next {
589	c @ b'0'..=b'9' => (c - b'0') as i32,
590	_ => {
591	return Err(self.error(ErrorCode::InvalidNumber));
592	}
593	};
594
595	while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
596	self.eat_char();
597	let digit = (c - b'0') as i32;
598
599	if overflow!(exp * `10` + digit, i32::max_value()) {
600	let zero_significand = significand == `0`;
601	return self.parse_exponent_overflow(positive, zero_significand, positive_exp);
602	}
603
604	exp = exp * `10` + digit;
605	}
606
607	let final_exp = if positive_exp {
608	starting_exp.saturating_add(exp)
609	} else {
610	starting_exp.saturating_sub(exp)
611	};
612
613	self.f64_from_parts(positive, significand, final_exp)
614	}
615
616	#[cfg(feature = "float_roundtrip")]
617	fn f64_from_parts(&mut self, positive: bool, significand: u64, exponent: i32) -> Result<f64> {
618	let f = if self.single_precision {
619	lexical::parse_concise_float::<f32>(significand, exponent) as f64
620	} else {
621	lexical::parse_concise_float::<f64>(significand, exponent)
622	};
623
624	if f.is_infinite() {
625	Err(self.error(ErrorCode::NumberOutOfRange))
626	} else {
627	Ok(if positive { f } else { -f })
628	}
629	}
630
631	#[cfg(not(feature = "float_roundtrip"))]
632	fn f64_from_parts(
633	&mut self,
634	positive: bool,
635	significand: u64,
636	mut exponent: i32,
637	) -> Result<f64> {
638	let mut f = significand as f64;
639	loop {
640	match POW10.get(exponent.wrapping_abs() as usize) {
641	Some(&pow) => {
642	if exponent >= `0` {
643	f *= pow;
644	if f.is_infinite() {
645	return Err(self.error(ErrorCode::NumberOutOfRange));
646	}
647	} else {
648	f /= pow;
649	}
650	break;
651	}
652	None => {
653	if f == `0.0` {
654	break;
655	}
656	if exponent >= `0` {
657	return Err(self.error(ErrorCode::NumberOutOfRange));
658	}
659	f /= `1e308`;
660	exponent += `308`;
661	}
662	}
663	}
664	Ok(if positive { f } else { -f })
665	}
666
667	#[cfg(feature = "float_roundtrip")]
668	#[cold]
669	#[inline(never)]
670	fn parse_long_integer(&mut self, positive: bool, partial_significand: u64) -> Result<f64> {
671	// To deserialize floats we'll first push the integer and fraction
672	// parts, both as byte strings, into the scratch buffer and then feed
673	// both slices to lexical's parser. For example if the input is
674	// `12.34e5` we'll push b"1234" into scratch and then pass b"12" and
675	// b"34" to lexical. `integer_end` will be used to track where to split
676	// the scratch buffer.
677	//
678	// Note that lexical expects the integer part to contain no* leading*
679	// zeroes and the fraction part to contain no* trailing zeroes. The*
680	// first requirement is already handled by the integer parsing logic.
681	// The second requirement will be enforced just before passing the
682	// slices to lexical in f64_long_from_parts.
683	self.scratch.clear();
684	self.scratch
685	.extend_from_slice(itoa::Buffer::new().format(partial_significand).as_bytes());
686
687	loop {
688	match tri!(self.peek_or_null()) {
689	c @ b'0'..=b'9' => {
690	self.scratch.push(c);
691	self.eat_char();
692	}
693	b'.' => {
694	self.eat_char();
695	return self.parse_long_decimal(positive, self.scratch.len());
696	}
697	b'e' \| b'E' => {
698	return self.parse_long_exponent(positive, self.scratch.len());
699	}
700	_ => {
701	return self.f64_long_from_parts(positive, self.scratch.len(), `0`);
702	}
703	}
704	}
705	}
706
707	#[cfg(not(feature = "float_roundtrip"))]
708	#[cold]
709	#[inline(never)]
710	fn parse_long_integer(&mut self, positive: bool, significand: u64) -> Result<f64> {
711	let mut exponent = `0`;
712	loop {
713	match tri!(self.peek_or_null()) {
714	b'0'..=b'9' => {
715	self.eat_char();
716	// This could overflow... if your integer is gigabytes long.
717	// Ignore that possibility.
718	exponent += `1`;
719	}
720	b'.' => {
721	return self.parse_decimal(positive, significand, exponent);
722	}
723	b'e' \| b'E' => {
724	return self.parse_exponent(positive, significand, exponent);
725	}
726	_ => {
727	return self.f64_from_parts(positive, significand, exponent);
728	}
729	}
730	}
731	}
732
733	#[cfg(feature = "float_roundtrip")]
734	#[cold]
735	fn parse_long_decimal(&mut self, positive: bool, integer_end: usize) -> Result<f64> {
736	let mut at_least_one_digit = integer_end < self.scratch.len();
737	while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
738	self.scratch.push(c);
739	self.eat_char();
740	at_least_one_digit = `true`;
741	}
742
743	if !at_least_one_digit {
744	match tri!(self.peek()) {
745	Some(_) => return Err(self.peek_error(ErrorCode::InvalidNumber)),
746	None => return Err(self.peek_error(ErrorCode::EofWhileParsingValue)),
747	}
748	}
749
750	match tri!(self.peek_or_null()) {
751	b'e' \| b'E' => self.parse_long_exponent(positive, integer_end),
752	_ => self.f64_long_from_parts(positive, integer_end, `0`),
753	}
754	}
755
756	#[cfg(feature = "float_roundtrip")]
757	fn parse_long_exponent(&mut self, positive: bool, integer_end: usize) -> Result<f64> {
758	self.eat_char();
759
760	let positive_exp = match tri!(self.peek_or_null()) {
761	b'+' => {
762	self.eat_char();
763	`true`
764	}
765	b'-' => {
766	self.eat_char();
767	`false`
768	}
769	_ => `true`,
770	};
771
772	let next = match tri!(self.next_char()) {
773	Some(b) => b,
774	None => {
775	return Err(self.error(ErrorCode::EofWhileParsingValue));
776	}
777	};
778
779	// Make sure a digit follows the exponent place.
780	let mut exp = match next {
781	c @ b'0'..=b'9' => (c - b'0') as i32,
782	_ => {
783	return Err(self.error(ErrorCode::InvalidNumber));
784	}
785	};
786
787	while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
788	self.eat_char();
789	let digit = (c - b'0') as i32;
790
791	if overflow!(exp * `10` + digit, i32::max_value()) {
792	let zero_significand = self.scratch.iter().all(\|&digit\| digit == b'0');
793	return self.parse_exponent_overflow(positive, zero_significand, positive_exp);
794	}
795
796	exp = exp * `10` + digit;
797	}
798
799	let final_exp = if positive_exp { exp } else { -exp };
800
801	self.f64_long_from_parts(positive, integer_end, final_exp)
802	}
803
804	// This cold code should not be inlined into the middle of the hot
805	// decimal-parsing loop above.
806	#[cfg(feature = "float_roundtrip")]
807	#[cold]
808	#[inline(never)]
809	fn parse_decimal_overflow(
810	&mut self,
811	positive: bool,
812	significand: u64,
813	exponent: i32,
814	) -> Result<f64> {
815	let mut buffer = itoa::Buffer::new();
816	let significand = buffer.format(significand);
817	let fraction_digits = -exponent as usize;
818	self.scratch.clear();
819	if let Some(zeros) = fraction_digits.checked_sub(significand.len() + `1`) {
820	self.scratch.extend(iter::repeat(b'0').take(zeros + `1`));
821	}
822	self.scratch.extend_from_slice(significand.as_bytes());
823	let integer_end = self.scratch.len() - fraction_digits;
824	self.parse_long_decimal(positive, integer_end)
825	}
826
827	#[cfg(not(feature = "float_roundtrip"))]
828	#[cold]
829	#[inline(never)]
830	fn parse_decimal_overflow(
831	&mut self,
832	positive: bool,
833	significand: u64,
834	exponent: i32,
835	) -> Result<f64> {
836	// The next multiply/add would overflow, so just ignore all further
837	// digits.
838	while let b'0'..=b'9' = tri!(self.peek_or_null()) {
839	self.eat_char();
840	}
841
842	match tri!(self.peek_or_null()) {
843	b'e' \| b'E' => self.parse_exponent(positive, significand, exponent),
844	_ => self.f64_from_parts(positive, significand, exponent),
845	}
846	}
847
848	// This cold code should not be inlined into the middle of the hot
849	// exponent-parsing loop above.
850	#[cold]
851	#[inline(never)]
852	fn parse_exponent_overflow(
853	&mut self,
854	positive: bool,
855	zero_significand: bool,
856	positive_exp: bool,
857	) -> Result<f64> {
858	// Error instead of +/- infinity.
859	if !zero_significand && positive_exp {
860	return Err(self.error(ErrorCode::NumberOutOfRange));
861	}
862
863	while let b'0'..=b'9' = tri!(self.peek_or_null()) {
864	self.eat_char();
865	}
866	Ok(if positive { `0.0` } else { `-0.0` })
867	}
868
869	#[cfg(feature = "float_roundtrip")]
870	fn f64_long_from_parts(
871	&mut self,
872	positive: bool,
873	integer_end: usize,
874	exponent: i32,
875	) -> Result<f64> {
876	let integer = &self.scratch[..integer_end];
877	let fraction = &self.scratch[integer_end..];
878
879	let f = if self.single_precision {
880	lexical::parse_truncated_float::<f32>(integer, fraction, exponent) as f64
881	} else {
882	lexical::parse_truncated_float::<f64>(integer, fraction, exponent)
883	};
884
885	if f.is_infinite() {
886	Err(self.error(ErrorCode::NumberOutOfRange))
887	} else {
888	Ok(if positive { f } else { -f })
889	}
890	}
891
892	fn parse_any_signed_number(&mut self) -> Result<ParserNumber> {
893	let peek = match tri!(self.peek()) {
894	Some(b) => b,
895	None => {
896	return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
897	}
898	};
899
900	let value = match peek {
901	b'-' => {
902	self.eat_char();
903	self.parse_any_number(`false`)
904	}
905	b'0'..=b'9' => self.parse_any_number(`true`),
906	_ => Err(self.peek_error(ErrorCode::InvalidNumber)),
907	};
908
909	let value = match tri!(self.peek()) {
910	Some(_) => Err(self.peek_error(ErrorCode::InvalidNumber)),
911	None => value,
912	};
913
914	match value {
915	Ok(value) => Ok(value),
916	// The de::Error impl creates errors with unknown line and column.
917	// Fill in the position here by looking at the current index in the
918	// input. There is no way to tell whether this should call `error`
919	// or `peek_error` so pick the one that seems correct more often.
920	// Worst case, the position is off by one character.
921	Err(err) => Err(self.fix_position(err)),
922	}
923	}
924
925	#[cfg(not(feature = "arbitrary_precision"))]
926	fn parse_any_number(&mut self, positive: bool) -> Result<ParserNumber> {
927	self.parse_integer(positive)
928	}
929
930	#[cfg(feature = "arbitrary_precision")]
931	fn parse_any_number(&mut self, positive: bool) -> Result<ParserNumber> {
932	let mut buf = String::with_capacity(`16`);
933	if !positive {
934	buf.push('-');
935	}
936	tri!(self.scan_integer(&mut buf));
937	if positive {
938	if let Ok(unsigned) = buf.parse() {
939	return Ok(ParserNumber::U64(unsigned));
940	}
941	} else {
942	if let Ok(signed) = buf.parse() {
943	return Ok(ParserNumber::I64(signed));
944	}
945	}
946	Ok(ParserNumber::String(buf))
947	}
948
949	#[cfg(feature = "arbitrary_precision")]
950	fn scan_or_eof(&mut self, buf: &mut String) -> Result<u8> {
951	match tri!(self.next_char()) {
952	Some(b) => {
953	buf.push(b as char);
954	Ok(b)
955	}
956	None => Err(self.error(ErrorCode::EofWhileParsingValue)),
957	}
958	}
959
960	#[cfg(feature = "arbitrary_precision")]
961	fn scan_integer(&mut self, buf: &mut String) -> Result<()> {
962	match tri!(self.scan_or_eof(buf)) {
963	b'0' => {
964	// There can be only one leading '0'.
965	match tri!(self.peek_or_null()) {
966	b'0'..=b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)),
967	_ => self.scan_number(buf),
968	}
969	}
970	b'1'..=b'9' => loop {
971	match tri!(self.peek_or_null()) {
972	c @ b'0'..=b'9' => {
973	self.eat_char();
974	buf.push(c as char);
975	}
976	_ => {
977	return self.scan_number(buf);
978	}
979	}
980	},
981	_ => Err(self.error(ErrorCode::InvalidNumber)),
982	}
983	}
984
985	#[cfg(feature = "arbitrary_precision")]
986	fn scan_number(&mut self, buf: &mut String) -> Result<()> {
987	match tri!(self.peek_or_null()) {
988	b'.' => self.scan_decimal(buf),
989	e @ (b'e' \| b'E') => self.scan_exponent(e as char, buf),
990	_ => Ok(()),
991	}
992	}
993
994	#[cfg(feature = "arbitrary_precision")]
995	fn scan_decimal(&mut self, buf: &mut String) -> Result<()> {
996	self.eat_char();
997	buf.push('.');
998
999	let mut at_least_one_digit = `false`;
1000	while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
1001	self.eat_char();
1002	buf.push(c as char);
1003	at_least_one_digit = `true`;
1004	}
1005
1006	if !at_least_one_digit {
1007	match tri!(self.peek()) {
1008	Some(_) => return Err(self.peek_error(ErrorCode::InvalidNumber)),
1009	None => return Err(self.peek_error(ErrorCode::EofWhileParsingValue)),
1010	}
1011	}
1012
1013	match tri!(self.peek_or_null()) {
1014	e @ (b'e' \| b'E') => self.scan_exponent(e as char, buf),
1015	_ => Ok(()),
1016	}
1017	}
1018
1019	#[cfg(feature = "arbitrary_precision")]
1020	fn scan_exponent(&mut self, e: char, buf: &mut String) -> Result<()> {
1021	self.eat_char();
1022	buf.push(e);
1023
1024	match tri!(self.peek_or_null()) {
1025	b'+' => {
1026	self.eat_char();
1027	buf.push('+');
1028	}
1029	b'-' => {
1030	self.eat_char();
1031	buf.push('-');
1032	}
1033	_ => {}
1034	}
1035
1036	// Make sure a digit follows the exponent place.
1037	match tri!(self.scan_or_eof(buf)) {
1038	b'0'..=b'9' => {}
1039	_ => {
1040	return Err(self.error(ErrorCode::InvalidNumber));
1041	}
1042	}
1043
1044	while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
1045	self.eat_char();
1046	buf.push(c as char);
1047	}
1048
1049	Ok(())
1050	}
1051
1052	fn parse_object_colon(&mut self) -> Result<()> {
1053	match tri!(self.parse_whitespace()) {
1054	Some(b':') => {
1055	self.eat_char();
1056	Ok(())
1057	}
1058	Some(_) => Err(self.peek_error(ErrorCode::ExpectedColon)),
1059	None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
1060	}
1061	}
1062
1063	fn end_seq(&mut self) -> Result<()> {
1064	match tri!(self.parse_whitespace()) {
1065	Some(b']') => {
1066	self.eat_char();
1067	Ok(())
1068	}
1069	Some(b',') => {
1070	self.eat_char();
1071	match self.parse_whitespace() {
1072	Ok(Some(b']')) => Err(self.peek_error(ErrorCode::TrailingComma)),
1073	_ => Err(self.peek_error(ErrorCode::TrailingCharacters)),
1074	}
1075	}
1076	Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)),
1077	None => Err(self.peek_error(ErrorCode::EofWhileParsingList)),
1078	}
1079	}
1080
1081	fn end_map(&mut self) -> Result<()> {
1082	match tri!(self.parse_whitespace()) {
1083	Some(b'}') => {
1084	self.eat_char();
1085	Ok(())
1086	}
1087	Some(b',') => Err(self.peek_error(ErrorCode::TrailingComma)),
1088	Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)),
1089	None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
1090	}
1091	}
1092
1093	fn ignore_value(&mut self) -> Result<()> {
1094	self.scratch.clear();
1095	let mut enclosing = None;
1096
1097	loop {
1098	let peek = match tri!(self.parse_whitespace()) {
1099	Some(b) => b,
1100	None => {
1101	return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1102	}
1103	};
1104
1105	let frame = match peek {
1106	b'n' => {
1107	self.eat_char();
1108	tri!(self.parse_ident(b"ull"));
1109	None
1110	}
1111	b't' => {
1112	self.eat_char();
1113	tri!(self.parse_ident(b"rue"));
1114	None
1115	}
1116	b'f' => {
1117	self.eat_char();
1118	tri!(self.parse_ident(b"alse"));
1119	None
1120	}
1121	b'-' => {
1122	self.eat_char();
1123	tri!(self.ignore_integer());
1124	None
1125	}
1126	b'0'..=b'9' => {
1127	tri!(self.ignore_integer());
1128	None
1129	}
1130	b'"' => {
1131	self.eat_char();
1132	tri!(self.read.ignore_str());
1133	None
1134	}
1135	frame @ (b'[' \| b'{') => {
1136	self.scratch.extend(enclosing.take());
1137	self.eat_char();
1138	Some(frame)
1139	}
1140	_ => return Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
1141	};
1142
1143	let (mut accept_comma, mut frame) = match frame {
1144	Some(frame) => (`false`, frame),
1145	None => match enclosing.take() {
1146	Some(frame) => (`true`, frame),
1147	None => match self.scratch.pop() {
1148	Some(frame) => (`true`, frame),
1149	None => return Ok(()),
1150	},
1151	},
1152	};
1153
1154	loop {
1155	match tri!(self.parse_whitespace()) {
1156	Some(b',') if accept_comma => {
1157	self.eat_char();
1158	break;
1159	}
1160	Some(b']') if frame == b'[' => {}
1161	Some(b'}') if frame == b'{' => {}
1162	Some(_) => {
1163	if accept_comma {
1164	return Err(self.peek_error(match frame {
1165	b'[' => ErrorCode::ExpectedListCommaOrEnd,
1166	b'{' => ErrorCode::ExpectedObjectCommaOrEnd,
1167	_ => unreachable!(),
1168	}));
1169	} else {
1170	break;
1171	}
1172	}
1173	None => {
1174	return Err(self.peek_error(match frame {
1175	b'[' => ErrorCode::EofWhileParsingList,
1176	b'{' => ErrorCode::EofWhileParsingObject,
1177	_ => unreachable!(),
1178	}));
1179	}
1180	}
1181
1182	self.eat_char();
1183	frame = match self.scratch.pop() {
1184	Some(frame) => frame,
1185	None => return Ok(()),
1186	};
1187	accept_comma = `true`;
1188	}
1189
1190	if frame == b'{' {
1191	match tri!(self.parse_whitespace()) {
1192	Some(b'"') => self.eat_char(),
1193	Some(_) => return Err(self.peek_error(ErrorCode::KeyMustBeAString)),
1194	None => return Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
1195	}
1196	tri!(self.read.ignore_str());
1197	match tri!(self.parse_whitespace()) {
1198	Some(b':') => self.eat_char(),
1199	Some(_) => return Err(self.peek_error(ErrorCode::ExpectedColon)),
1200	None => return Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
1201	}
1202	}
1203
1204	enclosing = Some(frame);
1205	}
1206	}
1207
1208	fn ignore_integer(&mut self) -> Result<()> {
1209	match tri!(self.next_char_or_null()) {
1210	b'0' => {
1211	// There can be only one leading '0'.
1212	if let b'0'..=b'9' = tri!(self.peek_or_null()) {
1213	return Err(self.peek_error(ErrorCode::InvalidNumber));
1214	}
1215	}
1216	b'1'..=b'9' => {
1217	while let b'0'..=b'9' = tri!(self.peek_or_null()) {
1218	self.eat_char();
1219	}
1220	}
1221	_ => {
1222	return Err(self.error(ErrorCode::InvalidNumber));
1223	}
1224	}
1225
1226	match tri!(self.peek_or_null()) {
1227	b'.' => self.ignore_decimal(),
1228	b'e' \| b'E' => self.ignore_exponent(),
1229	_ => Ok(()),
1230	}
1231	}
1232
1233	fn ignore_decimal(&mut self) -> Result<()> {
1234	self.eat_char();
1235
1236	let mut at_least_one_digit = `false`;
1237	while let b'0'..=b'9' = tri!(self.peek_or_null()) {
1238	self.eat_char();
1239	at_least_one_digit = `true`;
1240	}
1241
1242	if !at_least_one_digit {
1243	return Err(self.peek_error(ErrorCode::InvalidNumber));
1244	}
1245
1246	match tri!(self.peek_or_null()) {
1247	b'e' \| b'E' => self.ignore_exponent(),
1248	_ => Ok(()),
1249	}
1250	}
1251
1252	fn ignore_exponent(&mut self) -> Result<()> {
1253	self.eat_char();
1254
1255	match tri!(self.peek_or_null()) {
1256	b'+' \| b'-' => self.eat_char(),
1257	_ => {}
1258	}
1259
1260	// Make sure a digit follows the exponent place.
1261	match tri!(self.next_char_or_null()) {
1262	b'0'..=b'9' => {}
1263	_ => {
1264	return Err(self.error(ErrorCode::InvalidNumber));
1265	}
1266	}
1267
1268	while let b'0'..=b'9' = tri!(self.peek_or_null()) {
1269	self.eat_char();
1270	}
1271
1272	Ok(())
1273	}
1274
1275	#[cfg(feature = "raw_value")]
1276	fn deserialize_raw_value<V>(&mut self, visitor: V) -> Result<V::Value>
1277	where
1278	V: de::Visitor<'de>,
1279	{
1280	tri!(self.parse_whitespace());
1281	self.read.begin_raw_buffering();
1282	tri!(self.ignore_value());
1283	self.read.end_raw_buffering(visitor)
1284	}
1285	}
1286
1287	impl FromStr for Number {
1288	type Err = Error;
1289
1290	fn from_str(s: &str) -> result::Result<Self, Self::Err> {
1291	Deserializer::from_str(s)
1292	.parse_any_signed_number()
1293	.map(Into::into)
1294	}
1295	}
1296
1297	#[cfg(not(feature = "float_roundtrip"))]
1298	static POW10: [f64; `309`] = [
1299	`1e000`, `1e001`, `1e002`, `1e003`, `1e004`, `1e005`, `1e006`, `1e007`, `1e008`, `1e009`, //
1300	`1e010`, `1e011`, `1e012`, `1e013`, `1e014`, `1e015`, `1e016`, `1e017`, `1e018`, `1e019`, //
1301	`1e020`, `1e021`, `1e022`, `1e023`, `1e024`, `1e025`, `1e026`, `1e027`, `1e028`, `1e029`, //
1302	`1e030`, `1e031`, `1e032`, `1e033`, `1e034`, `1e035`, `1e036`, `1e037`, `1e038`, `1e039`, //
1303	`1e040`, `1e041`, `1e042`, `1e043`, `1e044`, `1e045`, `1e046`, `1e047`, `1e048`, `1e049`, //
1304	`1e050`, `1e051`, `1e052`, `1e053`, `1e054`, `1e055`, `1e056`, `1e057`, `1e058`, `1e059`, //
1305	`1e060`, `1e061`, `1e062`, `1e063`, `1e064`, `1e065`, `1e066`, `1e067`, `1e068`, `1e069`, //
1306	`1e070`, `1e071`, `1e072`, `1e073`, `1e074`, `1e075`, `1e076`, `1e077`, `1e078`, `1e079`, //
1307	`1e080`, `1e081`, `1e082`, `1e083`, `1e084`, `1e085`, `1e086`, `1e087`, `1e088`, `1e089`, //
1308	`1e090`, `1e091`, `1e092`, `1e093`, `1e094`, `1e095`, `1e096`, `1e097`, `1e098`, `1e099`, //
1309	`1e100`, `1e101`, `1e102`, `1e103`, `1e104`, `1e105`, `1e106`, `1e107`, `1e108`, `1e109`, //
1310	`1e110`, `1e111`, `1e112`, `1e113`, `1e114`, `1e115`, `1e116`, `1e117`, `1e118`, `1e119`, //
1311	`1e120`, `1e121`, `1e122`, `1e123`, `1e124`, `1e125`, `1e126`, `1e127`, `1e128`, `1e129`, //
1312	`1e130`, `1e131`, `1e132`, `1e133`, `1e134`, `1e135`, `1e136`, `1e137`, `1e138`, `1e139`, //
1313	`1e140`, `1e141`, `1e142`, `1e143`, `1e144`, `1e145`, `1e146`, `1e147`, `1e148`, `1e149`, //
1314	`1e150`, `1e151`, `1e152`, `1e153`, `1e154`, `1e155`, `1e156`, `1e157`, `1e158`, `1e159`, //
1315	`1e160`, `1e161`, `1e162`, `1e163`, `1e164`, `1e165`, `1e166`, `1e167`, `1e168`, `1e169`, //
1316	`1e170`, `1e171`, `1e172`, `1e173`, `1e174`, `1e175`, `1e176`, `1e177`, `1e178`, `1e179`, //
1317	`1e180`, `1e181`, `1e182`, `1e183`, `1e184`, `1e185`, `1e186`, `1e187`, `1e188`, `1e189`, //
1318	`1e190`, `1e191`, `1e192`, `1e193`, `1e194`, `1e195`, `1e196`, `1e197`, `1e198`, `1e199`, //
1319	`1e200`, `1e201`, `1e202`, `1e203`, `1e204`, `1e205`, `1e206`, `1e207`, `1e208`, `1e209`, //
1320	`1e210`, `1e211`, `1e212`, `1e213`, `1e214`, `1e215`, `1e216`, `1e217`, `1e218`, `1e219`, //
1321	`1e220`, `1e221`, `1e222`, `1e223`, `1e224`, `1e225`, `1e226`, `1e227`, `1e228`, `1e229`, //
1322	`1e230`, `1e231`, `1e232`, `1e233`, `1e234`, `1e235`, `1e236`, `1e237`, `1e238`, `1e239`, //
1323	`1e240`, `1e241`, `1e242`, `1e243`, `1e244`, `1e245`, `1e246`, `1e247`, `1e248`, `1e249`, //
1324	`1e250`, `1e251`, `1e252`, `1e253`, `1e254`, `1e255`, `1e256`, `1e257`, `1e258`, `1e259`, //
1325	`1e260`, `1e261`, `1e262`, `1e263`, `1e264`, `1e265`, `1e266`, `1e267`, `1e268`, `1e269`, //
1326	`1e270`, `1e271`, `1e272`, `1e273`, `1e274`, `1e275`, `1e276`, `1e277`, `1e278`, `1e279`, //
1327	`1e280`, `1e281`, `1e282`, `1e283`, `1e284`, `1e285`, `1e286`, `1e287`, `1e288`, `1e289`, //
1328	`1e290`, `1e291`, `1e292`, `1e293`, `1e294`, `1e295`, `1e296`, `1e297`, `1e298`, `1e299`, //
1329	`1e300`, `1e301`, `1e302`, `1e303`, `1e304`, `1e305`, `1e306`, `1e307`, `1e308`,
1330	];
1331
1332	macro_rules! deserialize_number {
1333	($method:ident) => {
1334	deserialize_number!($method, deserialize_number);
1335	};
1336
1337	($method:ident, $using:ident) => {
1338	fn $method<V>(self, visitor: V) -> Result<V::Value>
1339	where
1340	V: de::Visitor<'de>,
1341	{
1342	self.$using(visitor)
1343	}
1344	};
1345	}
1346
1347	#[cfg(not(feature = "unbounded_depth"))]
1348	macro_rules! if_checking_recursion_limit {
1349	($($body:tt)*) => {
1350	$($body)*
1351	};
1352	}
1353
1354	#[cfg(feature = "unbounded_depth")]
1355	macro_rules! if_checking_recursion_limit {
1356	($this:ident $($body:tt)*) => {
1357	if !$this.disable_recursion_limit {
1358	$this $($body)*
1359	}
1360	};
1361	}
1362
1363	macro_rules! check_recursion {
1364	($this:ident $($body:tt)*) => {
1365	if_checking_recursion_limit! {
1366	$this.remaining_depth -= `1`;
1367	if $this.remaining_depth == `0` {
1368	return Err($this.peek_error(ErrorCode::RecursionLimitExceeded));
1369	}
1370	}
1371
1372	$this $($body)*
1373
1374	if_checking_recursion_limit! {
1375	$this.remaining_depth += `1`;
1376	}
1377	};
1378	}
1379
1380	impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
1381	type Error = Error;
1382
1383	#[inline]
1384	fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
1385	where
1386	V: de::Visitor<'de>,
1387	{
1388	let peek = match tri!(self.parse_whitespace()) {
1389	Some(b) => b,
1390	None => {
1391	return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1392	}
1393	};
1394
1395	let value = match peek {
1396	b'n' => {
1397	self.eat_char();
1398	tri!(self.parse_ident(b"ull"));
1399	visitor.visit_unit()
1400	}
1401	b't' => {
1402	self.eat_char();
1403	tri!(self.parse_ident(b"rue"));
1404	visitor.visit_bool(`true`)
1405	}
1406	b'f' => {
1407	self.eat_char();
1408	tri!(self.parse_ident(b"alse"));
1409	visitor.visit_bool(`false`)
1410	}
1411	b'-' => {
1412	self.eat_char();
1413	tri!(self.parse_any_number(`false`)).visit(visitor)
1414	}
1415	b'0'..=b'9' => tri!(self.parse_any_number(`true`)).visit(visitor),
1416	b'"' => {
1417	self.eat_char();
1418	self.scratch.clear();
1419	match tri!(self.read.parse_str(&mut self.scratch)) {
1420	Reference::Borrowed(s) => visitor.visit_borrowed_str(s),
1421	Reference::Copied(s) => visitor.visit_str(s),
1422	}
1423	}
1424	b'[' => {
1425	check_recursion! {
1426	self.eat_char();
1427	let ret = visitor.visit_seq(SeqAccess::new(self));
1428	}
1429
1430	match (ret, self.end_seq()) {
1431	(Ok(ret), Ok(())) => Ok(ret),
1432	(Err(err), _) \| (_, Err(err)) => Err(err),
1433	}
1434	}
1435	b'{' => {
1436	check_recursion! {
1437	self.eat_char();
1438	let ret = visitor.visit_map(MapAccess::new(self));
1439	}
1440
1441	match (ret, self.end_map()) {
1442	(Ok(ret), Ok(())) => Ok(ret),
1443	(Err(err), _) \| (_, Err(err)) => Err(err),
1444	}
1445	}
1446	_ => Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
1447	};
1448
1449	match value {
1450	Ok(value) => Ok(value),
1451	// The de::Error impl creates errors with unknown line and column.
1452	// Fill in the position here by looking at the current index in the
1453	// input. There is no way to tell whether this should call `error`
1454	// or `peek_error` so pick the one that seems correct more often.
1455	// Worst case, the position is off by one character.
1456	Err(err) => Err(self.fix_position(err)),
1457	}
1458	}
1459
1460	fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
1461	where
1462	V: de::Visitor<'de>,
1463	{
1464	let peek = match tri!(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't' => {
1473	self.eat_char();
1474	tri!(self.parse_ident(b"rue"));
1475	visitor.visit_bool(`true`)
1476	}
1477	b'f' => {
1478	self.eat_char();
1479	tri!(self.parse_ident(b"alse"));
1480	visitor.visit_bool(`false`)
1481	}
1482	_ => Err(self.peek_invalid_type(&visitor)),
1483	};
1484
1485	match value {
1486	Ok(value) => Ok(value),
1487	Err(err) => Err(self.fix_position(err)),
1488	}
1489	}
1490
1491	deserialize_number!(deserialize_i8);
1492	deserialize_number!(deserialize_i16);
1493	deserialize_number!(deserialize_i32);
1494	deserialize_number!(deserialize_i64);
1495	deserialize_number!(deserialize_u8);
1496	deserialize_number!(deserialize_u16);
1497	deserialize_number!(deserialize_u32);
1498	deserialize_number!(deserialize_u64);
1499	#[cfg(not(feature = "float_roundtrip"))]
1500	deserialize_number!(deserialize_f32);
1501	deserialize_number!(deserialize_f64);
1502
1503	#[cfg(feature = "float_roundtrip")]
1504	deserialize_number!(deserialize_f32, do_deserialize_f32);
1505	deserialize_number!(deserialize_i128, do_deserialize_i128);
1506	deserialize_number!(deserialize_u128, do_deserialize_u128);
1507
1508	fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
1509	where
1510	V: de::Visitor<'de>,
1511	{
1512	self.deserialize_str(visitor)
1513	}
1514
1515	fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
1516	where
1517	V: de::Visitor<'de>,
1518	{
1519	let peek = match tri!(self.parse_whitespace()) {
1520	Some(b) => b,
1521	None => {
1522	return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1523	}
1524	};
1525
1526	let value = match peek {
1527	b'"' => {
1528	self.eat_char();
1529	self.scratch.clear();
1530	match tri!(self.read.parse_str(&mut self.scratch)) {
1531	Reference::Borrowed(s) => visitor.visit_borrowed_str(s),
1532	Reference::Copied(s) => visitor.visit_str(s),
1533	}
1534	}
1535	_ => Err(self.peek_invalid_type(&visitor)),
1536	};
1537
1538	match value {
1539	Ok(value) => Ok(value),
1540	Err(err) => Err(self.fix_position(err)),
1541	}
1542	}
1543
1544	fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
1545	where
1546	V: de::Visitor<'de>,
1547	{
1548	self.deserialize_str(visitor)
1549	}
1550
1551	/// Parses a JSON string as bytes. Note that this function does not check
1552	/// whether the bytes represent a valid UTF-8 string.
1553	///
1554	/// The relevant part of the JSON specification is Section 8.2 of [RFC
1555	/// 7159]:
1556	///
1557	/// > When all the strings represented in a JSON text are composed entirely
1558	/// > of Unicode characters (however escaped), then that JSON text is
1559	/// > interoperable in the sense that all software implementations that
1560	/// > parse it will agree on the contents of names and of string values in
1561	/// > objects and arrays.
1562	/// >
1563	/// > However, the ABNF in this specification allows member names and string
1564	/// > values to contain bit sequences that cannot encode Unicode characters;
1565	/// > for example, "\uDEAD" (a single unpaired UTF-16 surrogate). Instances
1566	/// > of this have been observed, for example, when a library truncates a
1567	/// > UTF-16 string without checking whether the truncation split a
1568	/// > surrogate pair. The behavior of software that receives JSON texts
1569	/// > containing such values is unpredictable; for example, implementations
1570	/// > might return different values for the length of a string value or even
1571	/// > suffer fatal runtime exceptions.
1572	///
1573	/// [RFC 7159]: https://tools.ietf.org/html/rfc7159
1574	///
1575	/// The behavior of serde_json is specified to fail on non-UTF-8 strings
1576	/// when deserializing into Rust UTF-8 string types such as String, and
1577	/// succeed with non-UTF-8 bytes when deserializing using this method.
1578	///
1579	/// Escape sequences are processed as usual, and for `\uXXXX` escapes it is
1580	/// still checked if the hex number represents a valid Unicode code point.
1581	///
1582	/// # Examples
1583	///
1584	/// You can use this to parse JSON strings containing invalid UTF-8 bytes,
1585	/// or unpaired surrogates.
1586	///
1587	/// ```
1588	/// use serde_bytes::ByteBuf;
1589	///
1590	/// fn look_at_bytes() -> Result<(), serde_json::Error> {
1591	/// let json_data = b"`\"`some bytes: `\xe5\x00\xe5\"`";
1592	/// let bytes: ByteBuf = serde_json::from_slice(json_data)?;
1593	///
1594	/// assert_eq!(b'`\xe5`', bytes[`12`]);
1595	/// assert_eq!(b'`\0`', bytes[`13`]);
1596	/// assert_eq!(b'`\xe5`', bytes[`14`]);
1597	///
1598	/// Ok(())
1599	/// }
1600	/// #
1601	/// # look_at_bytes().unwrap();
1602	/// ```
1603	///
1604	/// Backslash escape sequences like `\n` are still interpreted and required
1605	/// to be valid. `\u` escape sequences are required to represent a valid
1606	/// Unicode code point or lone surrogate.
1607	///
1608	/// ```
1609	/// use serde_bytes::ByteBuf;
1610	///
1611	/// fn look_at_bytes() -> Result<(), serde_json::Error> {
1612	/// let json_data = b"`\"`lone surrogate: `\\`uD801`\"`";
1613	/// let bytes: ByteBuf = serde_json::from_slice(json_data)?;
1614	/// let expected = b"lone surrogate: `\xED\xA0\x81`";
1615	/// assert_eq!(expected, bytes.as_slice());
1616	/// Ok(())
1617	/// }
1618	/// #
1619	/// # look_at_bytes();
1620	/// ```
1621	fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
1622	where
1623	V: de::Visitor<'de>,
1624	{
1625	let peek = match tri!(self.parse_whitespace()) {
1626	Some(b) => b,
1627	None => {
1628	return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1629	}
1630	};
1631
1632	let value = match peek {
1633	b'"' => {
1634	self.eat_char();
1635	self.scratch.clear();
1636	match tri!(self.read.parse_str_raw(&mut self.scratch)) {
1637	Reference::Borrowed(b) => visitor.visit_borrowed_bytes(b),
1638	Reference::Copied(b) => visitor.visit_bytes(b),
1639	}
1640	}
1641	b'[' => self.deserialize_seq(visitor),
1642	_ => Err(self.peek_invalid_type(&visitor)),
1643	};
1644
1645	match value {
1646	Ok(value) => Ok(value),
1647	Err(err) => Err(self.fix_position(err)),
1648	}
1649	}
1650
1651	#[inline]
1652	fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
1653	where
1654	V: de::Visitor<'de>,
1655	{
1656	self.deserialize_bytes(visitor)
1657	}
1658
1659	/// Parses a `null` as a None, and any other values as a `Some(...)`.
1660	#[inline]
1661	fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
1662	where
1663	V: de::Visitor<'de>,
1664	{
1665	match tri!(self.parse_whitespace()) {
1666	Some(b'n') => {
1667	self.eat_char();
1668	tri!(self.parse_ident(b"ull"));
1669	visitor.visit_none()
1670	}
1671	_ => visitor.visit_some(self),
1672	}
1673	}
1674
1675	fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
1676	where
1677	V: de::Visitor<'de>,
1678	{
1679	let peek = match tri!(self.parse_whitespace()) {
1680	Some(b) => b,
1681	None => {
1682	return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1683	}
1684	};
1685
1686	let value = match peek {
1687	b'n' => {
1688	self.eat_char();
1689	tri!(self.parse_ident(b"ull"));
1690	visitor.visit_unit()
1691	}
1692	_ => Err(self.peek_invalid_type(&visitor)),
1693	};
1694
1695	match value {
1696	Ok(value) => Ok(value),
1697	Err(err) => Err(self.fix_position(err)),
1698	}
1699	}
1700
1701	fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
1702	where
1703	V: de::Visitor<'de>,
1704	{
1705	self.deserialize_unit(visitor)
1706	}
1707
1708	/// Parses a newtype struct as the underlying value.
1709	#[inline]
1710	fn deserialize_newtype_struct<V>(self, name: &str, visitor: V) -> Result<V::Value>
1711	where
1712	V: de::Visitor<'de>,
1713	{
1714	#[cfg(feature = "raw_value")]
1715	{
1716	if name == crate::raw::TOKEN {
1717	return self.deserialize_raw_value(visitor);
1718	}
1719	}
1720
1721	let _ = name;
1722	visitor.visit_newtype_struct(self)
1723	}
1724
1725	fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
1726	where
1727	V: de::Visitor<'de>,
1728	{
1729	let peek = match tri!(self.parse_whitespace()) {
1730	Some(b) => b,
1731	None => {
1732	return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1733	}
1734	};
1735
1736	let value = match peek {
1737	b'[' => {
1738	check_recursion! {
1739	self.eat_char();
1740	let ret = visitor.visit_seq(SeqAccess::new(self));
1741	}
1742
1743	match (ret, self.end_seq()) {
1744	(Ok(ret), Ok(())) => Ok(ret),
1745	(Err(err), _) \| (_, Err(err)) => Err(err),
1746	}
1747	}
1748	_ => Err(self.peek_invalid_type(&visitor)),
1749	};
1750
1751	match value {
1752	Ok(value) => Ok(value),
1753	Err(err) => Err(self.fix_position(err)),
1754	}
1755	}
1756
1757	fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
1758	where
1759	V: de::Visitor<'de>,
1760	{
1761	self.deserialize_seq(visitor)
1762	}
1763
1764	fn deserialize_tuple_struct<V>(
1765	self,
1766	_name: &'static str,
1767	_len: usize,
1768	visitor: V,
1769	) -> Result<V::Value>
1770	where
1771	V: de::Visitor<'de>,
1772	{
1773	self.deserialize_seq(visitor)
1774	}
1775
1776	fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
1777	where
1778	V: de::Visitor<'de>,
1779	{
1780	let peek = match tri!(self.parse_whitespace()) {
1781	Some(b) => b,
1782	None => {
1783	return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1784	}
1785	};
1786
1787	let value = match peek {
1788	b'{' => {
1789	check_recursion! {
1790	self.eat_char();
1791	let ret = visitor.visit_map(MapAccess::new(self));
1792	}
1793
1794	match (ret, self.end_map()) {
1795	(Ok(ret), Ok(())) => Ok(ret),
1796	(Err(err), _) \| (_, Err(err)) => Err(err),
1797	}
1798	}
1799	_ => Err(self.peek_invalid_type(&visitor)),
1800	};
1801
1802	match value {
1803	Ok(value) => Ok(value),
1804	Err(err) => Err(self.fix_position(err)),
1805	}
1806	}
1807
1808	fn deserialize_struct<V>(
1809	self,
1810	_name: &'static str,
1811	_fields: &'static [&'static str],
1812	visitor: V,
1813	) -> Result<V::Value>
1814	where
1815	V: de::Visitor<'de>,
1816	{
1817	let peek = match tri!(self.parse_whitespace()) {
1818	Some(b) => b,
1819	None => {
1820	return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1821	}
1822	};
1823
1824	let value = match peek {
1825	b'[' => {
1826	check_recursion! {
1827	self.eat_char();
1828	let ret = visitor.visit_seq(SeqAccess::new(self));
1829	}
1830
1831	match (ret, self.end_seq()) {
1832	(Ok(ret), Ok(())) => Ok(ret),
1833	(Err(err), _) \| (_, Err(err)) => Err(err),
1834	}
1835	}
1836	b'{' => {
1837	check_recursion! {
1838	self.eat_char();
1839	let ret = visitor.visit_map(MapAccess::new(self));
1840	}
1841
1842	match (ret, self.end_map()) {
1843	(Ok(ret), Ok(())) => Ok(ret),
1844	(Err(err), _) \| (_, Err(err)) => Err(err),
1845	}
1846	}
1847	_ => Err(self.peek_invalid_type(&visitor)),
1848	};
1849
1850	match value {
1851	Ok(value) => Ok(value),
1852	Err(err) => Err(self.fix_position(err)),
1853	}
1854	}
1855
1856	/// Parses an enum as an object like `{"$KEY":$VALUE}`, where $VALUE is either a straight
1857	/// value, a `[..]`, or a `{..}`.
1858	#[inline]
1859	fn deserialize_enum<V>(
1860	self,
1861	_name: &str,
1862	_variants: &'static [&'static str],
1863	visitor: V,
1864	) -> Result<V::Value>
1865	where
1866	V: de::Visitor<'de>,
1867	{
1868	match tri!(self.parse_whitespace()) {
1869	Some(b'{') => {
1870	check_recursion! {
1871	self.eat_char();
1872	let value = tri!(visitor.visit_enum(VariantAccess::new(self)));
1873	}
1874
1875	match tri!(self.parse_whitespace()) {
1876	Some(b'}') => {
1877	self.eat_char();
1878	Ok(value)
1879	}
1880	Some(_) => Err(self.error(ErrorCode::ExpectedSomeValue)),
1881	None => Err(self.error(ErrorCode::EofWhileParsingObject)),
1882	}
1883	}
1884	Some(b'"') => visitor.visit_enum(UnitVariantAccess::new(self)),
1885	Some(_) => Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
1886	None => Err(self.peek_error(ErrorCode::EofWhileParsingValue)),
1887	}
1888	}
1889
1890	fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
1891	where
1892	V: de::Visitor<'de>,
1893	{
1894	self.deserialize_str(visitor)
1895	}
1896
1897	fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
1898	where
1899	V: de::Visitor<'de>,
1900	{
1901	tri!(self.ignore_value());
1902	visitor.visit_unit()
1903	}
1904	}
1905
1906	struct SeqAccess<'a, R: 'a> {
1907	de: &'a mut Deserializer<R>,
1908	first: bool,
1909	}
1910
1911	impl<'a, R: 'a> SeqAccess<'a, R> {
1912	fn new(de: &'a mut Deserializer<R>) -> Self {
1913	SeqAccess { de, first: `true` }
1914	}
1915	}
1916
1917	impl<'de, 'a, R: Read<'de> + 'a> de::SeqAccess<'de> for SeqAccess<'a, R> {
1918	type Error = Error;
1919
1920	fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
1921	where
1922	T: de::DeserializeSeed<'de>,
1923	{
1924	let peek = match tri!(self.de.parse_whitespace()) {
1925	Some(b']') => {
1926	return Ok(None);
1927	}
1928	Some(b',') if !self.first => {
1929	self.de.eat_char();
1930	tri!(self.de.parse_whitespace())
1931	}
1932	Some(b) => {
1933	if self.first {
1934	self.first = `false`;
1935	Some(b)
1936	} else {
1937	return Err(self.de.peek_error(ErrorCode::ExpectedListCommaOrEnd));
1938	}
1939	}
1940	None => {
1941	return Err(self.de.peek_error(ErrorCode::EofWhileParsingList));
1942	}
1943	};
1944
1945	match peek {
1946	Some(b']') => Err(self.de.peek_error(ErrorCode::TrailingComma)),
1947	Some(_) => Ok(Some(tri!(seed.deserialize(&mut *self.de)))),
1948	None => Err(self.de.peek_error(ErrorCode::EofWhileParsingValue)),
1949	}
1950	}
1951	}
1952
1953	struct MapAccess<'a, R: 'a> {
1954	de: &'a mut Deserializer<R>,
1955	first: bool,
1956	}
1957
1958	impl<'a, R: 'a> MapAccess<'a, R> {
1959	fn new(de: &'a mut Deserializer<R>) -> Self {
1960	MapAccess { de, first: `true` }
1961	}
1962	}
1963
1964	impl<'de, 'a, R: Read<'de> + 'a> de::MapAccess<'de> for MapAccess<'a, R> {
1965	type Error = Error;
1966
1967	fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
1968	where
1969	K: de::DeserializeSeed<'de>,
1970	{
1971	let peek = match tri!(self.de.parse_whitespace()) {
1972	Some(b'}') => {
1973	return Ok(None);
1974	}
1975	Some(b',') if !self.first => {
1976	self.de.eat_char();
1977	tri!(self.de.parse_whitespace())
1978	}
1979	Some(b) => {
1980	if self.first {
1981	self.first = `false`;
1982	Some(b)
1983	} else {
1984	return Err(self.de.peek_error(ErrorCode::ExpectedObjectCommaOrEnd));
1985	}
1986	}
1987	None => {
1988	return Err(self.de.peek_error(ErrorCode::EofWhileParsingObject));
1989	}
1990	};
1991
1992	match peek {
1993	Some(b'"') => seed.deserialize(MapKey { de: &mut *self.de }).map(Some),
1994	Some(b'}') => Err(self.de.peek_error(ErrorCode::TrailingComma)),
1995	Some(_) => Err(self.de.peek_error(ErrorCode::KeyMustBeAString)),
1996	None => Err(self.de.peek_error(ErrorCode::EofWhileParsingValue)),
1997	}
1998	}
1999
2000	fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
2001	where
2002	V: de::DeserializeSeed<'de>,
2003	{
2004	tri!(self.de.parse_object_colon());
2005
2006	seed.deserialize(&mut *self.de)
2007	}
2008	}
2009
2010	struct VariantAccess<'a, R: 'a> {
2011	de: &'a mut Deserializer<R>,
2012	}
2013
2014	impl<'a, R: 'a> VariantAccess<'a, R> {
2015	fn new(de: &'a mut Deserializer<R>) -> Self {
2016	VariantAccess { de }
2017	}
2018	}
2019
2020	impl<'de, 'a, R: Read<'de> + 'a> de::EnumAccess<'de> for VariantAccess<'a, R> {
2021	type Error = Error;
2022	type Variant = Self;
2023
2024	fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self)>
2025	where
2026	V: de::DeserializeSeed<'de>,
2027	{
2028	let val = tri!(seed.deserialize(&mut *self.de));
2029	tri!(self.de.parse_object_colon());
2030	Ok((val, self))
2031	}
2032	}
2033
2034	impl<'de, 'a, R: Read<'de> + 'a> de::VariantAccess<'de> for VariantAccess<'a, R> {
2035	type Error = Error;
2036
2037	fn unit_variant(self) -> Result<()> {
2038	de::Deserialize::deserialize(self.de)
2039	}
2040
2041	fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
2042	where
2043	T: de::DeserializeSeed<'de>,
2044	{
2045	seed.deserialize(self.de)
2046	}
2047
2048	fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
2049	where
2050	V: de::Visitor<'de>,
2051	{
2052	de::Deserializer::deserialize_seq(self.de, visitor)
2053	}
2054
2055	fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value>
2056	where
2057	V: de::Visitor<'de>,
2058	{
2059	de::Deserializer::deserialize_struct(self.de, "", fields, visitor)
2060	}
2061	}
2062
2063	struct UnitVariantAccess<'a, R: 'a> {
2064	de: &'a mut Deserializer<R>,
2065	}
2066
2067	impl<'a, R: 'a> UnitVariantAccess<'a, R> {
2068	fn new(de: &'a mut Deserializer<R>) -> Self {
2069	UnitVariantAccess { de }
2070	}
2071	}
2072
2073	impl<'de, 'a, R: Read<'de> + 'a> de::EnumAccess<'de> for UnitVariantAccess<'a, R> {
2074	type Error = Error;
2075	type Variant = Self;
2076
2077	fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self)>
2078	where
2079	V: de::DeserializeSeed<'de>,
2080	{
2081	let variant = tri!(seed.deserialize(&mut *self.de));
2082	Ok((variant, self))
2083	}
2084	}
2085
2086	impl<'de, 'a, R: Read<'de> + 'a> de::VariantAccess<'de> for UnitVariantAccess<'a, R> {
2087	type Error = Error;
2088
2089	fn unit_variant(self) -> Result<()> {
2090	Ok(())
2091	}
2092
2093	fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value>
2094	where
2095	T: de::DeserializeSeed<'de>,
2096	{
2097	Err(de::Error::invalid_type(
2098	Unexpected::UnitVariant,
2099	&"newtype variant",
2100	))
2101	}
2102
2103	fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value>
2104	where
2105	V: de::Visitor<'de>,
2106	{
2107	Err(de::Error::invalid_type(
2108	Unexpected::UnitVariant,
2109	&"tuple variant",
2110	))
2111	}
2112
2113	fn struct_variant<V>(self, _fields: &'static [&'static str], _visitor: V) -> Result<V::Value>
2114	where
2115	V: de::Visitor<'de>,
2116	{
2117	Err(de::Error::invalid_type(
2118	Unexpected::UnitVariant,
2119	&"struct variant",
2120	))
2121	}
2122	}
2123
2124	/// Only deserialize from this after peeking a '"' byte! Otherwise it may
2125	/// deserialize invalid JSON successfully.
2126	struct MapKey<'a, R: 'a> {
2127	de: &'a mut Deserializer<R>,
2128	}
2129
2130	macro_rules! deserialize_numeric_key {
2131	($method:ident) => {
2132	fn $method<V>(self, visitor: V) -> Result<V::Value>
2133	where
2134	V: de::Visitor<'de>,
2135	{
2136	self.deserialize_number(visitor)
2137	}
2138	};
2139
2140	($method:ident, $delegate:ident) => {
2141	fn $method<V>(self, visitor: V) -> Result<V::Value>
2142	where
2143	V: de::Visitor<'de>,
2144	{
2145	self.de.eat_char();
2146
2147	match tri!(self.de.peek()) {
2148	Some(b'0'..=b'9' \| b'-') => {}
2149	_ => return Err(self.de.error(ErrorCode::ExpectedNumericKey)),
2150	}
2151
2152	let value = tri!(self.de.$delegate(visitor));
2153
2154	match tri!(self.de.peek()) {
2155	Some(b'"') => self.de.eat_char(),
2156	_ => return Err(self.de.peek_error(ErrorCode::ExpectedDoubleQuote)),
2157	}
2158
2159	Ok(value)
2160	}
2161	};
2162	}
2163
2164	impl<'de, 'a, R> MapKey<'a, R>
2165	where
2166	R: Read<'de>,
2167	{
2168	deserialize_numeric_key!(deserialize_number, deserialize_number);
2169	}
2170
2171	impl<'de, 'a, R> de::Deserializer<'de> for MapKey<'a, R>
2172	where
2173	R: Read<'de>,
2174	{
2175	type Error = Error;
2176
2177	#[inline]
2178	fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
2179	where
2180	V: de::Visitor<'de>,
2181	{
2182	self.de.eat_char();
2183	self.de.scratch.clear();
2184	match tri!(self.de.read.parse_str(&mut self.de.scratch)) {
2185	Reference::Borrowed(s) => visitor.visit_borrowed_str(s),
2186	Reference::Copied(s) => visitor.visit_str(s),
2187	}
2188	}
2189
2190	deserialize_numeric_key!(deserialize_i8);
2191	deserialize_numeric_key!(deserialize_i16);
2192	deserialize_numeric_key!(deserialize_i32);
2193	deserialize_numeric_key!(deserialize_i64);
2194	deserialize_numeric_key!(deserialize_i128, deserialize_i128);
2195	deserialize_numeric_key!(deserialize_u8);
2196	deserialize_numeric_key!(deserialize_u16);
2197	deserialize_numeric_key!(deserialize_u32);
2198	deserialize_numeric_key!(deserialize_u64);
2199	deserialize_numeric_key!(deserialize_u128, deserialize_u128);
2200	#[cfg(not(feature = "float_roundtrip"))]
2201	deserialize_numeric_key!(deserialize_f32);
2202	#[cfg(feature = "float_roundtrip")]
2203	deserialize_numeric_key!(deserialize_f32, deserialize_f32);
2204	deserialize_numeric_key!(deserialize_f64);
2205
2206	fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
2207	where
2208	V: de::Visitor<'de>,
2209	{
2210	self.de.eat_char();
2211
2212	let peek = match tri!(self.de.next_char()) {
2213	Some(b) => b,
2214	None => {
2215	return Err(self.de.peek_error(ErrorCode::EofWhileParsingValue));
2216	}
2217	};
2218
2219	let value = match peek {
2220	b't' => {
2221	tri!(self.de.parse_ident(b"rue`\"`"));
2222	visitor.visit_bool(`true`)
2223	}
2224	b'f' => {
2225	tri!(self.de.parse_ident(b"alse`\"`"));
2226	visitor.visit_bool(`false`)
2227	}
2228	_ => {
2229	self.de.scratch.clear();
2230	let s = tri!(self.de.read.parse_str(&mut self.de.scratch));
2231	Err(de::Error::invalid_type(Unexpected::Str(&s), &visitor))
2232	}
2233	};
2234
2235	match value {
2236	Ok(value) => Ok(value),
2237	Err(err) => Err(self.de.fix_position(err)),
2238	}
2239	}
2240
2241	#[inline]
2242	fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
2243	where
2244	V: de::Visitor<'de>,
2245	{
2246	// Map keys cannot be null.
2247	visitor.visit_some(self)
2248	}
2249
2250	#[inline]
2251	fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
2252	where
2253	V: de::Visitor<'de>,
2254	{
2255	#[cfg(feature = "raw_value")]
2256	{
2257	if name == crate::raw::TOKEN {
2258	return self.de.deserialize_raw_value(visitor);
2259	}
2260	}
2261
2262	let _ = name;
2263	visitor.visit_newtype_struct(self)
2264	}
2265
2266	#[inline]
2267	fn deserialize_enum<V>(
2268	self,
2269	name: &'static str,
2270	variants: &'static [&'static str],
2271	visitor: V,
2272	) -> Result<V::Value>
2273	where
2274	V: de::Visitor<'de>,
2275	{
2276	self.de.deserialize_enum(name, variants, visitor)
2277	}
2278
2279	#[inline]
2280	fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
2281	where
2282	V: de::Visitor<'de>,
2283	{
2284	self.de.deserialize_bytes(visitor)
2285	}
2286
2287	#[inline]
2288	fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
2289	where
2290	V: de::Visitor<'de>,
2291	{
2292	self.de.deserialize_bytes(visitor)
2293	}
2294
2295	forward_to_deserialize_any! {
2296	char str string unit unit_struct seq tuple tuple_struct map struct
2297	identifier ignored_any
2298	}
2299	}
2300
2301	//////////////////////////////////////////////////////////////////////////////
2302
2303	/// Iterator that deserializes a stream into multiple JSON values.
2304	///
2305	/// A stream deserializer can be created from any JSON deserializer using the
2306	/// `Deserializer::into_iter` method.
2307	///
2308	/// The data can consist of any JSON value. Values need to be a self-delineating value e.g.
2309	/// arrays, objects, or strings, or be followed by whitespace or a self-delineating value.
2310	///
2311	/// ```
2312	/// use serde_json::{Deserializer, Value};
2313	///
2314	/// fn main() {
2315	/// let data = "{`\"`k`\"`: 3}1`\"`cool`\"\"`stuff`\"` 3{} [0, 1, 2]";
2316	///
2317	/// let stream = Deserializer::from_str(data).into_iter::<Value>();
2318	///
2319	/// for value in stream {
2320	/// println!("{}", value.unwrap());
2321	/// }
2322	/// }
2323	/// ```
2324	pub struct StreamDeserializer<'de, R, T> {
2325	de: Deserializer<R>,
2326	offset: usize,
2327	failed: bool,
2328	output: PhantomData<T>,
2329	lifetime: PhantomData<&'de ()>,
2330	}
2331
2332	impl<'de, R, T> StreamDeserializer<'de, R, T>
2333	where
2334	R: read::Read<'de>,
2335	T: de::Deserialize<'de>,
2336	{
2337	/// Create a JSON stream deserializer from one of the possible serde_json
2338	/// input sources.
2339	///
2340	/// Typically it is more convenient to use one of these methods instead:
2341	///
2342	/// - Deserializer::from_str(...).into_iter()
2343	/// - Deserializer::from_slice(...).into_iter()
2344	/// - Deserializer::from_reader(...).into_iter()
2345	pub fn new(read: R) -> Self {
2346	let offset = read.byte_offset();
2347	StreamDeserializer {
2348	de: Deserializer::new(read),
2349	offset,
2350	failed: `false`,
2351	output: PhantomData,
2352	lifetime: PhantomData,
2353	}
2354	}
2355
2356	/// Returns the number of bytes so far deserialized into a successful `T`.
2357	///
2358	/// If a stream deserializer returns an EOF error, new data can be joined to
2359	/// `old_data[stream.byte_offset()..]` to try again.
2360	///
2361	/// ```
2362	/// let data = b"[0] [1] [";
2363	///
2364	/// let de = serde_json::Deserializer::from_slice(data);
2365	/// let mut stream = de.into_iter::<Vec<i32>>();
2366	/// assert_eq!(`0`, stream.byte_offset());
2367	///
2368	/// println!("{:?}", stream.next()); // [0]
2369	/// assert_eq!(`3`, stream.byte_offset());
2370	///
2371	/// println!("{:?}", stream.next()); // [1]
2372	/// assert_eq!(`7`, stream.byte_offset());
2373	///
2374	/// println!("{:?}", stream.next()); // error
2375	/// assert_eq!(`8`, stream.byte_offset());
2376	///
2377	/// // If err.is_eof(), can join the remaining data to new data and continue.
2378	/// let remaining = &data[stream.byte_offset()..];
2379	/// ```
2380	///
2381	/// Note:* In the future this method may be changed to return the number of*
2382	/// bytes so far deserialized into a successful T or* syntactically valid*
2383	/// JSON skipped over due to a type error. See [serde-rs/json#70] for an
2384	/// example illustrating this.
2385	///
2386	/// [serde-rs/json#70]: https://github.com/serde-rs/json/issues/70
2387	pub fn byte_offset(&self) -> usize {
2388	self.offset
2389	}
2390
2391	fn peek_end_of_value(&mut self) -> Result<()> {
2392	match tri!(self.de.peek()) {
2393	Some(b' ' \| b'`\n`' \| b'`\t`' \| b'`\r`' \| b'"' \| b'[' \| b']' \| b'{' \| b'}' \| b',' \| b':')
2394	\| None => Ok(()),
2395	Some(_) => {
2396	let position = self.de.read.peek_position();
2397	Err(Error::syntax(
2398	ErrorCode::TrailingCharacters,
2399	position.line,
2400	position.column,
2401	))
2402	}
2403	}
2404	}
2405	}
2406
2407	impl<'de, R, T> Iterator for StreamDeserializer<'de, R, T>
2408	where
2409	R: Read<'de>,
2410	T: de::Deserialize<'de>,
2411	{
2412	type Item = Result<T>;
2413
2414	fn next(&mut self) -> Option<Result<T>> {
2415	if R::should_early_return_if_failed && self.failed {
2416	return None;
2417	}
2418
2419	// skip whitespaces, if any
2420	// this helps with trailing whitespaces, since whitespaces between
2421	// values are handled for us.
2422	match self.de.parse_whitespace() {
2423	Ok(None) => {
2424	self.offset = self.de.read.byte_offset();
2425	None
2426	}
2427	Ok(Some(b)) => {
2428	// If the value does not have a clear way to show the end of the value
2429	// (like numbers, null, true etc.) we have to look for whitespace or
2430	// the beginning of a self-delineated value.
2431	let self_delineated_value = match b {
2432	b'[' \| b'"' \| b'{' => `true`,
2433	_ => `false`,
2434	};
2435	self.offset = self.de.read.byte_offset();
2436	let result = de::Deserialize::deserialize(&mut self.de);
2437
2438	Some(match result {
2439	Ok(value) => {
2440	self.offset = self.de.read.byte_offset();
2441	if self_delineated_value {
2442	Ok(value)
2443	} else {
2444	self.peek_end_of_value().map(\|()\| value)
2445	}
2446	}
2447	Err(e) => {
2448	self.de.read.set_failed(&mut self.failed);
2449	Err(e)
2450	}
2451	})
2452	}
2453	Err(e) => {
2454	self.de.read.set_failed(&mut self.failed);
2455	Some(Err(e))
2456	}
2457	}
2458	}
2459	}
2460
2461	impl<'de, R, T> FusedIterator for StreamDeserializer<'de, R, T>
2462	where
2463	R: Read<'de> + Fused,
2464	T: de::Deserialize<'de>,
2465	{
2466	}
2467
2468	//////////////////////////////////////////////////////////////////////////////
2469
2470	fn from_trait<'de, R, T>(read: R) -> Result<T>
2471	where
2472	R: Read<'de>,
2473	T: de::Deserialize<'de>,
2474	{
2475	let mut de = Deserializer::new(read);
2476	let value = tri!(de::Deserialize::deserialize(&mut de));
2477
2478	// Make sure the whole stream has been consumed.
2479	tri!(de.end());
2480	Ok(value)
2481	}
2482
2483	/// Deserialize an instance of type `T` from an I/O stream of JSON.
2484	///
2485	/// The content of the I/O stream is deserialized directly from the stream
2486	/// without being buffered in memory by serde_json.
2487	///
2488	/// When reading from a source against which short reads are not efficient, such
2489	/// as a [`File`], you will want to apply your own buffering because serde_json
2490	/// will not buffer the input. See [`std::io::BufReader`].
2491	///
2492	/// It is expected that the input stream ends after the deserialized object.
2493	/// If the stream does not end, such as in the case of a persistent socket connection,
2494	/// this function will not return. It is possible instead to deserialize from a prefix of an input
2495	/// stream without looking for EOF by managing your own [`Deserializer`].
2496	///
2497	/// Note that counter to intuition, this function is usually slower than
2498	/// reading a file completely into memory and then applying [`from_str`]
2499	/// or [`from_slice`] on it. See [issue #160].
2500	///
2501	/// [`File`]: https://doc.rust-lang.org/std/fs/struct.File.html
2502	/// [`std::io::BufReader`]: https://doc.rust-lang.org/std/io/struct.BufReader.html
2503	/// [`from_str`]: ./fn.from_str.html
2504	/// [`from_slice`]: ./fn.from_slice.html
2505	/// [issue #160]: https://github.com/serde-rs/json/issues/160
2506	///
2507	/// # Example
2508	///
2509	/// Reading the contents of a file.
2510	///
2511	/// ```
2512	/// use serde::Deserialize;
2513	///
2514	/// use std::error::Error;
2515	/// use std::fs::File;
2516	/// use std::io::BufReader;
2517	/// use std::path::Path;
2518	///
2519	/// #[derive(Deserialize, Debug)]
2520	/// struct User {
2521	/// fingerprint: String,
2522	/// location: String,
2523	/// }
2524	///
2525	/// fn read_user_from_file<P: AsRef<Path>>(path: P) -> Result<User, Box<dyn Error>> {
2526	/// // Open the file in read-only mode with buffer.
2527	/// let file = File::open(path)?;
2528	/// let reader = BufReader::new(file);
2529	///
2530	/// // Read the JSON contents of the file as an instance of `User`.
2531	/// let u = serde_json::from_reader(reader)?;
2532	///
2533	/// // Return the `User`.
2534	/// Ok(u)
2535	/// }
2536	///
2537	/// fn main() {
2538	/// # }
2539	/// # fn fake_main() {
2540	/// let u = read_user_from_file("test.json").unwrap();
2541	/// println!("{:#?}", u);
2542	/// }
2543	/// ```
2544	///
2545	/// Reading from a persistent socket connection.
2546	///
2547	/// ```
2548	/// use serde::Deserialize;
2549	///
2550	/// use std::error::Error;
2551	/// use std::net::{TcpListener, TcpStream};
2552	///
2553	/// #[derive(Deserialize, Debug)]
2554	/// struct User {
2555	/// fingerprint: String,
2556	/// location: String,
2557	/// }
2558	///
2559	/// fn read_user_from_stream(tcp_stream: TcpStream) -> Result<User, Box<dyn Error>> {
2560	/// let mut de = serde_json::Deserializer::from_reader(tcp_stream);
2561	/// let u = User::deserialize(&mut de)?;
2562	///
2563	/// Ok(u)
2564	/// }
2565	///
2566	/// fn main() {
2567	/// # }
2568	/// # fn fake_main() {
2569	/// let listener = TcpListener::bind("127.0.0.1:4000").unwrap();
2570	///
2571	/// for stream in listener.incoming() {
2572	/// println!("{:#?}", read_user_from_stream(stream.unwrap()));
2573	/// }
2574	/// }
2575	/// ```
2576	///
2577	/// # Errors
2578	///
2579	/// This conversion can fail if the structure of the input does not match the
2580	/// structure expected by `T`, for example if `T` is a struct type but the input
2581	/// contains something other than a JSON map. It can also fail if the structure
2582	/// is correct but `T`'s implementation of `Deserialize` decides that something
2583	/// is wrong with the data, for example required struct fields are missing from
2584	/// the JSON map or some number is too big to fit in the expected primitive
2585	/// type.
2586	#[cfg(feature = "std")]
2587	#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
2588	pub fn from_reader<R, T>(rdr: R) -> Result<T>
2589	where
2590	R: crate::io::Read,
2591	T: de::DeserializeOwned,
2592	{
2593	from_trait(read::IoRead::new(rdr))
2594	}
2595
2596	/// Deserialize an instance of type `T` from bytes of JSON text.
2597	///
2598	/// # Example
2599	///
2600	/// ```
2601	/// use serde::Deserialize;
2602	///
2603	/// #[derive(Deserialize, Debug)]
2604	/// struct User {
2605	/// fingerprint: String,
2606	/// location: String,
2607	/// }
2608	///
2609	/// fn main() {
2610	/// // The type of `j` is `&[u8]`
2611	/// let j = b"
2612	/// {
2613	/// `\"`fingerprint`\"`: `\"`0xF9BA143B95FF6D82`\"`,
2614	/// `\"`location`\"`: `\"`Menlo Park, CA`\"`
2615	/// }";
2616	///
2617	/// let u: User = serde_json::from_slice(j).unwrap();
2618	/// println!("{:#?}", u);
2619	/// }
2620	/// ```
2621	///
2622	/// # Errors
2623	///
2624	/// This conversion can fail if the structure of the input does not match the
2625	/// structure expected by `T`, for example if `T` is a struct type but the input
2626	/// contains something other than a JSON map. It can also fail if the structure
2627	/// is correct but `T`'s implementation of `Deserialize` decides that something
2628	/// is wrong with the data, for example required struct fields are missing from
2629	/// the JSON map or some number is too big to fit in the expected primitive
2630	/// type.
2631	pub fn from_slice<'a, T>(v: &'a [u8]) -> Result<T>
2632	where
2633	T: de::Deserialize<'a>,
2634	{
2635	from_trait(read::SliceRead::new(v))
2636	}
2637
2638	/// Deserialize an instance of type `T` from a string of JSON text.
2639	///
2640	/// # Example
2641	///
2642	/// ```
2643	/// use serde::Deserialize;
2644	///
2645	/// #[derive(Deserialize, Debug)]
2646	/// struct User {
2647	/// fingerprint: String,
2648	/// location: String,
2649	/// }
2650	///
2651	/// fn main() {
2652	/// // The type of `j` is `&str`
2653	/// let j = "
2654	/// {
2655	/// `\"`fingerprint`\"`: `\"`0xF9BA143B95FF6D82`\"`,
2656	/// `\"`location`\"`: `\"`Menlo Park, CA`\"`
2657	/// }";
2658	///
2659	/// let u: User = serde_json::from_str(j).unwrap();
2660	/// println!("{:#?}", u);
2661	/// }
2662	/// ```
2663	///
2664	/// # Errors
2665	///
2666	/// This conversion can fail if the structure of the input does not match the
2667	/// structure expected by `T`, for example if `T` is a struct type but the input
2668	/// contains something other than a JSON map. It can also fail if the structure
2669	/// is correct but `T`'s implementation of `Deserialize` decides that something
2670	/// is wrong with the data, for example required struct fields are missing from
2671	/// the JSON map or some number is too big to fit in the expected primitive
2672	/// type.
2673	pub fn from_str<'a, T>(s: &'a str) -> Result<T>
2674	where
2675	T: de::Deserialize<'a>,
2676	{
2677	from_trait(read::StrRead::new(s))
2678	}
2679