//! Deserializing TOML into Rust structures.
//!
//! This module contains all the Serde support for deserializing TOML documents
//! into Rust structures. Note that some top-level functions here are also
//! provided at the top of the crate.
use std::borrow::Cow;
use std::collections::HashMap;
use std::error;
use std::f64;
use std::fmt;
use std::iter;
use std::marker::PhantomData;
use std::str;
use std::vec;
use serde::de;
use serde::de::value::BorrowedStrDeserializer;
use serde::de::IntoDeserializer;
use crate::datetime;
use crate::spanned;
use crate::tokens::{Error as TokenError, Span, Token, Tokenizer};
/// Type Alias for a TOML Table pair
type TablePair<'a> = ((Span, Cow<'a, str>), Value<'a>);
/// Deserializes a byte slice into a type.
///
/// This function will attempt to interpret `bytes` as UTF-8 data and then
/// deserialize `T` from the TOML document provided.
pub fn from_slice<'de, T>(bytes: &'de [u8]) -> Result<T, Error>
where
T: de::Deserialize<'de>,
{
match str::from_utf8(bytes) {
Ok(s) => from_str(s),
Err(e) => Err(Error::custom(None, e.to_string())),
}
}
/// Deserializes a string into a type.
///
/// This function will attempt to interpret `s` as a TOML document and
/// deserialize `T` from the document.
///
/// # Examples
///
/// ```
/// use serde_derive::Deserialize;
///
/// #[derive(Deserialize)]
/// struct Config {
/// title: String,
/// owner: Owner,
/// }
///
/// #[derive(Deserialize)]
/// struct Owner {
/// name: String,
/// }
///
/// let config: Config = toml::from_str(r#"
/// title = 'TOML Example'
///
/// [owner]
/// name = 'Lisa'
/// "#).unwrap();
///
/// assert_eq!(config.title, "TOML Example");
/// assert_eq!(config.owner.name, "Lisa");
/// ```
pub fn from_str<'de, T>(s: &'de str) -> Result<T, Error>
where
T: de::Deserialize<'de>,
{
let mut d = Deserializer::new(s);
let ret = T::deserialize(&mut d)?;
d.end()?;
Ok(ret)
}
/// Errors that can occur when deserializing a type.
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Error {
inner: Box<ErrorInner>,
}
#[derive(Debug, PartialEq, Eq, Clone)]
struct ErrorInner {
kind: ErrorKind,
line: Option<usize>,
col: usize,
at: Option<usize>,
message: String,
key: Vec<String>,
}
/// Errors that can occur when deserializing a type.
#[derive(Debug, PartialEq, Eq, Clone)]
#[non_exhaustive]
enum ErrorKind {
/// EOF was reached when looking for a value
UnexpectedEof,
/// An invalid character not allowed in a string was found
InvalidCharInString(char),
/// An invalid character was found as an escape
InvalidEscape(char),
/// An invalid character was found in a hex escape
InvalidHexEscape(char),
/// An invalid escape value was specified in a hex escape in a string.
///
/// Valid values are in the plane of unicode codepoints.
InvalidEscapeValue(u32),
/// A newline in a string was encountered when one was not allowed.
NewlineInString,
/// An unexpected character was encountered, typically when looking for a
/// value.
Unexpected(char),
/// An unterminated string was found where EOF was found before the ending
/// EOF mark.
UnterminatedString,
/// A newline was found in a table key.
NewlineInTableKey,
/// A number failed to parse
NumberInvalid,
/// A date or datetime was invalid
DateInvalid,
/// Wanted one sort of token, but found another.
Wanted {
/// Expected token type
expected: &'static str,
/// Actually found token type
found: &'static str,
},
/// A duplicate table definition was found.
DuplicateTable(String),
/// A previously defined table was redefined as an array.
RedefineAsArray,
/// An empty table key was found.
EmptyTableKey,
/// Multiline strings are not allowed for key
MultilineStringKey,
/// A custom error which could be generated when deserializing a particular
/// type.
Custom,
/// A tuple with a certain number of elements was expected but something
/// else was found.
ExpectedTuple(usize),
/// Expected table keys to be in increasing tuple index order, but something
/// else was found.
ExpectedTupleIndex {
/// Expected index.
expected: usize,
/// Key that was specified.
found: String,
},
/// An empty table was expected but entries were found
ExpectedEmptyTable,
/// Dotted key attempted to extend something that is not a table.
DottedKeyInvalidType,
/// An unexpected key was encountered.
///
/// Used when deserializing a struct with a limited set of fields.
UnexpectedKeys {
/// The unexpected keys.
keys: Vec<String>,
/// Keys that may be specified.
available: &'static [&'static str],
},
/// Unquoted string was found when quoted one was expected
UnquotedString,
}
/// Deserialization implementation for TOML.
pub struct Deserializer<'a> {
require_newline_after_table: bool,
allow_duplciate_after_longer_table: bool,
input: &'a str,
tokens: Tokenizer<'a>,
}
impl<'de, 'b> de::Deserializer<'de> for &'b mut Deserializer<'de> {
type Error = Error;
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
let mut tables = self.tables()?;
let table_indices = build_table_indices(&tables);
let table_pindices = build_table_pindices(&tables);
let res = visitor.visit_map(MapVisitor {
values: Vec::new().into_iter().peekable(),
next_value: None,
depth: 0,
cur: 0,
cur_parent: 0,
max: tables.len(),
table_indices: &table_indices,
table_pindices: &table_pindices,
tables: &mut tables,
array: false,
de: self,
});
res.map_err(|mut err| {
// Errors originating from this library (toml), have an offset
// attached to them already. Other errors, like those originating
// from serde (like "missing field") or from a custom deserializer,
// do not have offsets on them. Here, we do a best guess at their
// location, by attributing them to the "current table" (the last
// item in `tables`).
err.fix_offset(|| tables.last().map(|table| table.at));
err.fix_linecol(|at| self.to_linecol(at));
err
})
}
// Called when the type to deserialize is an enum, as opposed to a field in the type.
fn deserialize_enum<V>(
self,
_name: &'static str,
_variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
let (value, name) = self.string_or_table()?;
match value.e {
E::String(val) => visitor.visit_enum(val.into_deserializer()),
E::InlineTable(values) => {
if values.len() != 1 {
Err(Error::from_kind(
Some(value.start),
ErrorKind::Wanted {
expected: "exactly 1 element",
found: if values.is_empty() {
"zero elements"
} else {
"more than 1 element"
},
},
))
} else {
visitor.visit_enum(InlineTableDeserializer {
values: values.into_iter(),
next_value: None,
})
}
}
E::DottedTable(_) => visitor.visit_enum(DottedTableDeserializer {
name: name.expect("Expected table header to be passed."),
value,
}),
e => Err(Error::from_kind(
Some(value.start),
ErrorKind::Wanted {
expected: "string or table",
found: e.type_name(),
},
)),
}
}
fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
if name == spanned::NAME && fields == [spanned::START, spanned::END, spanned::VALUE] {
let start = 0;
let end = self.input.len();
let res = visitor.visit_map(SpannedDeserializer {
phantom_data: PhantomData,
start: Some(start),
value: Some(self),
end: Some(end),
});
return res;
}
self.deserialize_any(visitor)
}
serde::forward_to_deserialize_any! {
bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
bytes byte_buf map unit newtype_struct
ignored_any unit_struct tuple_struct tuple option identifier
}
}
// Builds a datastructure that allows for efficient sublinear lookups.
// The returned HashMap contains a mapping from table header (like [a.b.c])
// to list of tables with that precise name. The tables are being identified
// by their index in the passed slice. We use a list as the implementation
// uses this data structure for arrays as well as tables,
// so if any top level [[name]] array contains multiple entries,
// there are multiple entries in the list.
// The lookup is performed in the `SeqAccess` implementation of `MapVisitor`.
// The lists are ordered, which we exploit in the search code by using
// bisection.
fn build_table_indices<'de>(tables: &[Table<'de>]) -> HashMap<Vec<Cow<'de, str>>, Vec<usize>> {
let mut res = HashMap::new();
for (i, table) in tables.iter().enumerate() {
let header = table.header.iter().map(|v| v.1.clone()).collect::<Vec<_>>();
res.entry(header).or_insert_with(Vec::new).push(i);
}
res
}
// Builds a datastructure that allows for efficient sublinear lookups.
// The returned HashMap contains a mapping from table header (like [a.b.c])
// to list of tables whose name at least starts with the specified
// name. So searching for [a.b] would give both [a.b.c.d] as well as [a.b.e].
// The tables are being identified by their index in the passed slice.
//
// A list is used for two reasons: First, the implementation also
// stores arrays in the same data structure and any top level array
// of size 2 or greater creates multiple entries in the list with the
// same shared name. Second, there can be multiple tables sharing
// the same prefix.
//
// The lookup is performed in the `MapAccess` implementation of `MapVisitor`.
// The lists are ordered, which we exploit in the search code by using
// bisection.
fn build_table_pindices<'de>(tables: &[Table<'de>]) -> HashMap<Vec<Cow<'de, str>>, Vec<usize>> {
let mut res = HashMap::new();
for (i, table) in tables.iter().enumerate() {
let header = table.header.iter().map(|v| v.1.clone()).collect::<Vec<_>>();
for len in 0..=header.len() {
res.entry(header[..len].to_owned())
.or_insert_with(Vec::new)
.push(i);
}
}
res
}
fn headers_equal<'a, 'b>(hdr_a: &[(Span, Cow<'a, str>)], hdr_b: &[(Span, Cow<'b, str>)]) -> bool {
if hdr_a.len() != hdr_b.len() {
return false;
}
hdr_a.iter().zip(hdr_b.iter()).all(|(h1, h2)| h1.1 == h2.1)
}
struct Table<'a> {
at: usize,
header: Vec<(Span, Cow<'a, str>)>,
values: Option<Vec<TablePair<'a>>>,
array: bool,
}
struct MapVisitor<'de, 'b> {
values: iter::Peekable<vec::IntoIter<TablePair<'de>>>,
next_value: Option<TablePair<'de>>,
depth: usize,
cur: usize,
cur_parent: usize,
max: usize,
table_indices: &'b HashMap<Vec<Cow<'de, str>>, Vec<usize>>,
table_pindices: &'b HashMap<Vec<Cow<'de, str>>, Vec<usize>>,
tables: &'b mut [Table<'de>],
array: bool,
de: &'b mut Deserializer<'de>,
}
impl<'de, 'b> de::MapAccess<'de> for MapVisitor<'de, 'b> {
type Error = Error;
fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
where
K: de::DeserializeSeed<'de>,
{
if self.cur_parent == self.max || self.cur == self.max {
return Ok(None);
}
loop {
assert!(self.next_value.is_none());
if let Some((key, value)) = self.values.next() {
let ret = seed.deserialize(StrDeserializer::spanned(key.clone()))?;
self.next_value = Some((key, value));
return Ok(Some(ret));
}
let next_table = {
let prefix_stripped = self.tables[self.cur_parent].header[..self.depth]
.iter()
.map(|v| v.1.clone())
.collect::<Vec<_>>();
self.table_pindices
.get(&prefix_stripped)
.and_then(|entries| {
let start = entries.binary_search(&self.cur).unwrap_or_else(|v| v);
if start == entries.len() || entries[start] < self.cur {
return None;
}
entries[start..]
.iter()
.filter_map(|i| if *i < self.max { Some(*i) } else { None })
.map(|i| (i, &self.tables[i]))
.find(|(_, table)| table.values.is_some())
.map(|p| p.0)
})
};
let pos = match next_table {
Some(pos) => pos,
None => return Ok(None),
};
self.cur = pos;
// Test to see if we're duplicating our parent's table, and if so
// then this is an error in the toml format
if self.cur_parent != pos {
if headers_equal(
&self.tables[self.cur_parent].header,
&self.tables[pos].header,
) {
let at = self.tables[pos].at;
let name = self.tables[pos]
.header
.iter()
.map(|k| k.1.to_owned())
.collect::<Vec<_>>()
.join(".");
return Err(self.de.error(at, ErrorKind::DuplicateTable(name)));
}
// If we're here we know we should share the same prefix, and if
// the longer table was defined first then we want to narrow
// down our parent's length if possible to ensure that we catch
// duplicate tables defined afterwards.
if !self.de.allow_duplciate_after_longer_table {
let parent_len = self.tables[self.cur_parent].header.len();
let cur_len = self.tables[pos].header.len();
if cur_len < parent_len {
self.cur_parent = pos;
}
}
}
let table = &mut self.tables[pos];
// If we're not yet at the appropriate depth for this table then we
// just next the next portion of its header and then continue
// decoding.
if self.depth != table.header.len() {
let key = &table.header[self.depth];
let key = seed.deserialize(StrDeserializer::spanned(key.clone()))?;
return Ok(Some(key));
}
// Rule out cases like:
//
// [[foo.bar]]
// [[foo]]
if table.array {
let kind = ErrorKind::RedefineAsArray;
return Err(self.de.error(table.at, kind));
}
self.values = table
.values
.take()
.expect("Unable to read table values")
.into_iter()
.peekable();
}
}
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
where
V: de::DeserializeSeed<'de>,
{
if let Some((k, v)) = self.next_value.take() {
match seed.deserialize(ValueDeserializer::new(v)) {
Ok(v) => return Ok(v),
Err(mut e) => {
e.add_key_context(&k.1);
return Err(e);
}
}
}
let array =
self.tables[self.cur].array && self.depth == self.tables[self.cur].header.len() - 1;
self.cur += 1;
let res = seed.deserialize(MapVisitor {
values: Vec::new().into_iter().peekable(),
next_value: None,
depth: self.depth + if array { 0 } else { 1 },
cur_parent: self.cur - 1,
cur: 0,
max: self.max,
array,
table_indices: self.table_indices,
table_pindices: self.table_pindices,
tables: &mut *self.tables,
de: &mut *self.de,
});
res.map_err(|mut e| {
e.add_key_context(&self.tables[self.cur - 1].header[self.depth].1);
e
})
}
}
impl<'de, 'b> de::SeqAccess<'de> for MapVisitor<'de, 'b> {
type Error = Error;
fn next_element_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
where
K: de::DeserializeSeed<'de>,
{
assert!(self.next_value.is_none());
assert!(self.values.next().is_none());
if self.cur_parent == self.max {
return Ok(None);
}
let header_stripped = self.tables[self.cur_parent]
.header
.iter()
.map(|v| v.1.clone())
.collect::<Vec<_>>();
let start_idx = self.cur_parent + 1;
let next = self
.table_indices
.get(&header_stripped)
.and_then(|entries| {
let start = entries.binary_search(&start_idx).unwrap_or_else(|v| v);
if start == entries.len() || entries[start] < start_idx {
return None;
}
entries[start..]
.iter()
.filter_map(|i| if *i < self.max { Some(*i) } else { None })
.map(|i| (i, &self.tables[i]))
.find(|(_, table)| table.array)
.map(|p| p.0)
})
.unwrap_or(self.max);
let ret = seed.deserialize(MapVisitor {
values: self.tables[self.cur_parent]
.values
.take()
.expect("Unable to read table values")
.into_iter()
.peekable(),
next_value: None,
depth: self.depth + 1,
cur_parent: self.cur_parent,
max: next,
cur: 0,
array: false,
table_indices: self.table_indices,
table_pindices: self.table_pindices,
tables: self.tables,
de: self.de,
})?;
self.cur_parent = next;
Ok(Some(ret))
}
}
impl<'de, 'b> de::Deserializer<'de> for MapVisitor<'de, 'b> {
type Error = Error;
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
if self.array {
visitor.visit_seq(self)
} else {
visitor.visit_map(self)
}
}
// `None` is interpreted as a missing field so be sure to implement `Some`
// as a present field.
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
visitor.visit_some(self)
}
fn deserialize_newtype_struct<V>(
self,
_name: &'static str,
visitor: V,
) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
visitor.visit_newtype_struct(self)
}
fn deserialize_struct<V>(
mut self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
if name == spanned::NAME
&& fields == [spanned::START, spanned::END, spanned::VALUE]
&& !(self.array && self.values.peek().is_some())
{
// TODO we can't actually emit spans here for the *entire* table/array
// due to the format that toml uses. Setting the start and end to 0 is
// *detectable* (and no reasonable span would look like that),
// it would be better to expose this in the API via proper
// ADTs like Option<T>.
let start = 0;
let end = 0;
let res = visitor.visit_map(SpannedDeserializer {
phantom_data: PhantomData,
start: Some(start),
value: Some(self),
end: Some(end),
});
return res;
}
self.deserialize_any(visitor)
}
fn deserialize_enum<V>(
self,
_name: &'static str,
_variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
if self.tables.len() != 1 {
return Err(Error::custom(
Some(self.cur),
"enum table must contain exactly one table".into(),
));
}
let table = &mut self.tables[0];
let values = table.values.take().expect("table has no values?");
if table.header.is_empty() {
return Err(self.de.error(self.cur, ErrorKind::EmptyTableKey));
}
let name = table.header[table.header.len() - 1].1.to_owned();
visitor.visit_enum(DottedTableDeserializer {
name,
value: Value {
e: E::DottedTable(values),
start: 0,
end: 0,
},
})
}
serde::forward_to_deserialize_any! {
bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
bytes byte_buf map unit identifier
ignored_any unit_struct tuple_struct tuple
}
}
struct StrDeserializer<'a> {
span: Option<Span>,
key: Cow<'a, str>,
}
impl<'a> StrDeserializer<'a> {
fn spanned(inner: (Span, Cow<'a, str>)) -> StrDeserializer<'a> {
StrDeserializer {
span: Some(inner.0),
key: inner.1,
}
}
fn new(key: Cow<'a, str>) -> StrDeserializer<'a> {
StrDeserializer { span: None, key }
}
}
impl<'a> de::IntoDeserializer<'a, Error> for StrDeserializer<'a> {
type Deserializer = Self;
fn into_deserializer(self) -> Self::Deserializer {
self
}
}
impl<'de> de::Deserializer<'de> for StrDeserializer<'de> {
type Error = Error;
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
match self.key {
Cow::Borrowed(s) => visitor.visit_borrowed_str(s),
Cow::Owned(s) => visitor.visit_string(s),
}
}
fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
if name == spanned::NAME && fields == [spanned::START, spanned::END, spanned::VALUE] {
if let Some(span) = self.span {
return visitor.visit_map(SpannedDeserializer {
phantom_data: PhantomData,
start: Some(span.start),
value: Some(StrDeserializer::new(self.key)),
end: Some(span.end),
});
}
}
self.deserialize_any(visitor)
}
serde::forward_to_deserialize_any! {
bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
bytes byte_buf map option unit newtype_struct
ignored_any unit_struct tuple_struct tuple enum identifier
}
}
struct ValueDeserializer<'a> {
value: Value<'a>,
validate_struct_keys: bool,
}
impl<'a> ValueDeserializer<'a> {
fn new(value: Value<'a>) -> ValueDeserializer<'a> {
ValueDeserializer {
value,
validate_struct_keys: false,
}
}
fn with_struct_key_validation(mut self) -> Self {
self.validate_struct_keys = true;
self
}
}
impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> {
type Error = Error;
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
let start = self.value.start;
let res = match self.value.e {
E::Integer(i) => visitor.visit_i64(i),
E::Boolean(b) => visitor.visit_bool(b),
E::Float(f) => visitor.visit_f64(f),
E::String(Cow::Borrowed(s)) => visitor.visit_borrowed_str(s),
E::String(Cow::Owned(s)) => visitor.visit_string(s),
E::Datetime(s) => visitor.visit_map(DatetimeDeserializer {
date: s,
visited: false,
}),
E::Array(values) => {
let mut s = de::value::SeqDeserializer::new(values.into_iter());
let ret = visitor.visit_seq(&mut s)?;
s.end()?;
Ok(ret)
}
E::InlineTable(values) | E::DottedTable(values) => {
visitor.visit_map(InlineTableDeserializer {
values: values.into_iter(),
next_value: None,
})
}
};
res.map_err(|mut err| {
// Attribute the error to whatever value returned the error.
err.fix_offset(|| Some(start));
err
})
}
fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
if name == datetime::NAME && fields == [datetime::FIELD] {
if let E::Datetime(s) = self.value.e {
return visitor.visit_map(DatetimeDeserializer {
date: s,
visited: false,
});
}
}
if self.validate_struct_keys {
match self.value.e {
E::InlineTable(ref values) | E::DottedTable(ref values) => {
let extra_fields = values
.iter()
.filter_map(|key_value| {
let (ref key, ref _val) = *key_value;
if !fields.contains(&&*(key.1)) {
Some(key.clone())
} else {
None
}
})
.collect::<Vec<_>>();
if !extra_fields.is_empty() {
return Err(Error::from_kind(
Some(self.value.start),
ErrorKind::UnexpectedKeys {
keys: extra_fields
.iter()
.map(|k| k.1.to_string())
.collect::<Vec<_>>(),
available: fields,
},
));
}
}
_ => {}
}
}
if name == spanned::NAME && fields == [spanned::START, spanned::END, spanned::VALUE] {
let start = self.value.start;
let end = self.value.end;
return visitor.visit_map(SpannedDeserializer {
phantom_data: PhantomData,
start: Some(start),
value: Some(self.value),
end: Some(end),
});
}
self.deserialize_any(visitor)
}
// `None` is interpreted as a missing field so be sure to implement `Some`
// as a present field.
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
visitor.visit_some(self)
}
fn deserialize_enum<V>(
self,
_name: &'static str,
_variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
match self.value.e {
E::String(val) => visitor.visit_enum(val.into_deserializer()),
E::InlineTable(values) => {
if values.len() != 1 {
Err(Error::from_kind(
Some(self.value.start),
ErrorKind::Wanted {
expected: "exactly 1 element",
found: if values.is_empty() {
"zero elements"
} else {
"more than 1 element"
},
},
))
} else {
visitor.visit_enum(InlineTableDeserializer {
values: values.into_iter(),
next_value: None,
})
}
}
e => Err(Error::from_kind(
Some(self.value.start),
ErrorKind::Wanted {
expected: "string or inline table",
found: e.type_name(),
},
)),
}
}
fn deserialize_newtype_struct<V>(
self,
_name: &'static str,
visitor: V,
) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
visitor.visit_newtype_struct(self)
}
serde::forward_to_deserialize_any! {
bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
bytes byte_buf map unit identifier
ignored_any unit_struct tuple_struct tuple
}
}
impl<'de, 'b> de::IntoDeserializer<'de, Error> for MapVisitor<'de, 'b> {
type Deserializer = MapVisitor<'de, 'b>;
fn into_deserializer(self) -> Self::Deserializer {
self
}
}
impl<'de, 'b> de::IntoDeserializer<'de, Error> for &'b mut Deserializer<'de> {
type Deserializer = Self;
fn into_deserializer(self) -> Self::Deserializer {
self
}
}
impl<'de> de::IntoDeserializer<'de, Error> for Value<'de> {
type Deserializer = ValueDeserializer<'de>;
fn into_deserializer(self) -> Self::Deserializer {
ValueDeserializer::new(self)
}
}
struct SpannedDeserializer<'de, T: de::IntoDeserializer<'de, Error>> {
phantom_data: PhantomData<&'de ()>,
start: Option<usize>,
end: Option<usize>,
value: Option<T>,
}
impl<'de, T> de::MapAccess<'de> for SpannedDeserializer<'de, T>
where
T: de::IntoDeserializer<'de, Error>,
{
type Error = Error;
fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
where
K: de::DeserializeSeed<'de>,
{
if self.start.is_some() {
seed.deserialize(BorrowedStrDeserializer::new(spanned::START))
.map(Some)
} else if self.end.is_some() {
seed.deserialize(BorrowedStrDeserializer::new(spanned::END))
.map(Some)
} else if self.value.is_some() {
seed.deserialize(BorrowedStrDeserializer::new(spanned::VALUE))
.map(Some)
} else {
Ok(None)
}
}
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
where
V: de::DeserializeSeed<'de>,
{
if let Some(start) = self.start.take() {
seed.deserialize(start.into_deserializer())
} else if let Some(end) = self.end.take() {
seed.deserialize(end.into_deserializer())
} else if let Some(value) = self.value.take() {
seed.deserialize(value.into_deserializer())
} else {
panic!("next_value_seed called before next_key_seed")
}
}
}
struct DatetimeDeserializer<'a> {
visited: bool,
date: &'a str,
}
impl<'de> de::MapAccess<'de> for DatetimeDeserializer<'de> {
type Error = Error;
fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
where
K: de::DeserializeSeed<'de>,
{
if self.visited {
return Ok(None);
}
self.visited = true;
seed.deserialize(DatetimeFieldDeserializer).map(Some)
}
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
where
V: de::DeserializeSeed<'de>,
{
seed.deserialize(StrDeserializer::new(self.date.into()))
}
}
struct DatetimeFieldDeserializer;
impl<'de> de::Deserializer<'de> for DatetimeFieldDeserializer {
type Error = Error;
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
visitor.visit_borrowed_str(datetime::FIELD)
}
serde::forward_to_deserialize_any! {
bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
bytes byte_buf map struct option unit newtype_struct
ignored_any unit_struct tuple_struct tuple enum identifier
}
}
struct DottedTableDeserializer<'a> {
name: Cow<'a, str>,
value: Value<'a>,
}
impl<'de> de::EnumAccess<'de> for DottedTableDeserializer<'de> {
type Error = Error;
type Variant = TableEnumDeserializer<'de>;
fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
where
V: de::DeserializeSeed<'de>,
{
let (name, value) = (self.name, self.value);
seed.deserialize(StrDeserializer::new(name))
.map(|val| (val, TableEnumDeserializer { value }))
}
}
struct InlineTableDeserializer<'a> {
values: vec::IntoIter<TablePair<'a>>,
next_value: Option<Value<'a>>,
}
impl<'de> de::MapAccess<'de> for InlineTableDeserializer<'de> {
type Error = Error;
fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
where
K: de::DeserializeSeed<'de>,
{
let (key, value) = match self.values.next() {
Some(pair) => pair,
None => return Ok(None),
};
self.next_value = Some(value);
seed.deserialize(StrDeserializer::spanned(key)).map(Some)
}
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
where
V: de::DeserializeSeed<'de>,
{
let value = self.next_value.take().expect("Unable to read table values");
seed.deserialize(ValueDeserializer::new(value))
}
}
impl<'de> de::EnumAccess<'de> for InlineTableDeserializer<'de> {
type Error = Error;
type Variant = TableEnumDeserializer<'de>;
fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
where
V: de::DeserializeSeed<'de>,
{
let (key, value) = match self.values.next() {
Some(pair) => pair,
None => {
return Err(Error::from_kind(
None, // FIXME: How do we get an offset here?
ErrorKind::Wanted {
expected: "table with exactly 1 entry",
found: "empty table",
},
));
}
};
seed.deserialize(StrDeserializer::new(key.1))
.map(|val| (val, TableEnumDeserializer { value }))
}
}
/// Deserializes table values into enum variants.
struct TableEnumDeserializer<'a> {
value: Value<'a>,
}
impl<'de> de::VariantAccess<'de> for TableEnumDeserializer<'de> {
type Error = Error;
fn unit_variant(self) -> Result<(), Self::Error> {
match self.value.e {
E::InlineTable(values) | E::DottedTable(values) => {
if values.is_empty() {
Ok(())
} else {
Err(Error::from_kind(
Some(self.value.start),
ErrorKind::ExpectedEmptyTable,
))
}
}
e => Err(Error::from_kind(
Some(self.value.start),
ErrorKind::Wanted {
expected: "table",
found: e.type_name(),
},
)),
}
}
fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
where
T: de::DeserializeSeed<'de>,
{
seed.deserialize(ValueDeserializer::new(self.value))
}
fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
match self.value.e {
E::InlineTable(values) | E::DottedTable(values) => {
let tuple_values = values
.into_iter()
.enumerate()
.map(|(index, (key, value))| match key.1.parse::<usize>() {
Ok(key_index) if key_index == index => Ok(value),
Ok(_) | Err(_) => Err(Error::from_kind(
Some(key.0.start),
ErrorKind::ExpectedTupleIndex {
expected: index,
found: key.1.to_string(),
},
)),
})
// Fold all values into a `Vec`, or return the first error.
.fold(Ok(Vec::with_capacity(len)), |result, value_result| {
result.and_then(move |mut tuple_values| match value_result {
Ok(value) => {
tuple_values.push(value);
Ok(tuple_values)
}
// `Result<de::Value, Self::Error>` to `Result<Vec<_>, Self::Error>`
Err(e) => Err(e),
})
})?;
if tuple_values.len() == len {
de::Deserializer::deserialize_seq(
ValueDeserializer::new(Value {
e: E::Array(tuple_values),
start: self.value.start,
end: self.value.end,
}),
visitor,
)
} else {
Err(Error::from_kind(
Some(self.value.start),
ErrorKind::ExpectedTuple(len),
))
}
}
e => Err(Error::from_kind(
Some(self.value.start),
ErrorKind::Wanted {
expected: "table",
found: e.type_name(),
},
)),
}
}
fn struct_variant<V>(
self,
fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
de::Deserializer::deserialize_struct(
ValueDeserializer::new(self.value).with_struct_key_validation(),
"", // TODO: this should be the variant name
fields,
visitor,
)
}
}
impl<'a> Deserializer<'a> {
/// Creates a new deserializer which will be deserializing the string
/// provided.
pub fn new(input: &'a str) -> Deserializer<'a> {
Deserializer {
tokens: Tokenizer::new(input),
input,
require_newline_after_table: true,
allow_duplciate_after_longer_table: false,
}
}
#[doc(hidden)]
#[deprecated(since = "0.5.11")]
pub fn end(&mut self) -> Result<(), Error> {
Ok(())
}
#[doc(hidden)]
#[deprecated(since = "0.5.11")]
pub fn set_require_newline_after_table(&mut self, require: bool) {
self.require_newline_after_table = require;
}
#[doc(hidden)]
#[deprecated(since = "0.5.11")]
pub fn set_allow_duplicate_after_longer_table(&mut self, allow: bool) {
self.allow_duplciate_after_longer_table = allow;
}
fn tables(&mut self) -> Result<Vec<Table<'a>>, Error> {
let mut tables = Vec::new();
let mut cur_table = Table {
at: 0,
header: Vec::new(),
values: None,
array: false,
};
while let Some(line) = self.line()? {
match line {
Line::Table {
at,
mut header,
array,
} => {
if !cur_table.header.is_empty() || cur_table.values.is_some() {
tables.push(cur_table);
}
cur_table = Table {
at,
header: Vec::new(),
values: Some(Vec::new()),
array,
};
loop {
let part = header.next().map_err(|e| self.token_error(e));
match part? {
Some(part) => cur_table.header.push(part),
None => break,
}
}
}
Line::KeyValue(key, value) => {
if cur_table.values.is_none() {
cur_table.values = Some(Vec::new());
}
self.add_dotted_key(key, value, cur_table.values.as_mut().unwrap())?;
}
}
}
if !cur_table.header.is_empty() || cur_table.values.is_some() {
tables.push(cur_table);
}
Ok(tables)
}
fn line(&mut self) -> Result<Option<Line<'a>>, Error> {
loop {
self.eat_whitespace()?;
if self.eat_comment()? {
continue;
}
if self.eat(Token::Newline)? {
continue;
}
break;
}
match self.peek()? {
Some((_, Token::LeftBracket)) => self.table_header().map(Some),
Some(_) => self.key_value().map(Some),
None => Ok(None),
}
}
fn table_header(&mut self) -> Result<Line<'a>, Error> {
let start = self.tokens.current();
self.expect(Token::LeftBracket)?;
let array = self.eat(Token::LeftBracket)?;
let ret = Header::new(self.tokens.clone(), array, self.require_newline_after_table);
if self.require_newline_after_table {
self.tokens.skip_to_newline();
} else {
loop {
match self.next()? {
Some((_, Token::RightBracket)) => {
if array {
self.eat(Token::RightBracket)?;
}
break;
}
Some((_, Token::Newline)) | None => break,
_ => {}
}
}
self.eat_whitespace()?;
}
Ok(Line::Table {
at: start,
header: ret,
array,
})
}
fn key_value(&mut self) -> Result<Line<'a>, Error> {
let key = self.dotted_key()?;
self.eat_whitespace()?;
self.expect(Token::Equals)?;
self.eat_whitespace()?;
let value = self.value()?;
self.eat_whitespace()?;
if !self.eat_comment()? {
self.eat_newline_or_eof()?;
}
Ok(Line::KeyValue(key, value))
}
fn value(&mut self) -> Result<Value<'a>, Error> {
let at = self.tokens.current();
let value = match self.next()? {
Some((Span { start, end }, Token::String { val, .. })) => Value {
e: E::String(val),
start,
end,
},
Some((Span { start, end }, Token::Keylike("true"))) => Value {
e: E::Boolean(true),
start,
end,
},
Some((Span { start, end }, Token::Keylike("false"))) => Value {
e: E::Boolean(false),
start,
end,
},
Some((span, Token::Keylike(key))) => self.parse_keylike(at, span, key)?,
Some((span, Token::Plus)) => self.number_leading_plus(span)?,
Some((Span { start, .. }, Token::LeftBrace)) => {
self.inline_table().map(|(Span { end, .. }, table)| Value {
e: E::InlineTable(table),
start,
end,
})?
}
Some((Span { start, .. }, Token::LeftBracket)) => {
self.array().map(|(Span { end, .. }, array)| Value {
e: E::Array(array),
start,
end,
})?
}
Some(token) => {
return Err(self.error(
at,
ErrorKind::Wanted {
expected: "a value",
found: token.1.describe(),
},
));
}
None => return Err(self.eof()),
};
Ok(value)
}
fn parse_keylike(&mut self, at: usize, span: Span, key: &'a str) -> Result<Value<'a>, Error> {
if key == "inf" || key == "nan" {
return self.number_or_date(span, key);
}
let first_char = key.chars().next().expect("key should not be empty here");
match first_char {
'-' | '0'..='9' => self.number_or_date(span, key),
_ => Err(self.error(at, ErrorKind::UnquotedString)),
}
}
fn number_or_date(&mut self, span: Span, s: &'a str) -> Result<Value<'a>, Error> {
if s.contains('T')
|| s.contains('t')
|| (s.len() > 1 && s[1..].contains('-') && !s.contains("e-") && !s.contains("E-"))
{
self.datetime(span, s, false)
.map(|(Span { start, end }, d)| Value {
e: E::Datetime(d),
start,
end,
})
} else if self.eat(Token::Colon)? {
self.datetime(span, s, true)
.map(|(Span { start, end }, d)| Value {
e: E::Datetime(d),
start,
end,
})
} else {
self.number(span, s)
}
}
/// Returns a string or table value type.
///
/// Used to deserialize enums. Unit enums may be represented as a string or a table, all other
/// structures (tuple, newtype, struct) must be represented as a table.
fn string_or_table(&mut self) -> Result<(Value<'a>, Option<Cow<'a, str>>), Error> {
match self.peek()? {
Some((span, Token::LeftBracket)) => {
let tables = self.tables()?;
if tables.len() != 1 {
return Err(Error::from_kind(
Some(span.start),
ErrorKind::Wanted {
expected: "exactly 1 table",
found: if tables.is_empty() {
"zero tables"
} else {
"more than 1 table"
},
},
));
}
let table = tables
.into_iter()
.next()
.expect("Expected exactly one table");
let header = table
.header
.last()
.expect("Expected at least one header value for table.");
let start = table.at;
let end = table
.values
.as_ref()
.and_then(|values| values.last())
.map(|&(_, ref val)| val.end)
.unwrap_or_else(|| header.1.len());
Ok((
Value {
e: E::DottedTable(table.values.unwrap_or_default()),
start,
end,
},
Some(header.1.clone()),
))
}
Some(_) => self.value().map(|val| (val, None)),
None => Err(self.eof()),
}
}
fn number(&mut self, Span { start, end }: Span, s: &'a str) -> Result<Value<'a>, Error> {
let to_integer = |f| Value {
e: E::Integer(f),
start,
end,
};
if let Some(value) = s.strip_prefix("0x") {
self.integer(value, 16).map(to_integer)
} else if let Some(value) = s.strip_prefix("0o") {
self.integer(value, 8).map(to_integer)
} else if let Some(value) = s.strip_prefix("0b") {
self.integer(value, 2).map(to_integer)
} else if s.contains('e') || s.contains('E') {
self.float(s, None).map(|f| Value {
e: E::Float(f),
start,
end,
})
} else if self.eat(Token::Period)? {
let at = self.tokens.current();
match self.next()? {
Some((Span { start, end }, Token::Keylike(after))) => {
self.float(s, Some(after)).map(|f| Value {
e: E::Float(f),
start,
end,
})
}
_ => Err(self.error(at, ErrorKind::NumberInvalid)),
}
} else if s == "inf" {
Ok(Value {
e: E::Float(f64::INFINITY),
start,
end,
})
} else if s == "-inf" {
Ok(Value {
e: E::Float(f64::NEG_INFINITY),
start,
end,
})
} else if s == "nan" {
Ok(Value {
e: E::Float(f64::NAN),
start,
end,
})
} else if s == "-nan" {
Ok(Value {
e: E::Float(-f64::NAN),
start,
end,
})
} else {
self.integer(s, 10).map(to_integer)
}
}
fn number_leading_plus(&mut self, Span { start, .. }: Span) -> Result<Value<'a>, Error> {
let start_token = self.tokens.current();
match self.next()? {
Some((Span { end, .. }, Token::Keylike(s))) => self.number(Span { start, end }, s),
_ => Err(self.error(start_token, ErrorKind::NumberInvalid)),
}
}
fn integer(&self, s: &'a str, radix: u32) -> Result<i64, Error> {
let allow_sign = radix == 10;
let allow_leading_zeros = radix != 10;
let (prefix, suffix) = self.parse_integer(s, allow_sign, allow_leading_zeros, radix)?;
let start = self.tokens.substr_offset(s);
if !suffix.is_empty() {
return Err(self.error(start, ErrorKind::NumberInvalid));
}
i64::from_str_radix(prefix.replace('_', "").trim_start_matches('+'), radix)
.map_err(|_e| self.error(start, ErrorKind::NumberInvalid))
}
fn parse_integer(
&self,
s: &'a str,
allow_sign: bool,
allow_leading_zeros: bool,
radix: u32,
) -> Result<(&'a str, &'a str), Error> {
let start = self.tokens.substr_offset(s);
let mut first = true;
let mut first_zero = false;
let mut underscore = false;
let mut end = s.len();
for (i, c) in s.char_indices() {
let at = i + start;
if i == 0 && (c == '+' || c == '-') && allow_sign {
continue;
}
if c == '0' && first {
first_zero = true;
} else if c.is_digit(radix) {
if !first && first_zero && !allow_leading_zeros {
return Err(self.error(at, ErrorKind::NumberInvalid));
}
underscore = false;
} else if c == '_' && first {
return Err(self.error(at, ErrorKind::NumberInvalid));
} else if c == '_' && !underscore {
underscore = true;
} else {
end = i;
break;
}
first = false;
}
if first || underscore {
return Err(self.error(start, ErrorKind::NumberInvalid));
}
Ok((&s[..end], &s[end..]))
}
fn float(&mut self, s: &'a str, after_decimal: Option<&'a str>) -> Result<f64, Error> {
let (integral, mut suffix) = self.parse_integer(s, true, false, 10)?;
let start = self.tokens.substr_offset(integral);
let mut fraction = None;
if let Some(after) = after_decimal {
if !suffix.is_empty() {
return Err(self.error(start, ErrorKind::NumberInvalid));
}
let (a, b) = self.parse_integer(after, false, true, 10)?;
fraction = Some(a);
suffix = b;
}
let mut exponent = None;
if suffix.starts_with('e') || suffix.starts_with('E') {
let (a, b) = if suffix.len() == 1 {
self.eat(Token::Plus)?;
match self.next()? {
Some((_, Token::Keylike(s))) => self.parse_integer(s, false, true, 10)?,
_ => return Err(self.error(start, ErrorKind::NumberInvalid)),
}
} else {
self.parse_integer(&suffix[1..], true, true, 10)?
};
if !b.is_empty() {
return Err(self.error(start, ErrorKind::NumberInvalid));
}
exponent = Some(a);
} else if !suffix.is_empty() {
return Err(self.error(start, ErrorKind::NumberInvalid));
}
let mut number = integral
.trim_start_matches('+')
.chars()
.filter(|c| *c != '_')
.collect::<String>();
if let Some(fraction) = fraction {
number.push('.');
number.extend(fraction.chars().filter(|c| *c != '_'));
}
if let Some(exponent) = exponent {
number.push('E');
number.extend(exponent.chars().filter(|c| *c != '_'));
}
number
.parse()
.map_err(|_e| self.error(start, ErrorKind::NumberInvalid))
.and_then(|n: f64| {
if n.is_finite() {
Ok(n)
} else {
Err(self.error(start, ErrorKind::NumberInvalid))
}
})
}
fn datetime(
&mut self,
mut span: Span,
date: &'a str,
colon_eaten: bool,
) -> Result<(Span, &'a str), Error> {
let start = self.tokens.substr_offset(date);
// Check for space separated date and time.
let mut lookahead = self.tokens.clone();
if let Ok(Some((_, Token::Whitespace(" ")))) = lookahead.next() {
// Check if hour follows.
if let Ok(Some((_, Token::Keylike(_)))) = lookahead.next() {
self.next()?; // skip space
self.next()?; // skip keylike hour
}
}
if colon_eaten || self.eat(Token::Colon)? {
// minutes
match self.next()? {
Some((_, Token::Keylike(_))) => {}
_ => return Err(self.error(start, ErrorKind::DateInvalid)),
}
// Seconds
self.expect(Token::Colon)?;
match self.next()? {
Some((Span { end, .. }, Token::Keylike(_))) => {
span.end = end;
}
_ => return Err(self.error(start, ErrorKind::DateInvalid)),
}
// Fractional seconds
if self.eat(Token::Period)? {
match self.next()? {
Some((Span { end, .. }, Token::Keylike(_))) => {
span.end = end;
}
_ => return Err(self.error(start, ErrorKind::DateInvalid)),
}
}
// offset
if self.eat(Token::Plus)? {
match self.next()? {
Some((Span { end, .. }, Token::Keylike(_))) => {
span.end = end;
}
_ => return Err(self.error(start, ErrorKind::DateInvalid)),
}
}
if self.eat(Token::Colon)? {
match self.next()? {
Some((Span { end, .. }, Token::Keylike(_))) => {
span.end = end;
}
_ => return Err(self.error(start, ErrorKind::DateInvalid)),
}
}
}
let end = self.tokens.current();
Ok((span, &self.tokens.input()[start..end]))
}
// TODO(#140): shouldn't buffer up this entire table in memory, it'd be
// great to defer parsing everything until later.
fn inline_table(&mut self) -> Result<(Span, Vec<TablePair<'a>>), Error> {
let mut ret = Vec::new();
self.eat_whitespace()?;
if let Some(span) = self.eat_spanned(Token::RightBrace)? {
return Ok((span, ret));
}
loop {
let key = self.dotted_key()?;
self.eat_whitespace()?;
self.expect(Token::Equals)?;
self.eat_whitespace()?;
let value = self.value()?;
self.add_dotted_key(key, value, &mut ret)?;
self.eat_whitespace()?;
if let Some(span) = self.eat_spanned(Token::RightBrace)? {
return Ok((span, ret));
}
self.expect(Token::Comma)?;
self.eat_whitespace()?;
}
}
// TODO(#140): shouldn't buffer up this entire array in memory, it'd be
// great to defer parsing everything until later.
fn array(&mut self) -> Result<(Span, Vec<Value<'a>>), Error> {
let mut ret = Vec::new();
let intermediate = |me: &mut Deserializer<'_>| {
loop {
me.eat_whitespace()?;
if !me.eat(Token::Newline)? && !me.eat_comment()? {
break;
}
}
Ok(())
};
loop {
intermediate(self)?;
if let Some(span) = self.eat_spanned(Token::RightBracket)? {
return Ok((span, ret));
}
let value = self.value()?;
ret.push(value);
intermediate(self)?;
if !self.eat(Token::Comma)? {
break;
}
}
intermediate(self)?;
let span = self.expect_spanned(Token::RightBracket)?;
Ok((span, ret))
}
fn table_key(&mut self) -> Result<(Span, Cow<'a, str>), Error> {
self.tokens.table_key().map_err(|e| self.token_error(e))
}
fn dotted_key(&mut self) -> Result<Vec<(Span, Cow<'a, str>)>, Error> {
let mut result = vec![self.table_key()?];
self.eat_whitespace()?;
while self.eat(Token::Period)? {
self.eat_whitespace()?;
result.push(self.table_key()?);
self.eat_whitespace()?;
}
Ok(result)
}
/// Stores a value in the appropriate hierarchical structure positioned based on the dotted ke
y.
///
/// Given the following definition: `multi.part.key = "value"`, `multi` and `part` are
/// intermediate parts which are mapped to the relevant fields in the deserialized type's data
/// hierarchy.
///
/// # Parameters
///
/// * `key_parts`: Each segment of the dotted key, e.g. `part.one` maps to
/// `vec![Cow::Borrowed("part"), Cow::Borrowed("one")].`
/// * `value`: The parsed value.
/// * `values`: The `Vec` to store the value in.
fn add_dotted_key(
&self,
mut key_parts: Vec<(Span, Cow<'a, str>)>,
value: Value<'a>,
values: &mut Vec<TablePair<'a>>,
) -> Result<(), Error> {
let key = key_parts.remove(0);
if key_parts.is_empty() {
values.push((key, value));
return Ok(());
}
match values.iter_mut().find(|&&mut (ref k, _)| *k.1 == key.1) {
Some(&mut (
_,
Value {
e: E::DottedTable(ref mut v),
..
},
)) => {
return self.add_dotted_key(key_parts, value, v);
}
Some(&mut (_, Value { start, .. })) => {
return Err(self.error(start, ErrorKind::DottedKeyInvalidType));
}
None => {}
}
// The start/end value is somewhat misleading here.
let table_values = Value {
e: E::DottedTable(Vec::new()),
start: value.start,
end: value.end,
};
values.push((key, table_values));
let last_i = values.len() - 1;
if let (
_,
Value {
e: E::DottedTable(ref mut v),
..
},
) = values[last_i]
{
self.add_dotted_key(key_parts, value, v)?;
}
Ok(())
}
fn eat_whitespace(&mut self) -> Result<(), Error> {
self.tokens
.eat_whitespace()
.map_err(|e| self.token_error(e))
}
fn eat_comment(&mut self) -> Result<bool, Error> {
self.tokens.eat_comment().map_err(|e| self.token_error(e))
}
fn eat_newline_or_eof(&mut self) -> Result<(), Error> {
self.tokens
.eat_newline_or_eof()
.map_err(|e| self.token_error(e))
}
fn eat(&mut self, expected: Token<'a>) -> Result<bool, Error> {
self.tokens.eat(expected).map_err(|e| self.token_error(e))
}
fn eat_spanned(&mut self, expected: Token<'a>) -> Result<Option<Span>, Error> {
self.tokens
.eat_spanned(expected)
.map_err(|e| self.token_error(e))
}
fn expect(&mut self, expected: Token<'a>) -> Result<(), Error> {
self.tokens
.expect(expected)
.map_err(|e| self.token_error(e))
}
fn expect_spanned(&mut self, expected: Token<'a>) -> Result<Span, Error> {
self.tokens
.expect_spanned(expected)
.map_err(|e| self.token_error(e))
}
fn next(&mut self) -> Result<Option<(Span, Token<'a>)>, Error> {
self.tokens.next().map_err(|e| self.token_error(e))
}
fn peek(&mut self) -> Result<Option<(Span, Token<'a>)>, Error> {
self.tokens.peek().map_err(|e| self.token_error(e))
}
fn eof(&self) -> Error {
self.error(self.input.len(), ErrorKind::UnexpectedEof)
}
fn token_error(&self, error: TokenError) -> Error {
match error {
TokenError::InvalidCharInString(at, ch) => {
self.error(at, ErrorKind::InvalidCharInString(ch))
}
TokenError::InvalidEscape(at, ch) => self.error(at, ErrorKind::InvalidEscape(ch)),
TokenError::InvalidEscapeValue(at, v) => {
self.error(at, ErrorKind::InvalidEscapeValue(v))
}
TokenError::InvalidHexEscape(at, ch) => self.error(at, ErrorKind::InvalidHexEscape(ch)),
TokenError::NewlineInString(at) => self.error(at, ErrorKind::NewlineInString),
TokenError::Unexpected(at, ch) => self.error(at, ErrorKind::Unexpected(ch)),
TokenError::UnterminatedString(at) => self.error(at, ErrorKind::UnterminatedString),
TokenError::NewlineInTableKey(at) => self.error(at, ErrorKind::NewlineInTableKey),
TokenError::Wanted {
at,
expected,
found,
} => self.error(at, ErrorKind::Wanted { expected, found }),
TokenError::MultilineStringKey(at) => self.error(at, ErrorKind::MultilineStringKey),
}
}
fn error(&self, at: usize, kind: ErrorKind) -> Error {
let mut err = Error::from_kind(Some(at), kind);
err.fix_linecol(|at| self.to_linecol(at));
err
}
/// Converts a byte offset from an error message to a (line, column) pair
///
/// All indexes are 0-based.
fn to_linecol(&self, offset: usize) -> (usize, usize) {
let mut cur = 0;
// Use split_terminator instead of lines so that if there is a `\r`,
// it is included in the offset calculation. The `+1` values below
// account for the `\n`.
for (i, line) in self.input.split_terminator('\n').enumerate() {
if cur + line.len() + 1 > offset {
--> --------------------
--> maximum size reached
--> --------------------
