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