1 //! Deserializing TOML into Rust structures.
2 //!
3 //! This module contains all the Serde support for deserializing TOML documents
4 //! into Rust structures. Note that some top-level functions here are also
5 //! provided at the top of the crate.
6
7 use std::borrow::Cow;
8 use std::collections::HashMap;
9 use std::error;
10 use std::f64;
11 use std::fmt;
12 use std::iter;
13 use std::marker::PhantomData;
14 use std::str;
15 use std::vec;
16
17 use serde::de;
18 use serde::de::value::BorrowedStrDeserializer;
19 use serde::de::IntoDeserializer;
20
21 use crate::datetime;
22 use crate::spanned;
23 use crate::tokens::{Error as TokenError, Span, Token, Tokenizer};
24
25 /// Type Alias for a TOML Table pair
26 type TablePair<'a> = ((Span, Cow<'a, str>), Value<'a>);
27
28 /// Deserializes a byte slice into a type.
29 ///
30 /// This function will attempt to interpret `bytes` as UTF-8 data and then
31 /// deserialize `T` from the TOML document provided.
from_slice<'de, T>(bytes: &'de [u8]) -> Result<T, Error> where T: de::Deserialize<'de>,32 pub fn from_slice<'de, T>(bytes: &'de [u8]) -> Result<T, Error>
33 where
34 T: de::Deserialize<'de>,
35 {
36 match str::from_utf8(bytes) {
37 Ok(s) => from_str(s),
38 Err(e) => Err(Error::custom(None, e.to_string())),
39 }
40 }
41
42 /// Deserializes a string into a type.
43 ///
44 /// This function will attempt to interpret `s` as a TOML document and
45 /// deserialize `T` from the document.
46 ///
47 /// # Examples
48 ///
49 /// ```
50 /// use serde_derive::Deserialize;
51 ///
52 /// #[derive(Deserialize)]
53 /// struct Config {
54 /// title: String,
55 /// owner: Owner,
56 /// }
57 ///
58 /// #[derive(Deserialize)]
59 /// struct Owner {
60 /// name: String,
61 /// }
62 ///
63 /// fn main() {
64 /// let config: Config = toml::from_str(r#"
65 /// title = 'TOML Example'
66 ///
67 /// [owner]
68 /// name = 'Lisa'
69 /// "#).unwrap();
70 ///
71 /// assert_eq!(config.title, "TOML Example");
72 /// assert_eq!(config.owner.name, "Lisa");
73 /// }
74 /// ```
from_str<'de, T>(s: &'de str) -> Result<T, Error> where T: de::Deserialize<'de>,75 pub fn from_str<'de, T>(s: &'de str) -> Result<T, Error>
76 where
77 T: de::Deserialize<'de>,
78 {
79 let mut d = Deserializer::new(s);
80 let ret = T::deserialize(&mut d)?;
81 d.end()?;
82 Ok(ret)
83 }
84
85 /// Errors that can occur when deserializing a type.
86 #[derive(Debug, PartialEq, Eq, Clone)]
87 pub struct Error {
88 inner: Box<ErrorInner>,
89 }
90
91 #[derive(Debug, PartialEq, Eq, Clone)]
92 struct ErrorInner {
93 kind: ErrorKind,
94 line: Option<usize>,
95 col: usize,
96 at: Option<usize>,
97 message: String,
98 key: Vec<String>,
99 }
100
101 /// Errors that can occur when deserializing a type.
102 #[derive(Debug, PartialEq, Eq, Clone)]
103 enum ErrorKind {
104 /// EOF was reached when looking for a value
105 UnexpectedEof,
106
107 /// An invalid character not allowed in a string was found
108 InvalidCharInString(char),
109
110 /// An invalid character was found as an escape
111 InvalidEscape(char),
112
113 /// An invalid character was found in a hex escape
114 InvalidHexEscape(char),
115
116 /// An invalid escape value was specified in a hex escape in a string.
117 ///
118 /// Valid values are in the plane of unicode codepoints.
119 InvalidEscapeValue(u32),
120
121 /// A newline in a string was encountered when one was not allowed.
122 NewlineInString,
123
124 /// An unexpected character was encountered, typically when looking for a
125 /// value.
126 Unexpected(char),
127
128 /// An unterminated string was found where EOF was found before the ending
129 /// EOF mark.
130 UnterminatedString,
131
132 /// A newline was found in a table key.
133 NewlineInTableKey,
134
135 /// A number failed to parse
136 NumberInvalid,
137
138 /// A date or datetime was invalid
139 DateInvalid,
140
141 /// Wanted one sort of token, but found another.
142 Wanted {
143 /// Expected token type
144 expected: &'static str,
145 /// Actually found token type
146 found: &'static str,
147 },
148
149 /// A duplicate table definition was found.
150 DuplicateTable(String),
151
152 /// A previously defined table was redefined as an array.
153 RedefineAsArray,
154
155 /// An empty table key was found.
156 EmptyTableKey,
157
158 /// Multiline strings are not allowed for key
159 MultilineStringKey,
160
161 /// A custom error which could be generated when deserializing a particular
162 /// type.
163 Custom,
164
165 /// A tuple with a certain number of elements was expected but something
166 /// else was found.
167 ExpectedTuple(usize),
168
169 /// Expected table keys to be in increasing tuple index order, but something
170 /// else was found.
171 ExpectedTupleIndex {
172 /// Expected index.
173 expected: usize,
174 /// Key that was specified.
175 found: String,
176 },
177
178 /// An empty table was expected but entries were found
179 ExpectedEmptyTable,
180
181 /// Dotted key attempted to extend something that is not a table.
182 DottedKeyInvalidType,
183
184 /// An unexpected key was encountered.
185 ///
186 /// Used when deserializing a struct with a limited set of fields.
187 UnexpectedKeys {
188 /// The unexpected keys.
189 keys: Vec<String>,
190 /// Keys that may be specified.
191 available: &'static [&'static str],
192 },
193
194 /// Unquoted string was found when quoted one was expected
195 UnquotedString,
196
197 #[doc(hidden)]
198 __Nonexhaustive,
199 }
200
201 /// Deserialization implementation for TOML.
202 pub struct Deserializer<'a> {
203 require_newline_after_table: bool,
204 allow_duplciate_after_longer_table: bool,
205 input: &'a str,
206 tokens: Tokenizer<'a>,
207 }
208
209 impl<'de, 'b> de::Deserializer<'de> for &'b mut Deserializer<'de> {
210 type Error = Error;
211
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> where V: de::Visitor<'de>,212 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
213 where
214 V: de::Visitor<'de>,
215 {
216 let mut tables = self.tables()?;
217 let table_indices = build_table_indices(&tables);
218 let table_pindices = build_table_pindices(&tables);
219
220 let res = visitor.visit_map(MapVisitor {
221 values: Vec::new().into_iter().peekable(),
222 next_value: None,
223 depth: 0,
224 cur: 0,
225 cur_parent: 0,
226 max: tables.len(),
227 table_indices: &table_indices,
228 table_pindices: &table_pindices,
229 tables: &mut tables,
230 array: false,
231 de: self,
232 });
233 res.map_err(|mut err| {
234 // Errors originating from this library (toml), have an offset
235 // attached to them already. Other errors, like those originating
236 // from serde (like "missing field") or from a custom deserializer,
237 // do not have offsets on them. Here, we do a best guess at their
238 // location, by attributing them to the "current table" (the last
239 // item in `tables`).
240 err.fix_offset(|| tables.last().map(|table| table.at));
241 err.fix_linecol(|at| self.to_linecol(at));
242 err
243 })
244 }
245
246 // Called when the type to deserialize is an enum, as opposed to a field in the type.
deserialize_enum<V>( self, _name: &'static str, _variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Error> where V: de::Visitor<'de>,247 fn deserialize_enum<V>(
248 self,
249 _name: &'static str,
250 _variants: &'static [&'static str],
251 visitor: V,
252 ) -> Result<V::Value, Error>
253 where
254 V: de::Visitor<'de>,
255 {
256 let (value, name) = self.string_or_table()?;
257 match value.e {
258 E::String(val) => visitor.visit_enum(val.into_deserializer()),
259 E::InlineTable(values) => {
260 if values.len() != 1 {
261 Err(Error::from_kind(
262 Some(value.start),
263 ErrorKind::Wanted {
264 expected: "exactly 1 element",
265 found: if values.is_empty() {
266 "zero elements"
267 } else {
268 "more than 1 element"
269 },
270 },
271 ))
272 } else {
273 visitor.visit_enum(InlineTableDeserializer {
274 values: values.into_iter(),
275 next_value: None,
276 })
277 }
278 }
279 E::DottedTable(_) => visitor.visit_enum(DottedTableDeserializer {
280 name: name.expect("Expected table header to be passed."),
281 value,
282 }),
283 e => Err(Error::from_kind(
284 Some(value.start),
285 ErrorKind::Wanted {
286 expected: "string or table",
287 found: e.type_name(),
288 },
289 )),
290 }
291 }
292
deserialize_struct<V>( self, name: &'static str, fields: &'static [&'static str], visitor: V, ) -> Result<V::Value, Error> where V: de::Visitor<'de>,293 fn deserialize_struct<V>(
294 self,
295 name: &'static str,
296 fields: &'static [&'static str],
297 visitor: V,
298 ) -> Result<V::Value, Error>
299 where
300 V: de::Visitor<'de>,
301 {
302 if name == spanned::NAME && fields == [spanned::START, spanned::END, spanned::VALUE] {
303 let start = 0;
304 let end = self.input.len();
305
306 let res = visitor.visit_map(SpannedDeserializer {
307 phantom_data: PhantomData,
308 start: Some(start),
309 value: Some(self),
310 end: Some(end),
311 });
312 return res;
313 }
314
315 self.deserialize_any(visitor)
316 }
317
318 serde::forward_to_deserialize_any! {
319 bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
320 bytes byte_buf map unit newtype_struct
321 ignored_any unit_struct tuple_struct tuple option identifier
322 }
323 }
324
325 // Builds a datastructure that allows for efficient sublinear lookups.
326 // The returned HashMap contains a mapping from table header (like [a.b.c])
327 // to list of tables with that precise name. The tables are being identified
328 // by their index in the passed slice. We use a list as the implementation
329 // uses this data structure for arrays as well as tables,
330 // so if any top level [[name]] array contains multiple entries,
331 // there are multiple entires in the list.
332 // The lookup is performed in the `SeqAccess` implementation of `MapVisitor`.
333 // The lists are ordered, which we exploit in the search code by using
334 // bisection.
build_table_indices<'de>(tables: &[Table<'de>]) -> HashMap<Vec<Cow<'de, str>>, Vec<usize>>335 fn build_table_indices<'de>(tables: &[Table<'de>]) -> HashMap<Vec<Cow<'de, str>>, Vec<usize>> {
336 let mut res = HashMap::new();
337 for (i, table) in tables.iter().enumerate() {
338 let header = table.header.iter().map(|v| v.1.clone()).collect::<Vec<_>>();
339 res.entry(header).or_insert_with(Vec::new).push(i);
340 }
341 res
342 }
343
344 // Builds a datastructure that allows for efficient sublinear lookups.
345 // The returned HashMap contains a mapping from table header (like [a.b.c])
346 // to list of tables whose name at least starts with the specified
347 // name. So searching for [a.b] would give both [a.b.c.d] as well as [a.b.e].
348 // The tables are being identified by their index in the passed slice.
349 //
350 // A list is used for two reasons: First, the implementation also
351 // stores arrays in the same data structure and any top level array
352 // of size 2 or greater creates multiple entries in the list with the
353 // same shared name. Second, there can be multiple tables sharing
354 // the same prefix.
355 //
356 // The lookup is performed in the `MapAccess` implementation of `MapVisitor`.
357 // The lists are ordered, which we exploit in the search code by using
358 // bisection.
build_table_pindices<'de>(tables: &[Table<'de>]) -> HashMap<Vec<Cow<'de, str>>, Vec<usize>>359 fn build_table_pindices<'de>(tables: &[Table<'de>]) -> HashMap<Vec<Cow<'de, str>>, Vec<usize>> {
360 let mut res = HashMap::new();
361 for (i, table) in tables.iter().enumerate() {
362 let header = table.header.iter().map(|v| v.1.clone()).collect::<Vec<_>>();
363 for len in 0..=header.len() {
364 res.entry(header[..len].to_owned())
365 .or_insert_with(Vec::new)
366 .push(i);
367 }
368 }
369 res
370 }
371
headers_equal<'a, 'b>(hdr_a: &[(Span, Cow<'a, str>)], hdr_b: &[(Span, Cow<'b, str>)]) -> bool372 fn headers_equal<'a, 'b>(hdr_a: &[(Span, Cow<'a, str>)], hdr_b: &[(Span, Cow<'b, str>)]) -> bool {
373 if hdr_a.len() != hdr_b.len() {
374 return false;
375 }
376 hdr_a.iter().zip(hdr_b.iter()).all(|(h1, h2)| h1.1 == h2.1)
377 }
378
379 struct Table<'a> {
380 at: usize,
381 header: Vec<(Span, Cow<'a, str>)>,
382 values: Option<Vec<TablePair<'a>>>,
383 array: bool,
384 }
385
386 struct MapVisitor<'de, 'b> {
387 values: iter::Peekable<vec::IntoIter<TablePair<'de>>>,
388 next_value: Option<TablePair<'de>>,
389 depth: usize,
390 cur: usize,
391 cur_parent: usize,
392 max: usize,
393 table_indices: &'b HashMap<Vec<Cow<'de, str>>, Vec<usize>>,
394 table_pindices: &'b HashMap<Vec<Cow<'de, str>>, Vec<usize>>,
395 tables: &'b mut [Table<'de>],
396 array: bool,
397 de: &'b mut Deserializer<'de>,
398 }
399
400 impl<'de, 'b> de::MapAccess<'de> for MapVisitor<'de, 'b> {
401 type Error = Error;
402
next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error> where K: de::DeserializeSeed<'de>,403 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
404 where
405 K: de::DeserializeSeed<'de>,
406 {
407 if self.cur_parent == self.max || self.cur == self.max {
408 return Ok(None);
409 }
410
411 loop {
412 assert!(self.next_value.is_none());
413 if let Some((key, value)) = self.values.next() {
414 let ret = seed.deserialize(StrDeserializer::spanned(key.clone()))?;
415 self.next_value = Some((key, value));
416 return Ok(Some(ret));
417 }
418
419 let next_table = {
420 let prefix_stripped = self.tables[self.cur_parent].header[..self.depth]
421 .iter()
422 .map(|v| v.1.clone())
423 .collect::<Vec<_>>();
424 self.table_pindices
425 .get(&prefix_stripped)
426 .and_then(|entries| {
427 let start = entries.binary_search(&self.cur).unwrap_or_else(|v| v);
428 if start == entries.len() || entries[start] < self.cur {
429 return None;
430 }
431 entries[start..]
432 .iter()
433 .filter_map(|i| if *i < self.max { Some(*i) } else { None })
434 .map(|i| (i, &self.tables[i]))
435 .find(|(_, table)| table.values.is_some())
436 .map(|p| p.0)
437 })
438 };
439
440 let pos = match next_table {
441 Some(pos) => pos,
442 None => return Ok(None),
443 };
444 self.cur = pos;
445
446 // Test to see if we're duplicating our parent's table, and if so
447 // then this is an error in the toml format
448 if self.cur_parent != pos {
449 if headers_equal(
450 &self.tables[self.cur_parent].header,
451 &self.tables[pos].header,
452 ) {
453 let at = self.tables[pos].at;
454 let name = self.tables[pos]
455 .header
456 .iter()
457 .map(|k| k.1.to_owned())
458 .collect::<Vec<_>>()
459 .join(".");
460 return Err(self.de.error(at, ErrorKind::DuplicateTable(name)));
461 }
462
463 // If we're here we know we should share the same prefix, and if
464 // the longer table was defined first then we want to narrow
465 // down our parent's length if possible to ensure that we catch
466 // duplicate tables defined afterwards.
467 if !self.de.allow_duplciate_after_longer_table {
468 let parent_len = self.tables[self.cur_parent].header.len();
469 let cur_len = self.tables[pos].header.len();
470 if cur_len < parent_len {
471 self.cur_parent = pos;
472 }
473 }
474 }
475
476 let table = &mut self.tables[pos];
477
478 // If we're not yet at the appropriate depth for this table then we
479 // just next the next portion of its header and then continue
480 // decoding.
481 if self.depth != table.header.len() {
482 let key = &table.header[self.depth];
483 let key = seed.deserialize(StrDeserializer::spanned(key.clone()))?;
484 return Ok(Some(key));
485 }
486
487 // Rule out cases like:
488 //
489 // [[foo.bar]]
490 // [[foo]]
491 if table.array {
492 let kind = ErrorKind::RedefineAsArray;
493 return Err(self.de.error(table.at, kind));
494 }
495
496 self.values = table
497 .values
498 .take()
499 .expect("Unable to read table values")
500 .into_iter()
501 .peekable();
502 }
503 }
504
next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error> where V: de::DeserializeSeed<'de>,505 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
506 where
507 V: de::DeserializeSeed<'de>,
508 {
509 if let Some((k, v)) = self.next_value.take() {
510 match seed.deserialize(ValueDeserializer::new(v)) {
511 Ok(v) => return Ok(v),
512 Err(mut e) => {
513 e.add_key_context(&k.1);
514 return Err(e);
515 }
516 }
517 }
518
519 let array =
520 self.tables[self.cur].array && self.depth == self.tables[self.cur].header.len() - 1;
521 self.cur += 1;
522 let res = seed.deserialize(MapVisitor {
523 values: Vec::new().into_iter().peekable(),
524 next_value: None,
525 depth: self.depth + if array { 0 } else { 1 },
526 cur_parent: self.cur - 1,
527 cur: 0,
528 max: self.max,
529 array,
530 table_indices: &*self.table_indices,
531 table_pindices: &*self.table_pindices,
532 tables: &mut *self.tables,
533 de: &mut *self.de,
534 });
535 res.map_err(|mut e| {
536 e.add_key_context(&self.tables[self.cur - 1].header[self.depth].1);
537 e
538 })
539 }
540 }
541
542 impl<'de, 'b> de::SeqAccess<'de> for MapVisitor<'de, 'b> {
543 type Error = Error;
544
next_element_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error> where K: de::DeserializeSeed<'de>,545 fn next_element_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
546 where
547 K: de::DeserializeSeed<'de>,
548 {
549 assert!(self.next_value.is_none());
550 assert!(self.values.next().is_none());
551
552 if self.cur_parent == self.max {
553 return Ok(None);
554 }
555
556 let header_stripped = self.tables[self.cur_parent]
557 .header
558 .iter()
559 .map(|v| v.1.clone())
560 .collect::<Vec<_>>();
561 let start_idx = self.cur_parent + 1;
562 let next = self
563 .table_indices
564 .get(&header_stripped)
565 .and_then(|entries| {
566 let start = entries.binary_search(&start_idx).unwrap_or_else(|v| v);
567 if start == entries.len() || entries[start] < start_idx {
568 return None;
569 }
570 entries[start..]
571 .iter()
572 .filter_map(|i| if *i < self.max { Some(*i) } else { None })
573 .map(|i| (i, &self.tables[i]))
574 .find(|(_, table)| table.array)
575 .map(|p| p.0)
576 })
577 .unwrap_or(self.max);
578
579 let ret = seed.deserialize(MapVisitor {
580 values: self.tables[self.cur_parent]
581 .values
582 .take()
583 .expect("Unable to read table values")
584 .into_iter()
585 .peekable(),
586 next_value: None,
587 depth: self.depth + 1,
588 cur_parent: self.cur_parent,
589 max: next,
590 cur: 0,
591 array: false,
592 table_indices: &*self.table_indices,
593 table_pindices: &*self.table_pindices,
594 tables: &mut self.tables,
595 de: &mut self.de,
596 })?;
597 self.cur_parent = next;
598 Ok(Some(ret))
599 }
600 }
601
602 impl<'de, 'b> de::Deserializer<'de> for MapVisitor<'de, 'b> {
603 type Error = Error;
604
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> where V: de::Visitor<'de>,605 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
606 where
607 V: de::Visitor<'de>,
608 {
609 if self.array {
610 visitor.visit_seq(self)
611 } else {
612 visitor.visit_map(self)
613 }
614 }
615
616 // `None` is interpreted as a missing field so be sure to implement `Some`
617 // as a present field.
deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error> where V: de::Visitor<'de>,618 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
619 where
620 V: de::Visitor<'de>,
621 {
622 visitor.visit_some(self)
623 }
624
deserialize_newtype_struct<V>( self, _name: &'static str, visitor: V, ) -> Result<V::Value, Error> where V: de::Visitor<'de>,625 fn deserialize_newtype_struct<V>(
626 self,
627 _name: &'static str,
628 visitor: V,
629 ) -> Result<V::Value, Error>
630 where
631 V: de::Visitor<'de>,
632 {
633 visitor.visit_newtype_struct(self)
634 }
635
deserialize_struct<V>( mut self, name: &'static str, fields: &'static [&'static str], visitor: V, ) -> Result<V::Value, Error> where V: de::Visitor<'de>,636 fn deserialize_struct<V>(
637 mut self,
638 name: &'static str,
639 fields: &'static [&'static str],
640 visitor: V,
641 ) -> Result<V::Value, Error>
642 where
643 V: de::Visitor<'de>,
644 {
645 if name == spanned::NAME
646 && fields == [spanned::START, spanned::END, spanned::VALUE]
647 && !(self.array && !self.values.peek().is_none())
648 {
649 // TODO we can't actually emit spans here for the *entire* table/array
650 // due to the format that toml uses. Setting the start and end to 0 is
651 // *detectable* (and no reasonable span would look like that),
652 // it would be better to expose this in the API via proper
653 // ADTs like Option<T>.
654 let start = 0;
655 let end = 0;
656
657 let res = visitor.visit_map(SpannedDeserializer {
658 phantom_data: PhantomData,
659 start: Some(start),
660 value: Some(self),
661 end: Some(end),
662 });
663 return res;
664 }
665
666 self.deserialize_any(visitor)
667 }
668
deserialize_enum<V>( self, _name: &'static str, _variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Error> where V: de::Visitor<'de>,669 fn deserialize_enum<V>(
670 self,
671 _name: &'static str,
672 _variants: &'static [&'static str],
673 visitor: V,
674 ) -> Result<V::Value, Error>
675 where
676 V: de::Visitor<'de>,
677 {
678 if self.tables.len() != 1 {
679 return Err(Error::custom(
680 Some(self.cur),
681 "enum table must contain exactly one table".into(),
682 ));
683 }
684 let table = &mut self.tables[0];
685 let values = table.values.take().expect("table has no values?");
686 if table.header.is_empty() {
687 return Err(self.de.error(self.cur, ErrorKind::EmptyTableKey));
688 }
689 let name = table.header[table.header.len() - 1].1.to_owned();
690 visitor.visit_enum(DottedTableDeserializer {
691 name,
692 value: Value {
693 e: E::DottedTable(values),
694 start: 0,
695 end: 0,
696 },
697 })
698 }
699
700 serde::forward_to_deserialize_any! {
701 bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
702 bytes byte_buf map unit identifier
703 ignored_any unit_struct tuple_struct tuple
704 }
705 }
706
707 struct StrDeserializer<'a> {
708 span: Option<Span>,
709 key: Cow<'a, str>,
710 }
711
712 impl<'a> StrDeserializer<'a> {
spanned(inner: (Span, Cow<'a, str>)) -> StrDeserializer<'a>713 fn spanned(inner: (Span, Cow<'a, str>)) -> StrDeserializer<'a> {
714 StrDeserializer {
715 span: Some(inner.0),
716 key: inner.1,
717 }
718 }
new(key: Cow<'a, str>) -> StrDeserializer<'a>719 fn new(key: Cow<'a, str>) -> StrDeserializer<'a> {
720 StrDeserializer { span: None, key }
721 }
722 }
723
724 impl<'a, 'b> de::IntoDeserializer<'a, Error> for StrDeserializer<'a> {
725 type Deserializer = Self;
726
into_deserializer(self) -> Self::Deserializer727 fn into_deserializer(self) -> Self::Deserializer {
728 self
729 }
730 }
731
732 impl<'de> de::Deserializer<'de> for StrDeserializer<'de> {
733 type Error = Error;
734
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> where V: de::Visitor<'de>,735 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
736 where
737 V: de::Visitor<'de>,
738 {
739 match self.key {
740 Cow::Borrowed(s) => visitor.visit_borrowed_str(s),
741 Cow::Owned(s) => visitor.visit_string(s),
742 }
743 }
744
deserialize_struct<V>( self, name: &'static str, fields: &'static [&'static str], visitor: V, ) -> Result<V::Value, Error> where V: de::Visitor<'de>,745 fn deserialize_struct<V>(
746 self,
747 name: &'static str,
748 fields: &'static [&'static str],
749 visitor: V,
750 ) -> Result<V::Value, Error>
751 where
752 V: de::Visitor<'de>,
753 {
754 if name == spanned::NAME && fields == [spanned::START, spanned::END, spanned::VALUE] {
755 if let Some(span) = self.span {
756 return visitor.visit_map(SpannedDeserializer {
757 phantom_data: PhantomData,
758 start: Some(span.start),
759 value: Some(StrDeserializer::new(self.key)),
760 end: Some(span.end),
761 });
762 }
763 }
764 self.deserialize_any(visitor)
765 }
766
767 serde::forward_to_deserialize_any! {
768 bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
769 bytes byte_buf map option unit newtype_struct
770 ignored_any unit_struct tuple_struct tuple enum identifier
771 }
772 }
773
774 struct ValueDeserializer<'a> {
775 value: Value<'a>,
776 validate_struct_keys: bool,
777 }
778
779 impl<'a> ValueDeserializer<'a> {
new(value: Value<'a>) -> ValueDeserializer<'a>780 fn new(value: Value<'a>) -> ValueDeserializer<'a> {
781 ValueDeserializer {
782 value,
783 validate_struct_keys: false,
784 }
785 }
786
with_struct_key_validation(mut self) -> Self787 fn with_struct_key_validation(mut self) -> Self {
788 self.validate_struct_keys = true;
789 self
790 }
791 }
792
793 impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> {
794 type Error = Error;
795
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> where V: de::Visitor<'de>,796 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
797 where
798 V: de::Visitor<'de>,
799 {
800 let start = self.value.start;
801 let res = match self.value.e {
802 E::Integer(i) => visitor.visit_i64(i),
803 E::Boolean(b) => visitor.visit_bool(b),
804 E::Float(f) => visitor.visit_f64(f),
805 E::String(Cow::Borrowed(s)) => visitor.visit_borrowed_str(s),
806 E::String(Cow::Owned(s)) => visitor.visit_string(s),
807 E::Datetime(s) => visitor.visit_map(DatetimeDeserializer {
808 date: s,
809 visited: false,
810 }),
811 E::Array(values) => {
812 let mut s = de::value::SeqDeserializer::new(values.into_iter());
813 let ret = visitor.visit_seq(&mut s)?;
814 s.end()?;
815 Ok(ret)
816 }
817 E::InlineTable(values) | E::DottedTable(values) => {
818 visitor.visit_map(InlineTableDeserializer {
819 values: values.into_iter(),
820 next_value: None,
821 })
822 }
823 };
824 res.map_err(|mut err| {
825 // Attribute the error to whatever value returned the error.
826 err.fix_offset(|| Some(start));
827 err
828 })
829 }
830
deserialize_struct<V>( self, name: &'static str, fields: &'static [&'static str], visitor: V, ) -> Result<V::Value, Error> where V: de::Visitor<'de>,831 fn deserialize_struct<V>(
832 self,
833 name: &'static str,
834 fields: &'static [&'static str],
835 visitor: V,
836 ) -> Result<V::Value, Error>
837 where
838 V: de::Visitor<'de>,
839 {
840 if name == datetime::NAME && fields == [datetime::FIELD] {
841 if let E::Datetime(s) = self.value.e {
842 return visitor.visit_map(DatetimeDeserializer {
843 date: s,
844 visited: false,
845 });
846 }
847 }
848
849 if self.validate_struct_keys {
850 match self.value.e {
851 E::InlineTable(ref values) | E::DottedTable(ref values) => {
852 let extra_fields = values
853 .iter()
854 .filter_map(|key_value| {
855 let (ref key, ref _val) = *key_value;
856 if !fields.contains(&&*(key.1)) {
857 Some(key.clone())
858 } else {
859 None
860 }
861 })
862 .collect::<Vec<_>>();
863
864 if !extra_fields.is_empty() {
865 return Err(Error::from_kind(
866 Some(self.value.start),
867 ErrorKind::UnexpectedKeys {
868 keys: extra_fields
869 .iter()
870 .map(|k| k.1.to_string())
871 .collect::<Vec<_>>(),
872 available: fields,
873 },
874 ));
875 }
876 }
877 _ => {}
878 }
879 }
880
881 if name == spanned::NAME && fields == [spanned::START, spanned::END, spanned::VALUE] {
882 let start = self.value.start;
883 let end = self.value.end;
884
885 return visitor.visit_map(SpannedDeserializer {
886 phantom_data: PhantomData,
887 start: Some(start),
888 value: Some(self.value),
889 end: Some(end),
890 });
891 }
892
893 self.deserialize_any(visitor)
894 }
895
896 // `None` is interpreted as a missing field so be sure to implement `Some`
897 // as a present field.
deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error> where V: de::Visitor<'de>,898 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
899 where
900 V: de::Visitor<'de>,
901 {
902 visitor.visit_some(self)
903 }
904
deserialize_enum<V>( self, _name: &'static str, _variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Error> where V: de::Visitor<'de>,905 fn deserialize_enum<V>(
906 self,
907 _name: &'static str,
908 _variants: &'static [&'static str],
909 visitor: V,
910 ) -> Result<V::Value, Error>
911 where
912 V: de::Visitor<'de>,
913 {
914 match self.value.e {
915 E::String(val) => visitor.visit_enum(val.into_deserializer()),
916 E::InlineTable(values) => {
917 if values.len() != 1 {
918 Err(Error::from_kind(
919 Some(self.value.start),
920 ErrorKind::Wanted {
921 expected: "exactly 1 element",
922 found: if values.is_empty() {
923 "zero elements"
924 } else {
925 "more than 1 element"
926 },
927 },
928 ))
929 } else {
930 visitor.visit_enum(InlineTableDeserializer {
931 values: values.into_iter(),
932 next_value: None,
933 })
934 }
935 }
936 e => Err(Error::from_kind(
937 Some(self.value.start),
938 ErrorKind::Wanted {
939 expected: "string or inline table",
940 found: e.type_name(),
941 },
942 )),
943 }
944 }
945
deserialize_newtype_struct<V>( self, _name: &'static str, visitor: V, ) -> Result<V::Value, Error> where V: de::Visitor<'de>,946 fn deserialize_newtype_struct<V>(
947 self,
948 _name: &'static str,
949 visitor: V,
950 ) -> Result<V::Value, Error>
951 where
952 V: de::Visitor<'de>,
953 {
954 visitor.visit_newtype_struct(self)
955 }
956
957 serde::forward_to_deserialize_any! {
958 bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
959 bytes byte_buf map unit identifier
960 ignored_any unit_struct tuple_struct tuple
961 }
962 }
963
964 impl<'de, 'b> de::IntoDeserializer<'de, Error> for MapVisitor<'de, 'b> {
965 type Deserializer = MapVisitor<'de, 'b>;
966
into_deserializer(self) -> Self::Deserializer967 fn into_deserializer(self) -> Self::Deserializer {
968 self
969 }
970 }
971
972 impl<'de, 'b> de::IntoDeserializer<'de, Error> for &'b mut Deserializer<'de> {
973 type Deserializer = Self;
974
into_deserializer(self) -> Self::Deserializer975 fn into_deserializer(self) -> Self::Deserializer {
976 self
977 }
978 }
979
980 impl<'de> de::IntoDeserializer<'de, Error> for Value<'de> {
981 type Deserializer = ValueDeserializer<'de>;
982
into_deserializer(self) -> Self::Deserializer983 fn into_deserializer(self) -> Self::Deserializer {
984 ValueDeserializer::new(self)
985 }
986 }
987
988 struct SpannedDeserializer<'de, T: de::IntoDeserializer<'de, Error>> {
989 phantom_data: PhantomData<&'de ()>,
990 start: Option<usize>,
991 end: Option<usize>,
992 value: Option<T>,
993 }
994
995 impl<'de, T> de::MapAccess<'de> for SpannedDeserializer<'de, T>
996 where
997 T: de::IntoDeserializer<'de, Error>,
998 {
999 type Error = Error;
1000
next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error> where K: de::DeserializeSeed<'de>,1001 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
1002 where
1003 K: de::DeserializeSeed<'de>,
1004 {
1005 if self.start.is_some() {
1006 seed.deserialize(BorrowedStrDeserializer::new(spanned::START))
1007 .map(Some)
1008 } else if self.end.is_some() {
1009 seed.deserialize(BorrowedStrDeserializer::new(spanned::END))
1010 .map(Some)
1011 } else if self.value.is_some() {
1012 seed.deserialize(BorrowedStrDeserializer::new(spanned::VALUE))
1013 .map(Some)
1014 } else {
1015 Ok(None)
1016 }
1017 }
1018
next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error> where V: de::DeserializeSeed<'de>,1019 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
1020 where
1021 V: de::DeserializeSeed<'de>,
1022 {
1023 if let Some(start) = self.start.take() {
1024 seed.deserialize(start.into_deserializer())
1025 } else if let Some(end) = self.end.take() {
1026 seed.deserialize(end.into_deserializer())
1027 } else if let Some(value) = self.value.take() {
1028 seed.deserialize(value.into_deserializer())
1029 } else {
1030 panic!("next_value_seed called before next_key_seed")
1031 }
1032 }
1033 }
1034
1035 struct DatetimeDeserializer<'a> {
1036 visited: bool,
1037 date: &'a str,
1038 }
1039
1040 impl<'de> de::MapAccess<'de> for DatetimeDeserializer<'de> {
1041 type Error = Error;
1042
next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error> where K: de::DeserializeSeed<'de>,1043 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
1044 where
1045 K: de::DeserializeSeed<'de>,
1046 {
1047 if self.visited {
1048 return Ok(None);
1049 }
1050 self.visited = true;
1051 seed.deserialize(DatetimeFieldDeserializer).map(Some)
1052 }
1053
next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error> where V: de::DeserializeSeed<'de>,1054 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
1055 where
1056 V: de::DeserializeSeed<'de>,
1057 {
1058 seed.deserialize(StrDeserializer::new(self.date.into()))
1059 }
1060 }
1061
1062 struct DatetimeFieldDeserializer;
1063
1064 impl<'de> de::Deserializer<'de> for DatetimeFieldDeserializer {
1065 type Error = Error;
1066
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> where V: de::Visitor<'de>,1067 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
1068 where
1069 V: de::Visitor<'de>,
1070 {
1071 visitor.visit_borrowed_str(datetime::FIELD)
1072 }
1073
1074 serde::forward_to_deserialize_any! {
1075 bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
1076 bytes byte_buf map struct option unit newtype_struct
1077 ignored_any unit_struct tuple_struct tuple enum identifier
1078 }
1079 }
1080
1081 struct DottedTableDeserializer<'a> {
1082 name: Cow<'a, str>,
1083 value: Value<'a>,
1084 }
1085
1086 impl<'de> de::EnumAccess<'de> for DottedTableDeserializer<'de> {
1087 type Error = Error;
1088 type Variant = TableEnumDeserializer<'de>;
1089
variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error> where V: de::DeserializeSeed<'de>,1090 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
1091 where
1092 V: de::DeserializeSeed<'de>,
1093 {
1094 let (name, value) = (self.name, self.value);
1095 seed.deserialize(StrDeserializer::new(name))
1096 .map(|val| (val, TableEnumDeserializer { value }))
1097 }
1098 }
1099
1100 struct InlineTableDeserializer<'a> {
1101 values: vec::IntoIter<TablePair<'a>>,
1102 next_value: Option<Value<'a>>,
1103 }
1104
1105 impl<'de> de::MapAccess<'de> for InlineTableDeserializer<'de> {
1106 type Error = Error;
1107
next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error> where K: de::DeserializeSeed<'de>,1108 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
1109 where
1110 K: de::DeserializeSeed<'de>,
1111 {
1112 let (key, value) = match self.values.next() {
1113 Some(pair) => pair,
1114 None => return Ok(None),
1115 };
1116 self.next_value = Some(value);
1117 seed.deserialize(StrDeserializer::spanned(key)).map(Some)
1118 }
1119
next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error> where V: de::DeserializeSeed<'de>,1120 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
1121 where
1122 V: de::DeserializeSeed<'de>,
1123 {
1124 let value = self.next_value.take().expect("Unable to read table values");
1125 seed.deserialize(ValueDeserializer::new(value))
1126 }
1127 }
1128
1129 impl<'de> de::EnumAccess<'de> for InlineTableDeserializer<'de> {
1130 type Error = Error;
1131 type Variant = TableEnumDeserializer<'de>;
1132
variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error> where V: de::DeserializeSeed<'de>,1133 fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
1134 where
1135 V: de::DeserializeSeed<'de>,
1136 {
1137 let (key, value) = match self.values.next() {
1138 Some(pair) => pair,
1139 None => {
1140 return Err(Error::from_kind(
1141 None, // FIXME: How do we get an offset here?
1142 ErrorKind::Wanted {
1143 expected: "table with exactly 1 entry",
1144 found: "empty table",
1145 },
1146 ));
1147 }
1148 };
1149
1150 seed.deserialize(StrDeserializer::new(key.1))
1151 .map(|val| (val, TableEnumDeserializer { value }))
1152 }
1153 }
1154
1155 /// Deserializes table values into enum variants.
1156 struct TableEnumDeserializer<'a> {
1157 value: Value<'a>,
1158 }
1159
1160 impl<'de> de::VariantAccess<'de> for TableEnumDeserializer<'de> {
1161 type Error = Error;
1162
unit_variant(self) -> Result<(), Self::Error>1163 fn unit_variant(self) -> Result<(), Self::Error> {
1164 match self.value.e {
1165 E::InlineTable(values) | E::DottedTable(values) => {
1166 if values.is_empty() {
1167 Ok(())
1168 } else {
1169 Err(Error::from_kind(
1170 Some(self.value.start),
1171 ErrorKind::ExpectedEmptyTable,
1172 ))
1173 }
1174 }
1175 e => Err(Error::from_kind(
1176 Some(self.value.start),
1177 ErrorKind::Wanted {
1178 expected: "table",
1179 found: e.type_name(),
1180 },
1181 )),
1182 }
1183 }
1184
newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error> where T: de::DeserializeSeed<'de>,1185 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
1186 where
1187 T: de::DeserializeSeed<'de>,
1188 {
1189 seed.deserialize(ValueDeserializer::new(self.value))
1190 }
1191
tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1192 fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
1193 where
1194 V: de::Visitor<'de>,
1195 {
1196 match self.value.e {
1197 E::InlineTable(values) | E::DottedTable(values) => {
1198 let tuple_values = values
1199 .into_iter()
1200 .enumerate()
1201 .map(|(index, (key, value))| match key.1.parse::<usize>() {
1202 Ok(key_index) if key_index == index => Ok(value),
1203 Ok(_) | Err(_) => Err(Error::from_kind(
1204 Some(key.0.start),
1205 ErrorKind::ExpectedTupleIndex {
1206 expected: index,
1207 found: key.1.to_string(),
1208 },
1209 )),
1210 })
1211 // Fold all values into a `Vec`, or return the first error.
1212 .fold(Ok(Vec::with_capacity(len)), |result, value_result| {
1213 result.and_then(move |mut tuple_values| match value_result {
1214 Ok(value) => {
1215 tuple_values.push(value);
1216 Ok(tuple_values)
1217 }
1218 // `Result<de::Value, Self::Error>` to `Result<Vec<_>, Self::Error>`
1219 Err(e) => Err(e),
1220 })
1221 })?;
1222
1223 if tuple_values.len() == len {
1224 de::Deserializer::deserialize_seq(
1225 ValueDeserializer::new(Value {
1226 e: E::Array(tuple_values),
1227 start: self.value.start,
1228 end: self.value.end,
1229 }),
1230 visitor,
1231 )
1232 } else {
1233 Err(Error::from_kind(
1234 Some(self.value.start),
1235 ErrorKind::ExpectedTuple(len),
1236 ))
1237 }
1238 }
1239 e => Err(Error::from_kind(
1240 Some(self.value.start),
1241 ErrorKind::Wanted {
1242 expected: "table",
1243 found: e.type_name(),
1244 },
1245 )),
1246 }
1247 }
1248
struct_variant<V>( self, fields: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1249 fn struct_variant<V>(
1250 self,
1251 fields: &'static [&'static str],
1252 visitor: V,
1253 ) -> Result<V::Value, Self::Error>
1254 where
1255 V: de::Visitor<'de>,
1256 {
1257 de::Deserializer::deserialize_struct(
1258 ValueDeserializer::new(self.value).with_struct_key_validation(),
1259 "", // TODO: this should be the variant name
1260 fields,
1261 visitor,
1262 )
1263 }
1264 }
1265
1266 impl<'a> Deserializer<'a> {
1267 /// Creates a new deserializer which will be deserializing the string
1268 /// provided.
new(input: &'a str) -> Deserializer<'a>1269 pub fn new(input: &'a str) -> Deserializer<'a> {
1270 Deserializer {
1271 tokens: Tokenizer::new(input),
1272 input,
1273 require_newline_after_table: true,
1274 allow_duplciate_after_longer_table: false,
1275 }
1276 }
1277
1278 /// The `Deserializer::end` method should be called after a value has been
1279 /// fully deserialized. This allows the `Deserializer` to validate that the
1280 /// input stream is at the end or that it only has trailing
1281 /// whitespace/comments.
end(&mut self) -> Result<(), Error>1282 pub fn end(&mut self) -> Result<(), Error> {
1283 Ok(())
1284 }
1285
1286 /// Historical versions of toml-rs accidentally allowed a newline after a
1287 /// table definition, but the TOML spec requires a newline after a table
1288 /// definition header.
1289 ///
1290 /// This option can be set to `false` (the default is `true`) to emulate
1291 /// this behavior for backwards compatibility with older toml-rs versions.
set_require_newline_after_table(&mut self, require: bool)1292 pub fn set_require_newline_after_table(&mut self, require: bool) {
1293 self.require_newline_after_table = require;
1294 }
1295
1296 /// Historical versions of toml-rs accidentally allowed a duplicate table
1297 /// header after a longer table header was previously defined. This is
1298 /// invalid according to the TOML spec, however.
1299 ///
1300 /// This option can be set to `true` (the default is `false`) to emulate
1301 /// this behavior for backwards compatibility with older toml-rs versions.
set_allow_duplicate_after_longer_table(&mut self, allow: bool)1302 pub fn set_allow_duplicate_after_longer_table(&mut self, allow: bool) {
1303 self.allow_duplciate_after_longer_table = allow;
1304 }
1305
tables(&mut self) -> Result<Vec<Table<'a>>, Error>1306 fn tables(&mut self) -> Result<Vec<Table<'a>>, Error> {
1307 let mut tables = Vec::new();
1308 let mut cur_table = Table {
1309 at: 0,
1310 header: Vec::new(),
1311 values: None,
1312 array: false,
1313 };
1314
1315 while let Some(line) = self.line()? {
1316 match line {
1317 Line::Table {
1318 at,
1319 mut header,
1320 array,
1321 } => {
1322 if !cur_table.header.is_empty() || cur_table.values.is_some() {
1323 tables.push(cur_table);
1324 }
1325 cur_table = Table {
1326 at,
1327 header: Vec::new(),
1328 values: Some(Vec::new()),
1329 array,
1330 };
1331 loop {
1332 let part = header.next().map_err(|e| self.token_error(e));
1333 match part? {
1334 Some(part) => cur_table.header.push(part),
1335 None => break,
1336 }
1337 }
1338 }
1339 Line::KeyValue(key, value) => {
1340 if cur_table.values.is_none() {
1341 cur_table.values = Some(Vec::new());
1342 }
1343 self.add_dotted_key(key, value, cur_table.values.as_mut().unwrap())?;
1344 }
1345 }
1346 }
1347 if !cur_table.header.is_empty() || cur_table.values.is_some() {
1348 tables.push(cur_table);
1349 }
1350 Ok(tables)
1351 }
1352
line(&mut self) -> Result<Option<Line<'a>>, Error>1353 fn line(&mut self) -> Result<Option<Line<'a>>, Error> {
1354 loop {
1355 self.eat_whitespace()?;
1356 if self.eat_comment()? {
1357 continue;
1358 }
1359 if self.eat(Token::Newline)? {
1360 continue;
1361 }
1362 break;
1363 }
1364
1365 match self.peek()? {
1366 Some((_, Token::LeftBracket)) => self.table_header().map(Some),
1367 Some(_) => self.key_value().map(Some),
1368 None => Ok(None),
1369 }
1370 }
1371
table_header(&mut self) -> Result<Line<'a>, Error>1372 fn table_header(&mut self) -> Result<Line<'a>, Error> {
1373 let start = self.tokens.current();
1374 self.expect(Token::LeftBracket)?;
1375 let array = self.eat(Token::LeftBracket)?;
1376 let ret = Header::new(self.tokens.clone(), array, self.require_newline_after_table);
1377 if self.require_newline_after_table {
1378 self.tokens.skip_to_newline();
1379 } else {
1380 loop {
1381 match self.next()? {
1382 Some((_, Token::RightBracket)) => {
1383 if array {
1384 self.eat(Token::RightBracket)?;
1385 }
1386 break;
1387 }
1388 Some((_, Token::Newline)) | None => break,
1389 _ => {}
1390 }
1391 }
1392 self.eat_whitespace()?;
1393 }
1394 Ok(Line::Table {
1395 at: start,
1396 header: ret,
1397 array,
1398 })
1399 }
1400
key_value(&mut self) -> Result<Line<'a>, Error>1401 fn key_value(&mut self) -> Result<Line<'a>, Error> {
1402 let key = self.dotted_key()?;
1403 self.eat_whitespace()?;
1404 self.expect(Token::Equals)?;
1405 self.eat_whitespace()?;
1406
1407 let value = self.value()?;
1408 self.eat_whitespace()?;
1409 if !self.eat_comment()? {
1410 self.eat_newline_or_eof()?;
1411 }
1412
1413 Ok(Line::KeyValue(key, value))
1414 }
1415
value(&mut self) -> Result<Value<'a>, Error>1416 fn value(&mut self) -> Result<Value<'a>, Error> {
1417 let at = self.tokens.current();
1418 let value = match self.next()? {
1419 Some((Span { start, end }, Token::String { val, .. })) => Value {
1420 e: E::String(val),
1421 start,
1422 end,
1423 },
1424 Some((Span { start, end }, Token::Keylike("true"))) => Value {
1425 e: E::Boolean(true),
1426 start,
1427 end,
1428 },
1429 Some((Span { start, end }, Token::Keylike("false"))) => Value {
1430 e: E::Boolean(false),
1431 start,
1432 end,
1433 },
1434 Some((span, Token::Keylike(key))) => self.parse_keylike(at, span, key)?,
1435 Some((span, Token::Plus)) => self.number_leading_plus(span)?,
1436 Some((Span { start, .. }, Token::LeftBrace)) => {
1437 self.inline_table().map(|(Span { end, .. }, table)| Value {
1438 e: E::InlineTable(table),
1439 start,
1440 end,
1441 })?
1442 }
1443 Some((Span { start, .. }, Token::LeftBracket)) => {
1444 self.array().map(|(Span { end, .. }, array)| Value {
1445 e: E::Array(array),
1446 start,
1447 end,
1448 })?
1449 }
1450 Some(token) => {
1451 return Err(self.error(
1452 at,
1453 ErrorKind::Wanted {
1454 expected: "a value",
1455 found: token.1.describe(),
1456 },
1457 ));
1458 }
1459 None => return Err(self.eof()),
1460 };
1461 Ok(value)
1462 }
1463
parse_keylike(&mut self, at: usize, span: Span, key: &'a str) -> Result<Value<'a>, Error>1464 fn parse_keylike(&mut self, at: usize, span: Span, key: &'a str) -> Result<Value<'a>, Error> {
1465 if key == "inf" || key == "nan" {
1466 return self.number_or_date(span, key);
1467 }
1468
1469 let first_char = key.chars().next().expect("key should not be empty here");
1470 match first_char {
1471 '-' | '0'..='9' => self.number_or_date(span, key),
1472 _ => Err(self.error(at, ErrorKind::UnquotedString)),
1473 }
1474 }
1475
number_or_date(&mut self, span: Span, s: &'a str) -> Result<Value<'a>, Error>1476 fn number_or_date(&mut self, span: Span, s: &'a str) -> Result<Value<'a>, Error> {
1477 if s.contains('T')
1478 || s.contains('t')
1479 || (s.len() > 1 && s[1..].contains('-') && !s.contains("e-") && !s.contains("E-"))
1480 {
1481 self.datetime(span, s, false)
1482 .map(|(Span { start, end }, d)| Value {
1483 e: E::Datetime(d),
1484 start,
1485 end,
1486 })
1487 } else if self.eat(Token::Colon)? {
1488 self.datetime(span, s, true)
1489 .map(|(Span { start, end }, d)| Value {
1490 e: E::Datetime(d),
1491 start,
1492 end,
1493 })
1494 } else {
1495 self.number(span, s)
1496 }
1497 }
1498
1499 /// Returns a string or table value type.
1500 ///
1501 /// Used to deserialize enums. Unit enums may be represented as a string or a table, all other
1502 /// structures (tuple, newtype, struct) must be represented as a table.
string_or_table(&mut self) -> Result<(Value<'a>, Option<Cow<'a, str>>), Error>1503 fn string_or_table(&mut self) -> Result<(Value<'a>, Option<Cow<'a, str>>), Error> {
1504 match self.peek()? {
1505 Some((span, Token::LeftBracket)) => {
1506 let tables = self.tables()?;
1507 if tables.len() != 1 {
1508 return Err(Error::from_kind(
1509 Some(span.start),
1510 ErrorKind::Wanted {
1511 expected: "exactly 1 table",
1512 found: if tables.is_empty() {
1513 "zero tables"
1514 } else {
1515 "more than 1 table"
1516 },
1517 },
1518 ));
1519 }
1520
1521 let table = tables
1522 .into_iter()
1523 .next()
1524 .expect("Expected exactly one table");
1525 let header = table
1526 .header
1527 .last()
1528 .expect("Expected at least one header value for table.");
1529
1530 let start = table.at;
1531 let end = table
1532 .values
1533 .as_ref()
1534 .and_then(|values| values.last())
1535 .map(|&(_, ref val)| val.end)
1536 .unwrap_or_else(|| header.1.len());
1537 Ok((
1538 Value {
1539 e: E::DottedTable(table.values.unwrap_or_else(Vec::new)),
1540 start,
1541 end,
1542 },
1543 Some(header.1.clone()),
1544 ))
1545 }
1546 Some(_) => self.value().map(|val| (val, None)),
1547 None => Err(self.eof()),
1548 }
1549 }
1550
1551 fn number(&mut self, Span { start, end }: Span, s: &'a str) -> Result<Value<'a>, Error> {
1552 let to_integer = |f| Value {
1553 e: E::Integer(f),
1554 start,
1555 end,
1556 };
1557 if s.starts_with("0x") {
1558 self.integer(&s[2..], 16).map(to_integer)
1559 } else if s.starts_with("0o") {
1560 self.integer(&s[2..], 8).map(to_integer)
1561 } else if s.starts_with("0b") {
1562 self.integer(&s[2..], 2).map(to_integer)
1563 } else if s.contains('e') || s.contains('E') {
1564 self.float(s, None).map(|f| Value {
1565 e: E::Float(f),
1566 start,
1567 end,
1568 })
1569 } else if self.eat(Token::Period)? {
1570 let at = self.tokens.current();
1571 match self.next()? {
1572 Some((Span { start, end }, Token::Keylike(after))) => {
1573 self.float(s, Some(after)).map(|f| Value {
1574 e: E::Float(f),
1575 start,
1576 end,
1577 })
1578 }
1579 _ => Err(self.error(at, ErrorKind::NumberInvalid)),
1580 }
1581 } else if s == "inf" {
1582 Ok(Value {
1583 e: E::Float(f64::INFINITY),
1584 start,
1585 end,
1586 })
1587 } else if s == "-inf" {
1588 Ok(Value {
1589 e: E::Float(f64::NEG_INFINITY),
1590 start,
1591 end,
1592 })
1593 } else if s == "nan" {
1594 Ok(Value {
1595 e: E::Float(f64::NAN),
1596 start,
1597 end,
1598 })
1599 } else if s == "-nan" {
1600 Ok(Value {
1601 e: E::Float(-f64::NAN),
1602 start,
1603 end,
1604 })
1605 } else {
1606 self.integer(s, 10).map(to_integer)
1607 }
1608 }
1609
1610 fn number_leading_plus(&mut self, Span { start, .. }: Span) -> Result<Value<'a>, Error> {
1611 let start_token = self.tokens.current();
1612 match self.next()? {
1613 Some((Span { end, .. }, Token::Keylike(s))) => self.number(Span { start, end }, s),
1614 _ => Err(self.error(start_token, ErrorKind::NumberInvalid)),
1615 }
1616 }
1617
integer(&self, s: &'a str, radix: u32) -> Result<i64, Error>1618 fn integer(&self, s: &'a str, radix: u32) -> Result<i64, Error> {
1619 let allow_sign = radix == 10;
1620 let allow_leading_zeros = radix != 10;
1621 let (prefix, suffix) = self.parse_integer(s, allow_sign, allow_leading_zeros, radix)?;
1622 let start = self.tokens.substr_offset(s);
1623 if suffix != "" {
1624 return Err(self.error(start, ErrorKind::NumberInvalid));
1625 }
1626 i64::from_str_radix(&prefix.replace("_", "").trim_start_matches('+'), radix)
1627 .map_err(|_e| self.error(start, ErrorKind::NumberInvalid))
1628 }
1629
parse_integer( &self, s: &'a str, allow_sign: bool, allow_leading_zeros: bool, radix: u32, ) -> Result<(&'a str, &'a str), Error>1630 fn parse_integer(
1631 &self,
1632 s: &'a str,
1633 allow_sign: bool,
1634 allow_leading_zeros: bool,
1635 radix: u32,
1636 ) -> Result<(&'a str, &'a str), Error> {
1637 let start = self.tokens.substr_offset(s);
1638
1639 let mut first = true;
1640 let mut first_zero = false;
1641 let mut underscore = false;
1642 let mut end = s.len();
1643 for (i, c) in s.char_indices() {
1644 let at = i + start;
1645 if i == 0 && (c == '+' || c == '-') && allow_sign {
1646 continue;
1647 }
1648
1649 if c == '0' && first {
1650 first_zero = true;
1651 } else if c.is_digit(radix) {
1652 if !first && first_zero && !allow_leading_zeros {
1653 return Err(self.error(at, ErrorKind::NumberInvalid));
1654 }
1655 underscore = false;
1656 } else if c == '_' && first {
1657 return Err(self.error(at, ErrorKind::NumberInvalid));
1658 } else if c == '_' && !underscore {
1659 underscore = true;
1660 } else {
1661 end = i;
1662 break;
1663 }
1664 first = false;
1665 }
1666 if first || underscore {
1667 return Err(self.error(start, ErrorKind::NumberInvalid));
1668 }
1669 Ok((&s[..end], &s[end..]))
1670 }
1671
float(&mut self, s: &'a str, after_decimal: Option<&'a str>) -> Result<f64, Error>1672 fn float(&mut self, s: &'a str, after_decimal: Option<&'a str>) -> Result<f64, Error> {
1673 let (integral, mut suffix) = self.parse_integer(s, true, false, 10)?;
1674 let start = self.tokens.substr_offset(integral);
1675
1676 let mut fraction = None;
1677 if let Some(after) = after_decimal {
1678 if suffix != "" {
1679 return Err(self.error(start, ErrorKind::NumberInvalid));
1680 }
1681 let (a, b) = self.parse_integer(after, false, true, 10)?;
1682 fraction = Some(a);
1683 suffix = b;
1684 }
1685
1686 let mut exponent = None;
1687 if suffix.starts_with('e') || suffix.starts_with('E') {
1688 let (a, b) = if suffix.len() == 1 {
1689 self.eat(Token::Plus)?;
1690 match self.next()? {
1691 Some((_, Token::Keylike(s))) => self.parse_integer(s, false, true, 10)?,
1692 _ => return Err(self.error(start, ErrorKind::NumberInvalid)),
1693 }
1694 } else {
1695 self.parse_integer(&suffix[1..], true, true, 10)?
1696 };
1697 if b != "" {
1698 return Err(self.error(start, ErrorKind::NumberInvalid));
1699 }
1700 exponent = Some(a);
1701 } else if !suffix.is_empty() {
1702 return Err(self.error(start, ErrorKind::NumberInvalid));
1703 }
1704
1705 let mut number = integral
1706 .trim_start_matches('+')
1707 .chars()
1708 .filter(|c| *c != '_')
1709 .collect::<String>();
1710 if let Some(fraction) = fraction {
1711 number.push_str(".");
1712 number.extend(fraction.chars().filter(|c| *c != '_'));
1713 }
1714 if let Some(exponent) = exponent {
1715 number.push_str("E");
1716 number.extend(exponent.chars().filter(|c| *c != '_'));
1717 }
1718 number
1719 .parse()
1720 .map_err(|_e| self.error(start, ErrorKind::NumberInvalid))
1721 .and_then(|n: f64| {
1722 if n.is_finite() {
1723 Ok(n)
1724 } else {
1725 Err(self.error(start, ErrorKind::NumberInvalid))
1726 }
1727 })
1728 }
1729
datetime( &mut self, mut span: Span, date: &'a str, colon_eaten: bool, ) -> Result<(Span, &'a str), Error>1730 fn datetime(
1731 &mut self,
1732 mut span: Span,
1733 date: &'a str,
1734 colon_eaten: bool,
1735 ) -> Result<(Span, &'a str), Error> {
1736 let start = self.tokens.substr_offset(date);
1737
1738 // Check for space separated date and time.
1739 let mut lookahead = self.tokens.clone();
1740 if let Ok(Some((_, Token::Whitespace(" ")))) = lookahead.next() {
1741 // Check if hour follows.
1742 if let Ok(Some((_, Token::Keylike(_)))) = lookahead.next() {
1743 self.next()?; // skip space
1744 self.next()?; // skip keylike hour
1745 }
1746 }
1747
1748 if colon_eaten || self.eat(Token::Colon)? {
1749 // minutes
1750 match self.next()? {
1751 Some((_, Token::Keylike(_))) => {}
1752 _ => return Err(self.error(start, ErrorKind::DateInvalid)),
1753 }
1754 // Seconds
1755 self.expect(Token::Colon)?;
1756 match self.next()? {
1757 Some((Span { end, .. }, Token::Keylike(_))) => {
1758 span.end = end;
1759 }
1760 _ => return Err(self.error(start, ErrorKind::DateInvalid)),
1761 }
1762 // Fractional seconds
1763 if self.eat(Token::Period)? {
1764 match self.next()? {
1765 Some((Span { end, .. }, Token::Keylike(_))) => {
1766 span.end = end;
1767 }
1768 _ => return Err(self.error(start, ErrorKind::DateInvalid)),
1769 }
1770 }
1771
1772 // offset
1773 if self.eat(Token::Plus)? {
1774 match self.next()? {
1775 Some((Span { end, .. }, Token::Keylike(_))) => {
1776 span.end = end;
1777 }
1778 _ => return Err(self.error(start, ErrorKind::DateInvalid)),
1779 }
1780 }
1781 if self.eat(Token::Colon)? {
1782 match self.next()? {
1783 Some((Span { end, .. }, Token::Keylike(_))) => {
1784 span.end = end;
1785 }
1786 _ => return Err(self.error(start, ErrorKind::DateInvalid)),
1787 }
1788 }
1789 }
1790
1791 let end = self.tokens.current();
1792 Ok((span, &self.tokens.input()[start..end]))
1793 }
1794
1795 // TODO(#140): shouldn't buffer up this entire table in memory, it'd be
1796 // great to defer parsing everything until later.
inline_table(&mut self) -> Result<(Span, Vec<TablePair<'a>>), Error>1797 fn inline_table(&mut self) -> Result<(Span, Vec<TablePair<'a>>), Error> {
1798 let mut ret = Vec::new();
1799 self.eat_whitespace()?;
1800 if let Some(span) = self.eat_spanned(Token::RightBrace)? {
1801 return Ok((span, ret));
1802 }
1803 loop {
1804 let key = self.dotted_key()?;
1805 self.eat_whitespace()?;
1806 self.expect(Token::Equals)?;
1807 self.eat_whitespace()?;
1808 let value = self.value()?;
1809 self.add_dotted_key(key, value, &mut ret)?;
1810
1811 self.eat_whitespace()?;
1812 if let Some(span) = self.eat_spanned(Token::RightBrace)? {
1813 return Ok((span, ret));
1814 }
1815 self.expect(Token::Comma)?;
1816 self.eat_whitespace()?;
1817 }
1818 }
1819
1820 // TODO(#140): shouldn't buffer up this entire array in memory, it'd be
1821 // great to defer parsing everything until later.
array(&mut self) -> Result<(Span, Vec<Value<'a>>), Error>1822 fn array(&mut self) -> Result<(Span, Vec<Value<'a>>), Error> {
1823 let mut ret = Vec::new();
1824
1825 let intermediate = |me: &mut Deserializer<'_>| {
1826 loop {
1827 me.eat_whitespace()?;
1828 if !me.eat(Token::Newline)? && !me.eat_comment()? {
1829 break;
1830 }
1831 }
1832 Ok(())
1833 };
1834
1835 loop {
1836 intermediate(self)?;
1837 if let Some(span) = self.eat_spanned(Token::RightBracket)? {
1838 return Ok((span, ret));
1839 }
1840 let value = self.value()?;
1841 ret.push(value);
1842 intermediate(self)?;
1843 if !self.eat(Token::Comma)? {
1844 break;
1845 }
1846 }
1847 intermediate(self)?;
1848 let span = self.expect_spanned(Token::RightBracket)?;
1849 Ok((span, ret))
1850 }
1851
table_key(&mut self) -> Result<(Span, Cow<'a, str>), Error>1852 fn table_key(&mut self) -> Result<(Span, Cow<'a, str>), Error> {
1853 self.tokens.table_key().map_err(|e| self.token_error(e))
1854 }
1855
dotted_key(&mut self) -> Result<Vec<(Span, Cow<'a, str>)>, Error>1856 fn dotted_key(&mut self) -> Result<Vec<(Span, Cow<'a, str>)>, Error> {
1857 let mut result = Vec::new();
1858 result.push(self.table_key()?);
1859 self.eat_whitespace()?;
1860 while self.eat(Token::Period)? {
1861 self.eat_whitespace()?;
1862 result.push(self.table_key()?);
1863 self.eat_whitespace()?;
1864 }
1865 Ok(result)
1866 }
1867
1868 /// Stores a value in the appropriate hierachical structure positioned based on the dotted key.
1869 ///
1870 /// Given the following definition: `multi.part.key = "value"`, `multi` and `part` are
1871 /// intermediate parts which are mapped to the relevant fields in the deserialized type's data
1872 /// hierarchy.
1873 ///
1874 /// # Parameters
1875 ///
1876 /// * `key_parts`: Each segment of the dotted key, e.g. `part.one` maps to
1877 /// `vec![Cow::Borrowed("part"), Cow::Borrowed("one")].`
1878 /// * `value`: The parsed value.
1879 /// * `values`: The `Vec` to store the value in.
add_dotted_key( &self, mut key_parts: Vec<(Span, Cow<'a, str>)>, value: Value<'a>, values: &mut Vec<TablePair<'a>>, ) -> Result<(), Error>1880 fn add_dotted_key(
1881 &self,
1882 mut key_parts: Vec<(Span, Cow<'a, str>)>,
1883 value: Value<'a>,
1884 values: &mut Vec<TablePair<'a>>,
1885 ) -> Result<(), Error> {
1886 let key = key_parts.remove(0);
1887 if key_parts.is_empty() {
1888 values.push((key, value));
1889 return Ok(());
1890 }
1891 match values.iter_mut().find(|&&mut (ref k, _)| *k.1 == key.1) {
1892 Some(&mut (
1893 _,
1894 Value {
1895 e: E::DottedTable(ref mut v),
1896 ..
1897 },
1898 )) => {
1899 return self.add_dotted_key(key_parts, value, v);
1900 }
1901 Some(&mut (_, Value { start, .. })) => {
1902 return Err(self.error(start, ErrorKind::DottedKeyInvalidType));
1903 }
1904 None => {}
1905 }
1906 // The start/end value is somewhat misleading here.
1907 let table_values = Value {
1908 e: E::DottedTable(Vec::new()),
1909 start: value.start,
1910 end: value.end,
1911 };
1912 values.push((key, table_values));
1913 let last_i = values.len() - 1;
1914 if let (
1915 _,
1916 Value {
1917 e: E::DottedTable(ref mut v),
1918 ..
1919 },
1920 ) = values[last_i]
1921 {
1922 self.add_dotted_key(key_parts, value, v)?;
1923 }
1924 Ok(())
1925 }
1926
eat_whitespace(&mut self) -> Result<(), Error>1927 fn eat_whitespace(&mut self) -> Result<(), Error> {
1928 self.tokens
1929 .eat_whitespace()
1930 .map_err(|e| self.token_error(e))
1931 }
1932
eat_comment(&mut self) -> Result<bool, Error>1933 fn eat_comment(&mut self) -> Result<bool, Error> {
1934 self.tokens.eat_comment().map_err(|e| self.token_error(e))
1935 }
1936
eat_newline_or_eof(&mut self) -> Result<(), Error>1937 fn eat_newline_or_eof(&mut self) -> Result<(), Error> {
1938 self.tokens
1939 .eat_newline_or_eof()
1940 .map_err(|e| self.token_error(e))
1941 }
1942
eat(&mut self, expected: Token<'a>) -> Result<bool, Error>1943 fn eat(&mut self, expected: Token<'a>) -> Result<bool, Error> {
1944 self.tokens.eat(expected).map_err(|e| self.token_error(e))
1945 }
1946
eat_spanned(&mut self, expected: Token<'a>) -> Result<Option<Span>, Error>1947 fn eat_spanned(&mut self, expected: Token<'a>) -> Result<Option<Span>, Error> {
1948 self.tokens
1949 .eat_spanned(expected)
1950 .map_err(|e| self.token_error(e))
1951 }
1952
expect(&mut self, expected: Token<'a>) -> Result<(), Error>1953 fn expect(&mut self, expected: Token<'a>) -> Result<(), Error> {
1954 self.tokens
1955 .expect(expected)
1956 .map_err(|e| self.token_error(e))
1957 }
1958
expect_spanned(&mut self, expected: Token<'a>) -> Result<Span, Error>1959 fn expect_spanned(&mut self, expected: Token<'a>) -> Result<Span, Error> {
1960 self.tokens
1961 .expect_spanned(expected)
1962 .map_err(|e| self.token_error(e))
1963 }
1964
next(&mut self) -> Result<Option<(Span, Token<'a>)>, Error>1965 fn next(&mut self) -> Result<Option<(Span, Token<'a>)>, Error> {
1966 self.tokens.next().map_err(|e| self.token_error(e))
1967 }
1968
peek(&mut self) -> Result<Option<(Span, Token<'a>)>, Error>1969 fn peek(&mut self) -> Result<Option<(Span, Token<'a>)>, Error> {
1970 self.tokens.peek().map_err(|e| self.token_error(e))
1971 }
1972
eof(&self) -> Error1973 fn eof(&self) -> Error {
1974 self.error(self.input.len(), ErrorKind::UnexpectedEof)
1975 }
1976
token_error(&self, error: TokenError) -> Error1977 fn token_error(&self, error: TokenError) -> Error {
1978 match error {
1979 TokenError::InvalidCharInString(at, ch) => {
1980 self.error(at, ErrorKind::InvalidCharInString(ch))
1981 }
1982 TokenError::InvalidEscape(at, ch) => self.error(at, ErrorKind::InvalidEscape(ch)),
1983 TokenError::InvalidEscapeValue(at, v) => {
1984 self.error(at, ErrorKind::InvalidEscapeValue(v))
1985 }
1986 TokenError::InvalidHexEscape(at, ch) => self.error(at, ErrorKind::InvalidHexEscape(ch)),
1987 TokenError::NewlineInString(at) => self.error(at, ErrorKind::NewlineInString),
1988 TokenError::Unexpected(at, ch) => self.error(at, ErrorKind::Unexpected(ch)),
1989 TokenError::UnterminatedString(at) => self.error(at, ErrorKind::UnterminatedString),
1990 TokenError::NewlineInTableKey(at) => self.error(at, ErrorKind::NewlineInTableKey),
1991 TokenError::Wanted {
1992 at,
1993 expected,
1994 found,
1995 } => self.error(at, ErrorKind::Wanted { expected, found }),
1996 TokenError::EmptyTableKey(at) => self.error(at, ErrorKind::EmptyTableKey),
1997 TokenError::MultilineStringKey(at) => self.error(at, ErrorKind::MultilineStringKey),
1998 }
1999 }
2000
error(&self, at: usize, kind: ErrorKind) -> Error2001 fn error(&self, at: usize, kind: ErrorKind) -> Error {
2002 let mut err = Error::from_kind(Some(at), kind);
2003 err.fix_linecol(|at| self.to_linecol(at));
2004 err
2005 }
2006
2007 /// Converts a byte offset from an error message to a (line, column) pair
2008 ///
2009 /// All indexes are 0-based.
to_linecol(&self, offset: usize) -> (usize, usize)2010 fn to_linecol(&self, offset: usize) -> (usize, usize) {
2011 let mut cur = 0;
2012 // Use split_terminator instead of lines so that if there is a `\r`,
2013 // it is included in the offset calculation. The `+1` values below
2014 // account for the `\n`.
2015 for (i, line) in self.input.split_terminator('\n').enumerate() {
2016 if cur + line.len() + 1 > offset {
2017 return (i, offset - cur);
2018 }
2019 cur += line.len() + 1;
2020 }
2021 (self.input.lines().count(), 0)
2022 }
2023 }
2024
2025 impl Error {
2026 /// Produces a (line, column) pair of the position of the error if available
2027 ///
2028 /// All indexes are 0-based.
line_col(&self) -> Option<(usize, usize)>2029 pub fn line_col(&self) -> Option<(usize, usize)> {
2030 self.inner.line.map(|line| (line, self.inner.col))
2031 }
2032
from_kind(at: Option<usize>, kind: ErrorKind) -> Error2033 fn from_kind(at: Option<usize>, kind: ErrorKind) -> Error {
2034 Error {
2035 inner: Box::new(ErrorInner {
2036 kind,
2037 line: None,
2038 col: 0,
2039 at,
2040 message: String::new(),
2041 key: Vec::new(),
2042 }),
2043 }
2044 }
2045
custom(at: Option<usize>, s: String) -> Error2046 fn custom(at: Option<usize>, s: String) -> Error {
2047 Error {
2048 inner: Box::new(ErrorInner {
2049 kind: ErrorKind::Custom,
2050 line: None,
2051 col: 0,
2052 at,
2053 message: s,
2054 key: Vec::new(),
2055 }),
2056 }
2057 }
2058
add_key_context(&mut self, key: &str)2059 pub(crate) fn add_key_context(&mut self, key: &str) {
2060 self.inner.key.insert(0, key.to_string());
2061 }
2062
fix_offset<F>(&mut self, f: F) where F: FnOnce() -> Option<usize>,2063 fn fix_offset<F>(&mut self, f: F)
2064 where
2065 F: FnOnce() -> Option<usize>,
2066 {
2067 // An existing offset is always better positioned than anything we
2068 // might want to add later.
2069 if self.inner.at.is_none() {
2070 self.inner.at = f();
2071 }
2072 }
2073
fix_linecol<F>(&mut self, f: F) where F: FnOnce(usize) -> (usize, usize),2074 fn fix_linecol<F>(&mut self, f: F)
2075 where
2076 F: FnOnce(usize) -> (usize, usize),
2077 {
2078 if let Some(at) = self.inner.at {
2079 let (line, col) = f(at);
2080 self.inner.line = Some(line);
2081 self.inner.col = col;
2082 }
2083 }
2084 }
2085
2086 impl std::convert::From<Error> for std::io::Error {
from(e: Error) -> Self2087 fn from(e: Error) -> Self {
2088 std::io::Error::new(std::io::ErrorKind::InvalidData, e.to_string())
2089 }
2090 }
2091
2092 impl fmt::Display for Error {
fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result2093 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2094 match &self.inner.kind {
2095 ErrorKind::UnexpectedEof => "unexpected eof encountered".fmt(f)?,
2096 ErrorKind::InvalidCharInString(c) => write!(
2097 f,
2098 "invalid character in string: `{}`",
2099 c.escape_default().collect::<String>()
2100 )?,
2101 ErrorKind::InvalidEscape(c) => write!(
2102 f,
2103 "invalid escape character in string: `{}`",
2104 c.escape_default().collect::<String>()
2105 )?,
2106 ErrorKind::InvalidHexEscape(c) => write!(
2107 f,
2108 "invalid hex escape character in string: `{}`",
2109 c.escape_default().collect::<String>()
2110 )?,
2111 ErrorKind::InvalidEscapeValue(c) => write!(f, "invalid escape value: `{}`", c)?,
2112 ErrorKind::NewlineInString => "newline in string found".fmt(f)?,
2113 ErrorKind::Unexpected(ch) => write!(
2114 f,
2115 "unexpected character found: `{}`",
2116 ch.escape_default().collect::<String>()
2117 )?,
2118 ErrorKind::UnterminatedString => "unterminated string".fmt(f)?,
2119 ErrorKind::NewlineInTableKey => "found newline in table key".fmt(f)?,
2120 ErrorKind::Wanted { expected, found } => {
2121 write!(f, "expected {}, found {}", expected, found)?
2122 }
2123 ErrorKind::NumberInvalid => "invalid number".fmt(f)?,
2124 ErrorKind::DateInvalid => "invalid date".fmt(f)?,
2125 ErrorKind::DuplicateTable(ref s) => {
2126 write!(f, "redefinition of table `{}`", s)?;
2127 }
2128 ErrorKind::RedefineAsArray => "table redefined as array".fmt(f)?,
2129 ErrorKind::EmptyTableKey => "empty table key found".fmt(f)?,
2130 ErrorKind::MultilineStringKey => "multiline strings are not allowed for key".fmt(f)?,
2131 ErrorKind::Custom => self.inner.message.fmt(f)?,
2132 ErrorKind::ExpectedTuple(l) => write!(f, "expected table with length {}", l)?,
2133 ErrorKind::ExpectedTupleIndex {
2134 expected,
2135 ref found,
2136 } => write!(f, "expected table key `{}`, but was `{}`", expected, found)?,
2137 ErrorKind::ExpectedEmptyTable => "expected empty table".fmt(f)?,
2138 ErrorKind::DottedKeyInvalidType => {
2139 "dotted key attempted to extend non-table type".fmt(f)?
2140 }
2141 ErrorKind::UnexpectedKeys {
2142 ref keys,
2143 available,
2144 } => write!(
2145 f,
2146 "unexpected keys in table: `{:?}`, available keys: `{:?}`",
2147 keys, available
2148 )?,
2149 ErrorKind::UnquotedString => write!(
2150 f,
2151 "invalid TOML value, did you mean to use a quoted string?"
2152 )?,
2153 ErrorKind::__Nonexhaustive => panic!(),
2154 }
2155
2156 if !self.inner.key.is_empty() {
2157 write!(f, " for key `")?;
2158 for (i, k) in self.inner.key.iter().enumerate() {
2159 if i > 0 {
2160 write!(f, ".")?;
2161 }
2162 write!(f, "{}", k)?;
2163 }
2164 write!(f, "`")?;
2165 }
2166
2167 if let Some(line) = self.inner.line {
2168 write!(f, " at line {} column {}", line + 1, self.inner.col + 1)?;
2169 }
2170
2171 Ok(())
2172 }
2173 }
2174
2175 impl error::Error for Error {}
2176
2177 impl de::Error for Error {
custom<T: fmt::Display>(msg: T) -> Error2178 fn custom<T: fmt::Display>(msg: T) -> Error {
2179 Error::custom(None, msg.to_string())
2180 }
2181 }
2182
2183 enum Line<'a> {
2184 Table {
2185 at: usize,
2186 header: Header<'a>,
2187 array: bool,
2188 },
2189 KeyValue(Vec<(Span, Cow<'a, str>)>, Value<'a>),
2190 }
2191
2192 struct Header<'a> {
2193 first: bool,
2194 array: bool,
2195 require_newline_after_table: bool,
2196 tokens: Tokenizer<'a>,
2197 }
2198
2199 impl<'a> Header<'a> {
new(tokens: Tokenizer<'a>, array: bool, require_newline_after_table: bool) -> Header<'a>2200 fn new(tokens: Tokenizer<'a>, array: bool, require_newline_after_table: bool) -> Header<'a> {
2201 Header {
2202 first: true,
2203 array,
2204 tokens,
2205 require_newline_after_table,
2206 }
2207 }
2208
next(&mut self) -> Result<Option<(Span, Cow<'a, str>)>, TokenError>2209 fn next(&mut self) -> Result<Option<(Span, Cow<'a, str>)>, TokenError> {
2210 self.tokens.eat_whitespace()?;
2211
2212 if self.first || self.tokens.eat(Token::Period)? {
2213 self.first = false;
2214 self.tokens.eat_whitespace()?;
2215 self.tokens.table_key().map(|t| t).map(Some)
2216 } else {
2217 self.tokens.expect(Token::RightBracket)?;
2218 if self.array {
2219 self.tokens.expect(Token::RightBracket)?;
2220 }
2221
2222 self.tokens.eat_whitespace()?;
2223 if self.require_newline_after_table && !self.tokens.eat_comment()? {
2224 self.tokens.eat_newline_or_eof()?;
2225 }
2226 Ok(None)
2227 }
2228 }
2229 }
2230
2231 #[derive(Debug)]
2232 struct Value<'a> {
2233 e: E<'a>,
2234 start: usize,
2235 end: usize,
2236 }
2237
2238 #[derive(Debug)]
2239 enum E<'a> {
2240 Integer(i64),
2241 Float(f64),
2242 Boolean(bool),
2243 String(Cow<'a, str>),
2244 Datetime(&'a str),
2245 Array(Vec<Value<'a>>),
2246 InlineTable(Vec<TablePair<'a>>),
2247 DottedTable(Vec<TablePair<'a>>),
2248 }
2249
2250 impl<'a> E<'a> {
type_name(&self) -> &'static str2251 fn type_name(&self) -> &'static str {
2252 match *self {
2253 E::String(..) => "string",
2254 E::Integer(..) => "integer",
2255 E::Float(..) => "float",
2256 E::Boolean(..) => "boolean",
2257 E::Datetime(..) => "datetime",
2258 E::Array(..) => "array",
2259 E::InlineTable(..) => "inline table",
2260 E::DottedTable(..) => "dotted table",
2261 }
2262 }
2263 }
2264