diff options
Diffstat (limited to 'compiler/rustc_serialize/src')
| -rw-r--r-- | compiler/rustc_serialize/src/collection_impls.rs | 337 | ||||
| -rw-r--r-- | compiler/rustc_serialize/src/json.rs | 2778 | ||||
| -rw-r--r-- | compiler/rustc_serialize/src/json/tests.rs | 147 | ||||
| -rw-r--r-- | compiler/rustc_serialize/src/leb128.rs | 110 | ||||
| -rw-r--r-- | compiler/rustc_serialize/src/lib.rs | 27 | ||||
| -rw-r--r-- | compiler/rustc_serialize/src/opaque.rs | 318 | ||||
| -rw-r--r-- | compiler/rustc_serialize/src/serialize.rs | 782 |
7 files changed, 4499 insertions, 0 deletions
diff --git a/compiler/rustc_serialize/src/collection_impls.rs b/compiler/rustc_serialize/src/collection_impls.rs new file mode 100644 index 00000000000..3d274cb0150 --- /dev/null +++ b/compiler/rustc_serialize/src/collection_impls.rs @@ -0,0 +1,337 @@ +//! Implementations of serialization for structures found in liballoc + +use std::hash::{BuildHasher, Hash}; + +use crate::{Decodable, Decoder, Encodable, Encoder}; +use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, LinkedList, VecDeque}; +use std::rc::Rc; +use std::sync::Arc; + +use smallvec::{Array, SmallVec}; + +impl<S: Encoder, A: Array<Item: Encodable<S>>> Encodable<S> for SmallVec<A> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.emit_seq(self.len(), |s| { + for (i, e) in self.iter().enumerate() { + s.emit_seq_elt(i, |s| e.encode(s))?; + } + Ok(()) + }) + } +} + +impl<D: Decoder, A: Array<Item: Decodable<D>>> Decodable<D> for SmallVec<A> { + fn decode(d: &mut D) -> Result<SmallVec<A>, D::Error> { + d.read_seq(|d, len| { + let mut vec = SmallVec::with_capacity(len); + // FIXME(#48994) - could just be collected into a Result<SmallVec, D::Error> + for i in 0..len { + vec.push(d.read_seq_elt(i, |d| Decodable::decode(d))?); + } + Ok(vec) + }) + } +} + +impl<S: Encoder, T: Encodable<S>> Encodable<S> for LinkedList<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.emit_seq(self.len(), |s| { + for (i, e) in self.iter().enumerate() { + s.emit_seq_elt(i, |s| e.encode(s))?; + } + Ok(()) + }) + } +} + +impl<D: Decoder, T: Decodable<D>> Decodable<D> for LinkedList<T> { + fn decode(d: &mut D) -> Result<LinkedList<T>, D::Error> { + d.read_seq(|d, len| { + let mut list = LinkedList::new(); + for i in 0..len { + list.push_back(d.read_seq_elt(i, |d| Decodable::decode(d))?); + } + Ok(list) + }) + } +} + +impl<S: Encoder, T: Encodable<S>> Encodable<S> for VecDeque<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.emit_seq(self.len(), |s| { + for (i, e) in self.iter().enumerate() { + s.emit_seq_elt(i, |s| e.encode(s))?; + } + Ok(()) + }) + } +} + +impl<D: Decoder, T: Decodable<D>> Decodable<D> for VecDeque<T> { + fn decode(d: &mut D) -> Result<VecDeque<T>, D::Error> { + d.read_seq(|d, len| { + let mut deque: VecDeque<T> = VecDeque::with_capacity(len); + for i in 0..len { + deque.push_back(d.read_seq_elt(i, |d| Decodable::decode(d))?); + } + Ok(deque) + }) + } +} + +impl<S: Encoder, K, V> Encodable<S> for BTreeMap<K, V> +where + K: Encodable<S> + PartialEq + Ord, + V: Encodable<S>, +{ + fn encode(&self, e: &mut S) -> Result<(), S::Error> { + e.emit_map(self.len(), |e| { + for (i, (key, val)) in self.iter().enumerate() { + e.emit_map_elt_key(i, |e| key.encode(e))?; + e.emit_map_elt_val(i, |e| val.encode(e))?; + } + Ok(()) + }) + } +} + +impl<D: Decoder, K, V> Decodable<D> for BTreeMap<K, V> +where + K: Decodable<D> + PartialEq + Ord, + V: Decodable<D>, +{ + fn decode(d: &mut D) -> Result<BTreeMap<K, V>, D::Error> { + d.read_map(|d, len| { + let mut map = BTreeMap::new(); + for i in 0..len { + let key = d.read_map_elt_key(i, |d| Decodable::decode(d))?; + let val = d.read_map_elt_val(i, |d| Decodable::decode(d))?; + map.insert(key, val); + } + Ok(map) + }) + } +} + +impl<S: Encoder, T> Encodable<S> for BTreeSet<T> +where + T: Encodable<S> + PartialEq + Ord, +{ + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.emit_seq(self.len(), |s| { + for (i, e) in self.iter().enumerate() { + s.emit_seq_elt(i, |s| e.encode(s))?; + } + Ok(()) + }) + } +} + +impl<D: Decoder, T> Decodable<D> for BTreeSet<T> +where + T: Decodable<D> + PartialEq + Ord, +{ + fn decode(d: &mut D) -> Result<BTreeSet<T>, D::Error> { + d.read_seq(|d, len| { + let mut set = BTreeSet::new(); + for i in 0..len { + set.insert(d.read_seq_elt(i, |d| Decodable::decode(d))?); + } + Ok(set) + }) + } +} + +impl<E: Encoder, K, V, S> Encodable<E> for HashMap<K, V, S> +where + K: Encodable<E> + Eq, + V: Encodable<E>, + S: BuildHasher, +{ + fn encode(&self, e: &mut E) -> Result<(), E::Error> { + e.emit_map(self.len(), |e| { + for (i, (key, val)) in self.iter().enumerate() { + e.emit_map_elt_key(i, |e| key.encode(e))?; + e.emit_map_elt_val(i, |e| val.encode(e))?; + } + Ok(()) + }) + } +} + +impl<D: Decoder, K, V, S> Decodable<D> for HashMap<K, V, S> +where + K: Decodable<D> + Hash + Eq, + V: Decodable<D>, + S: BuildHasher + Default, +{ + fn decode(d: &mut D) -> Result<HashMap<K, V, S>, D::Error> { + d.read_map(|d, len| { + let state = Default::default(); + let mut map = HashMap::with_capacity_and_hasher(len, state); + for i in 0..len { + let key = d.read_map_elt_key(i, |d| Decodable::decode(d))?; + let val = d.read_map_elt_val(i, |d| Decodable::decode(d))?; + map.insert(key, val); + } + Ok(map) + }) + } +} + +impl<E: Encoder, T, S> Encodable<E> for HashSet<T, S> +where + T: Encodable<E> + Eq, + S: BuildHasher, +{ + fn encode(&self, s: &mut E) -> Result<(), E::Error> { + s.emit_seq(self.len(), |s| { + for (i, e) in self.iter().enumerate() { + s.emit_seq_elt(i, |s| e.encode(s))?; + } + Ok(()) + }) + } +} + +impl<E: Encoder, T, S> Encodable<E> for &HashSet<T, S> +where + T: Encodable<E> + Eq, + S: BuildHasher, +{ + fn encode(&self, s: &mut E) -> Result<(), E::Error> { + (**self).encode(s) + } +} + +impl<D: Decoder, T, S> Decodable<D> for HashSet<T, S> +where + T: Decodable<D> + Hash + Eq, + S: BuildHasher + Default, +{ + fn decode(d: &mut D) -> Result<HashSet<T, S>, D::Error> { + d.read_seq(|d, len| { + let state = Default::default(); + let mut set = HashSet::with_capacity_and_hasher(len, state); + for i in 0..len { + set.insert(d.read_seq_elt(i, |d| Decodable::decode(d))?); + } + Ok(set) + }) + } +} + +impl<E: Encoder, K, V, S> Encodable<E> for indexmap::IndexMap<K, V, S> +where + K: Encodable<E> + Hash + Eq, + V: Encodable<E>, + S: BuildHasher, +{ + fn encode(&self, e: &mut E) -> Result<(), E::Error> { + e.emit_map(self.len(), |e| { + for (i, (key, val)) in self.iter().enumerate() { + e.emit_map_elt_key(i, |e| key.encode(e))?; + e.emit_map_elt_val(i, |e| val.encode(e))?; + } + Ok(()) + }) + } +} + +impl<D: Decoder, K, V, S> Decodable<D> for indexmap::IndexMap<K, V, S> +where + K: Decodable<D> + Hash + Eq, + V: Decodable<D>, + S: BuildHasher + Default, +{ + fn decode(d: &mut D) -> Result<indexmap::IndexMap<K, V, S>, D::Error> { + d.read_map(|d, len| { + let state = Default::default(); + let mut map = indexmap::IndexMap::with_capacity_and_hasher(len, state); + for i in 0..len { + let key = d.read_map_elt_key(i, |d| Decodable::decode(d))?; + let val = d.read_map_elt_val(i, |d| Decodable::decode(d))?; + map.insert(key, val); + } + Ok(map) + }) + } +} + +impl<E: Encoder, T, S> Encodable<E> for indexmap::IndexSet<T, S> +where + T: Encodable<E> + Hash + Eq, + S: BuildHasher, +{ + fn encode(&self, s: &mut E) -> Result<(), E::Error> { + s.emit_seq(self.len(), |s| { + for (i, e) in self.iter().enumerate() { + s.emit_seq_elt(i, |s| e.encode(s))?; + } + Ok(()) + }) + } +} + +impl<D: Decoder, T, S> Decodable<D> for indexmap::IndexSet<T, S> +where + T: Decodable<D> + Hash + Eq, + S: BuildHasher + Default, +{ + fn decode(d: &mut D) -> Result<indexmap::IndexSet<T, S>, D::Error> { + d.read_seq(|d, len| { + let state = Default::default(); + let mut set = indexmap::IndexSet::with_capacity_and_hasher(len, state); + for i in 0..len { + set.insert(d.read_seq_elt(i, |d| Decodable::decode(d))?); + } + Ok(set) + }) + } +} + +impl<E: Encoder, T: Encodable<E>> Encodable<E> for Rc<[T]> { + fn encode(&self, s: &mut E) -> Result<(), E::Error> { + s.emit_seq(self.len(), |s| { + for (index, e) in self.iter().enumerate() { + s.emit_seq_elt(index, |s| e.encode(s))?; + } + Ok(()) + }) + } +} + +impl<D: Decoder, T: Decodable<D>> Decodable<D> for Rc<[T]> { + fn decode(d: &mut D) -> Result<Rc<[T]>, D::Error> { + d.read_seq(|d, len| { + let mut vec = Vec::with_capacity(len); + for index in 0..len { + vec.push(d.read_seq_elt(index, |d| Decodable::decode(d))?); + } + Ok(vec.into()) + }) + } +} + +impl<E: Encoder, T: Encodable<E>> Encodable<E> for Arc<[T]> { + fn encode(&self, s: &mut E) -> Result<(), E::Error> { + s.emit_seq(self.len(), |s| { + for (index, e) in self.iter().enumerate() { + s.emit_seq_elt(index, |s| e.encode(s))?; + } + Ok(()) + }) + } +} + +impl<D: Decoder, T: Decodable<D>> Decodable<D> for Arc<[T]> { + fn decode(d: &mut D) -> Result<Arc<[T]>, D::Error> { + d.read_seq(|d, len| { + let mut vec = Vec::with_capacity(len); + for index in 0..len { + vec.push(d.read_seq_elt(index, |d| Decodable::decode(d))?); + } + Ok(vec.into()) + }) + } +} diff --git a/compiler/rustc_serialize/src/json.rs b/compiler/rustc_serialize/src/json.rs new file mode 100644 index 00000000000..6c8965aa2e3 --- /dev/null +++ b/compiler/rustc_serialize/src/json.rs @@ -0,0 +1,2778 @@ +// Rust JSON serialization library. +// Copyright (c) 2011 Google Inc. + +#![forbid(non_camel_case_types)] +#![allow(missing_docs)] + +//! JSON parsing and serialization +//! +//! # What is JSON? +//! +//! JSON (JavaScript Object Notation) is a way to write data in Javascript. +//! Like XML, it allows to encode structured data in a text format that can be easily read by humans +//! Its simple syntax and native compatibility with JavaScript have made it a widely used format. +//! +//! Data types that can be encoded are JavaScript types (see the `Json` enum for more details): +//! +//! * `Boolean`: equivalent to rust's `bool` +//! * `Number`: equivalent to rust's `f64` +//! * `String`: equivalent to rust's `String` +//! * `Array`: equivalent to rust's `Vec<T>`, but also allowing objects of different types in the +//! same array +//! * `Object`: equivalent to rust's `BTreeMap<String, json::Json>` +//! * `Null` +//! +//! An object is a series of string keys mapping to values, in `"key": value` format. +//! Arrays are enclosed in square brackets ([ ... ]) and objects in curly brackets ({ ... }). +//! A simple JSON document encoding a person, their age, address and phone numbers could look like +//! +//! ```json +//! { +//! "FirstName": "John", +//! "LastName": "Doe", +//! "Age": 43, +//! "Address": { +//! "Street": "Downing Street 10", +//! "City": "London", +//! "Country": "Great Britain" +//! }, +//! "PhoneNumbers": [ +//! "+44 1234567", +//! "+44 2345678" +//! ] +//! } +//! ``` +//! +//! # Rust Type-based Encoding and Decoding +//! +//! Rust provides a mechanism for low boilerplate encoding & decoding of values to and from JSON via +//! the serialization API. +//! To be able to encode a piece of data, it must implement the `serialize::Encodable` trait. +//! To be able to decode a piece of data, it must implement the `serialize::Decodable` trait. +//! The Rust compiler provides an annotation to automatically generate the code for these traits: +//! `#[derive(Decodable, Encodable)]` +//! +//! The JSON API provides an enum `json::Json` and a trait `ToJson` to encode objects. +//! The `ToJson` trait provides a `to_json` method to convert an object into a `json::Json` value. +//! A `json::Json` value can be encoded as a string or buffer using the functions described above. +//! You can also use the `json::Encoder` object, which implements the `Encoder` trait. +//! +//! When using `ToJson` the `Encodable` trait implementation is not mandatory. +//! +//! # Examples of use +//! +//! ## Using Autoserialization +//! +//! Create a struct called `TestStruct` and serialize and deserialize it to and from JSON using the +//! serialization API, using the derived serialization code. +//! +//! ```rust +//! # #![feature(rustc_private)] +//! use rustc_macros::{Decodable, Encodable}; +//! use rustc_serialize::json; +//! +//! // Automatically generate `Decodable` and `Encodable` trait implementations +//! #[derive(Decodable, Encodable)] +//! pub struct TestStruct { +//! data_int: u8, +//! data_str: String, +//! data_vector: Vec<u8>, +//! } +//! +//! let object = TestStruct { +//! data_int: 1, +//! data_str: "homura".to_string(), +//! data_vector: vec![2,3,4,5], +//! }; +//! +//! // Serialize using `json::encode` +//! let encoded = json::encode(&object).unwrap(); +//! +//! // Deserialize using `json::decode` +//! let decoded: TestStruct = json::decode(&encoded[..]).unwrap(); +//! ``` +//! +//! ## Using the `ToJson` trait +//! +//! The examples above use the `ToJson` trait to generate the JSON string, which is required +//! for custom mappings. +//! +//! ### Simple example of `ToJson` usage +//! +//! ```rust +//! # #![feature(rustc_private)] +//! use rustc_macros::Encodable; +//! use rustc_serialize::json::{self, ToJson, Json}; +//! +//! // A custom data structure +//! struct ComplexNum { +//! a: f64, +//! b: f64, +//! } +//! +//! // JSON value representation +//! impl ToJson for ComplexNum { +//! fn to_json(&self) -> Json { +//! Json::String(format!("{}+{}i", self.a, self.b)) +//! } +//! } +//! +//! // Only generate `Encodable` trait implementation +//! #[derive(Encodable)] +//! pub struct ComplexNumRecord { +//! uid: u8, +//! dsc: String, +//! val: Json, +//! } +//! +//! let num = ComplexNum { a: 0.0001, b: 12.539 }; +//! let data: String = json::encode(&ComplexNumRecord{ +//! uid: 1, +//! dsc: "test".to_string(), +//! val: num.to_json(), +//! }).unwrap(); +//! println!("data: {}", data); +//! // data: {"uid":1,"dsc":"test","val":"0.0001+12.539i"}; +//! ``` +//! +//! ### Verbose example of `ToJson` usage +//! +//! ```rust +//! # #![feature(rustc_private)] +//! use rustc_macros::Decodable; +//! use std::collections::BTreeMap; +//! use rustc_serialize::json::{self, Json, ToJson}; +//! +//! // Only generate `Decodable` trait implementation +//! #[derive(Decodable)] +//! pub struct TestStruct { +//! data_int: u8, +//! data_str: String, +//! data_vector: Vec<u8>, +//! } +//! +//! // Specify encoding method manually +//! impl ToJson for TestStruct { +//! fn to_json(&self) -> Json { +//! let mut d = BTreeMap::new(); +//! // All standard types implement `to_json()`, so use it +//! d.insert("data_int".to_string(), self.data_int.to_json()); +//! d.insert("data_str".to_string(), self.data_str.to_json()); +//! d.insert("data_vector".to_string(), self.data_vector.to_json()); +//! Json::Object(d) +//! } +//! } +//! +//! // Serialize using `ToJson` +//! let input_data = TestStruct { +//! data_int: 1, +//! data_str: "madoka".to_string(), +//! data_vector: vec![2,3,4,5], +//! }; +//! let json_obj: Json = input_data.to_json(); +//! let json_str: String = json_obj.to_string(); +//! +//! // Deserialize like before +//! let decoded: TestStruct = json::decode(&json_str).unwrap(); +//! ``` + +use self::DecoderError::*; +use self::ErrorCode::*; +use self::InternalStackElement::*; +use self::JsonEvent::*; +use self::ParserError::*; +use self::ParserState::*; + +use std::borrow::Cow; +use std::collections::{BTreeMap, HashMap}; +use std::io; +use std::io::prelude::*; +use std::mem::swap; +use std::num::FpCategory as Fp; +use std::ops::Index; +use std::str::FromStr; +use std::string; +use std::{char, fmt, str}; + +use crate::Encodable; + +/// Represents a json value +#[derive(Clone, PartialEq, PartialOrd, Debug)] +pub enum Json { + I64(i64), + U64(u64), + F64(f64), + String(string::String), + Boolean(bool), + Array(self::Array), + Object(self::Object), + Null, +} + +pub type Array = Vec<Json>; +pub type Object = BTreeMap<string::String, Json>; + +pub struct PrettyJson<'a> { + inner: &'a Json, +} + +pub struct AsJson<'a, T> { + inner: &'a T, +} +pub struct AsPrettyJson<'a, T> { + inner: &'a T, + indent: Option<usize>, +} + +/// The errors that can arise while parsing a JSON stream. +#[derive(Clone, Copy, PartialEq, Debug)] +pub enum ErrorCode { + InvalidSyntax, + InvalidNumber, + EOFWhileParsingObject, + EOFWhileParsingArray, + EOFWhileParsingValue, + EOFWhileParsingString, + KeyMustBeAString, + ExpectedColon, + TrailingCharacters, + TrailingComma, + InvalidEscape, + InvalidUnicodeCodePoint, + LoneLeadingSurrogateInHexEscape, + UnexpectedEndOfHexEscape, + UnrecognizedHex, + NotFourDigit, + NotUtf8, +} + +#[derive(Clone, PartialEq, Debug)] +pub enum ParserError { + /// msg, line, col + SyntaxError(ErrorCode, usize, usize), + IoError(io::ErrorKind, String), +} + +// Builder and Parser have the same errors. +pub type BuilderError = ParserError; + +#[derive(Clone, PartialEq, Debug)] +pub enum DecoderError { + ParseError(ParserError), + ExpectedError(string::String, string::String), + MissingFieldError(string::String), + UnknownVariantError(string::String), + ApplicationError(string::String), +} + +#[derive(Copy, Clone, Debug)] +pub enum EncoderError { + FmtError(fmt::Error), + BadHashmapKey, +} + +/// Returns a readable error string for a given error code. +pub fn error_str(error: ErrorCode) -> &'static str { + match error { + InvalidSyntax => "invalid syntax", + InvalidNumber => "invalid number", + EOFWhileParsingObject => "EOF While parsing object", + EOFWhileParsingArray => "EOF While parsing array", + EOFWhileParsingValue => "EOF While parsing value", + EOFWhileParsingString => "EOF While parsing string", + KeyMustBeAString => "key must be a string", + ExpectedColon => "expected `:`", + TrailingCharacters => "trailing characters", + TrailingComma => "trailing comma", + InvalidEscape => "invalid escape", + UnrecognizedHex => "invalid \\u{ esc}ape (unrecognized hex)", + NotFourDigit => "invalid \\u{ esc}ape (not four digits)", + NotUtf8 => "contents not utf-8", + InvalidUnicodeCodePoint => "invalid Unicode code point", + LoneLeadingSurrogateInHexEscape => "lone leading surrogate in hex escape", + UnexpectedEndOfHexEscape => "unexpected end of hex escape", + } +} + +/// Shortcut function to decode a JSON `&str` into an object +pub fn decode<T: crate::Decodable<Decoder>>(s: &str) -> DecodeResult<T> { + let json = match from_str(s) { + Ok(x) => x, + Err(e) => return Err(ParseError(e)), + }; + + let mut decoder = Decoder::new(json); + crate::Decodable::decode(&mut decoder) +} + +/// Shortcut function to encode a `T` into a JSON `String` +pub fn encode<T: for<'r> crate::Encodable<Encoder<'r>>>( + object: &T, +) -> Result<string::String, EncoderError> { + let mut s = String::new(); + { + let mut encoder = Encoder::new(&mut s); + object.encode(&mut encoder)?; + } + Ok(s) +} + +impl fmt::Display for ErrorCode { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + error_str(*self).fmt(f) + } +} + +fn io_error_to_error(io: io::Error) -> ParserError { + IoError(io.kind(), io.to_string()) +} + +impl fmt::Display for ParserError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + // FIXME this should be a nicer error + fmt::Debug::fmt(self, f) + } +} + +impl fmt::Display for DecoderError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + // FIXME this should be a nicer error + fmt::Debug::fmt(self, f) + } +} + +impl std::error::Error for DecoderError {} + +impl fmt::Display for EncoderError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + // FIXME this should be a nicer error + fmt::Debug::fmt(self, f) + } +} + +impl std::error::Error for EncoderError {} + +impl From<fmt::Error> for EncoderError { + /// Converts a [`fmt::Error`] into `EncoderError` + /// + /// This conversion does not allocate memory. + fn from(err: fmt::Error) -> EncoderError { + EncoderError::FmtError(err) + } +} + +pub type EncodeResult = Result<(), EncoderError>; +pub type DecodeResult<T> = Result<T, DecoderError>; + +fn escape_str(wr: &mut dyn fmt::Write, v: &str) -> EncodeResult { + wr.write_str("\"")?; + + let mut start = 0; + + for (i, byte) in v.bytes().enumerate() { + let escaped = match byte { + b'"' => "\\\"", + b'\\' => "\\\\", + b'\x00' => "\\u0000", + b'\x01' => "\\u0001", + b'\x02' => "\\u0002", + b'\x03' => "\\u0003", + b'\x04' => "\\u0004", + b'\x05' => "\\u0005", + b'\x06' => "\\u0006", + b'\x07' => "\\u0007", + b'\x08' => "\\b", + b'\t' => "\\t", + b'\n' => "\\n", + b'\x0b' => "\\u000b", + b'\x0c' => "\\f", + b'\r' => "\\r", + b'\x0e' => "\\u000e", + b'\x0f' => "\\u000f", + b'\x10' => "\\u0010", + b'\x11' => "\\u0011", + b'\x12' => "\\u0012", + b'\x13' => "\\u0013", + b'\x14' => "\\u0014", + b'\x15' => "\\u0015", + b'\x16' => "\\u0016", + b'\x17' => "\\u0017", + b'\x18' => "\\u0018", + b'\x19' => "\\u0019", + b'\x1a' => "\\u001a", + b'\x1b' => "\\u001b", + b'\x1c' => "\\u001c", + b'\x1d' => "\\u001d", + b'\x1e' => "\\u001e", + b'\x1f' => "\\u001f", + b'\x7f' => "\\u007f", + _ => { + continue; + } + }; + + if start < i { + wr.write_str(&v[start..i])?; + } + + wr.write_str(escaped)?; + + start = i + 1; + } + + if start != v.len() { + wr.write_str(&v[start..])?; + } + + wr.write_str("\"")?; + Ok(()) +} + +fn escape_char(writer: &mut dyn fmt::Write, v: char) -> EncodeResult { + escape_str(writer, v.encode_utf8(&mut [0; 4])) +} + +fn spaces(wr: &mut dyn fmt::Write, mut n: usize) -> EncodeResult { + const BUF: &str = " "; + + while n >= BUF.len() { + wr.write_str(BUF)?; + n -= BUF.len(); + } + + if n > 0 { + wr.write_str(&BUF[..n])?; + } + Ok(()) +} + +fn fmt_number_or_null(v: f64) -> string::String { + match v.classify() { + Fp::Nan | Fp::Infinite => string::String::from("null"), + _ if v.fract() != 0f64 => v.to_string(), + _ => v.to_string() + ".0", + } +} + +/// A structure for implementing serialization to JSON. +pub struct Encoder<'a> { + writer: &'a mut (dyn fmt::Write + 'a), + is_emitting_map_key: bool, +} + +impl<'a> Encoder<'a> { + /// Creates a new JSON encoder whose output will be written to the writer + /// specified. + pub fn new(writer: &'a mut dyn fmt::Write) -> Encoder<'a> { + Encoder { writer, is_emitting_map_key: false } + } +} + +macro_rules! emit_enquoted_if_mapkey { + ($enc:ident,$e:expr) => {{ + if $enc.is_emitting_map_key { + write!($enc.writer, "\"{}\"", $e)?; + } else { + write!($enc.writer, "{}", $e)?; + } + Ok(()) + }}; +} + +impl<'a> crate::Encoder for Encoder<'a> { + type Error = EncoderError; + + fn emit_unit(&mut self) -> EncodeResult { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + write!(self.writer, "null")?; + Ok(()) + } + + fn emit_usize(&mut self, v: usize) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + fn emit_u128(&mut self, v: u128) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + fn emit_u64(&mut self, v: u64) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + fn emit_u32(&mut self, v: u32) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + fn emit_u16(&mut self, v: u16) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + fn emit_u8(&mut self, v: u8) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + + fn emit_isize(&mut self, v: isize) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + fn emit_i128(&mut self, v: i128) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + fn emit_i64(&mut self, v: i64) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + fn emit_i32(&mut self, v: i32) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + fn emit_i16(&mut self, v: i16) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + fn emit_i8(&mut self, v: i8) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + + fn emit_bool(&mut self, v: bool) -> EncodeResult { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + if v { + write!(self.writer, "true")?; + } else { + write!(self.writer, "false")?; + } + Ok(()) + } + + fn emit_f64(&mut self, v: f64) -> EncodeResult { + emit_enquoted_if_mapkey!(self, fmt_number_or_null(v)) + } + fn emit_f32(&mut self, v: f32) -> EncodeResult { + self.emit_f64(f64::from(v)) + } + + fn emit_char(&mut self, v: char) -> EncodeResult { + escape_char(self.writer, v) + } + fn emit_str(&mut self, v: &str) -> EncodeResult { + escape_str(self.writer, v) + } + + fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult + where + F: FnOnce(&mut Encoder<'a>) -> EncodeResult, + { + f(self) + } + + fn emit_enum_variant<F>(&mut self, name: &str, _id: usize, cnt: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut Encoder<'a>) -> EncodeResult, + { + // enums are encoded as strings or objects + // Bunny => "Bunny" + // Kangaroo(34,"William") => {"variant": "Kangaroo", "fields": [34,"William"]} + if cnt == 0 { + escape_str(self.writer, name) + } else { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + write!(self.writer, "{{\"variant\":")?; + escape_str(self.writer, name)?; + write!(self.writer, ",\"fields\":[")?; + f(self)?; + write!(self.writer, "]}}")?; + Ok(()) + } + } + + fn emit_enum_variant_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut Encoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + if idx != 0 { + write!(self.writer, ",")?; + } + f(self) + } + + fn emit_enum_struct_variant<F>( + &mut self, + name: &str, + id: usize, + cnt: usize, + f: F, + ) -> EncodeResult + where + F: FnOnce(&mut Encoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + self.emit_enum_variant(name, id, cnt, f) + } + + fn emit_enum_struct_variant_field<F>(&mut self, _: &str, idx: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut Encoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + self.emit_enum_variant_arg(idx, f) + } + + fn emit_struct<F>(&mut self, _: &str, _: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut Encoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + write!(self.writer, "{{")?; + f(self)?; + write!(self.writer, "}}")?; + Ok(()) + } + + fn emit_struct_field<F>(&mut self, name: &str, idx: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut Encoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + if idx != 0 { + write!(self.writer, ",")?; + } + escape_str(self.writer, name)?; + write!(self.writer, ":")?; + f(self) + } + + fn emit_tuple<F>(&mut self, len: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut Encoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + self.emit_seq(len, f) + } + fn emit_tuple_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut Encoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + self.emit_seq_elt(idx, f) + } + + fn emit_tuple_struct<F>(&mut self, _name: &str, len: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut Encoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + self.emit_seq(len, f) + } + fn emit_tuple_struct_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut Encoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + self.emit_seq_elt(idx, f) + } + + fn emit_option<F>(&mut self, f: F) -> EncodeResult + where + F: FnOnce(&mut Encoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + f(self) + } + fn emit_option_none(&mut self) -> EncodeResult { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + self.emit_unit() + } + fn emit_option_some<F>(&mut self, f: F) -> EncodeResult + where + F: FnOnce(&mut Encoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + f(self) + } + + fn emit_seq<F>(&mut self, _len: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut Encoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + write!(self.writer, "[")?; + f(self)?; + write!(self.writer, "]")?; + Ok(()) + } + + fn emit_seq_elt<F>(&mut self, idx: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut Encoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + if idx != 0 { + write!(self.writer, ",")?; + } + f(self) + } + + fn emit_map<F>(&mut self, _len: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut Encoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + write!(self.writer, "{{")?; + f(self)?; + write!(self.writer, "}}")?; + Ok(()) + } + + fn emit_map_elt_key<F>(&mut self, idx: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut Encoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + if idx != 0 { + write!(self.writer, ",")? + } + self.is_emitting_map_key = true; + f(self)?; + self.is_emitting_map_key = false; + Ok(()) + } + + fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut Encoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + write!(self.writer, ":")?; + f(self) + } +} + +/// Another encoder for JSON, but prints out human-readable JSON instead of +/// compact data +pub struct PrettyEncoder<'a> { + writer: &'a mut (dyn fmt::Write + 'a), + curr_indent: usize, + indent: usize, + is_emitting_map_key: bool, +} + +impl<'a> PrettyEncoder<'a> { + /// Creates a new encoder whose output will be written to the specified writer + pub fn new(writer: &'a mut dyn fmt::Write) -> PrettyEncoder<'a> { + PrettyEncoder { writer, curr_indent: 0, indent: 2, is_emitting_map_key: false } + } + + /// Sets the number of spaces to indent for each level. + /// This is safe to set during encoding. + pub fn set_indent(&mut self, indent: usize) { + // self.indent very well could be 0 so we need to use checked division. + let level = self.curr_indent.checked_div(self.indent).unwrap_or(0); + self.indent = indent; + self.curr_indent = level * self.indent; + } +} + +impl<'a> crate::Encoder for PrettyEncoder<'a> { + type Error = EncoderError; + + fn emit_unit(&mut self) -> EncodeResult { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + write!(self.writer, "null")?; + Ok(()) + } + + fn emit_usize(&mut self, v: usize) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + fn emit_u128(&mut self, v: u128) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + fn emit_u64(&mut self, v: u64) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + fn emit_u32(&mut self, v: u32) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + fn emit_u16(&mut self, v: u16) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + fn emit_u8(&mut self, v: u8) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + + fn emit_isize(&mut self, v: isize) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + fn emit_i128(&mut self, v: i128) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + fn emit_i64(&mut self, v: i64) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + fn emit_i32(&mut self, v: i32) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + fn emit_i16(&mut self, v: i16) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + fn emit_i8(&mut self, v: i8) -> EncodeResult { + emit_enquoted_if_mapkey!(self, v) + } + + fn emit_bool(&mut self, v: bool) -> EncodeResult { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + if v { + write!(self.writer, "true")?; + } else { + write!(self.writer, "false")?; + } + Ok(()) + } + + fn emit_f64(&mut self, v: f64) -> EncodeResult { + emit_enquoted_if_mapkey!(self, fmt_number_or_null(v)) + } + fn emit_f32(&mut self, v: f32) -> EncodeResult { + self.emit_f64(f64::from(v)) + } + + fn emit_char(&mut self, v: char) -> EncodeResult { + escape_char(self.writer, v) + } + fn emit_str(&mut self, v: &str) -> EncodeResult { + escape_str(self.writer, v) + } + + fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult + where + F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult, + { + f(self) + } + + fn emit_enum_variant<F>(&mut self, name: &str, _id: usize, cnt: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult, + { + if cnt == 0 { + escape_str(self.writer, name) + } else { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + writeln!(self.writer, "{{")?; + self.curr_indent += self.indent; + spaces(self.writer, self.curr_indent)?; + write!(self.writer, "\"variant\": ")?; + escape_str(self.writer, name)?; + writeln!(self.writer, ",")?; + spaces(self.writer, self.curr_indent)?; + writeln!(self.writer, "\"fields\": [")?; + self.curr_indent += self.indent; + f(self)?; + self.curr_indent -= self.indent; + writeln!(self.writer)?; + spaces(self.writer, self.curr_indent)?; + self.curr_indent -= self.indent; + writeln!(self.writer, "]")?; + spaces(self.writer, self.curr_indent)?; + write!(self.writer, "}}")?; + Ok(()) + } + } + + fn emit_enum_variant_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + if idx != 0 { + writeln!(self.writer, ",")?; + } + spaces(self.writer, self.curr_indent)?; + f(self) + } + + fn emit_enum_struct_variant<F>( + &mut self, + name: &str, + id: usize, + cnt: usize, + f: F, + ) -> EncodeResult + where + F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + self.emit_enum_variant(name, id, cnt, f) + } + + fn emit_enum_struct_variant_field<F>(&mut self, _: &str, idx: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + self.emit_enum_variant_arg(idx, f) + } + + fn emit_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + if len == 0 { + write!(self.writer, "{{}}")?; + } else { + write!(self.writer, "{{")?; + self.curr_indent += self.indent; + f(self)?; + self.curr_indent -= self.indent; + writeln!(self.writer)?; + spaces(self.writer, self.curr_indent)?; + write!(self.writer, "}}")?; + } + Ok(()) + } + + fn emit_struct_field<F>(&mut self, name: &str, idx: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + if idx == 0 { + writeln!(self.writer)?; + } else { + writeln!(self.writer, ",")?; + } + spaces(self.writer, self.curr_indent)?; + escape_str(self.writer, name)?; + write!(self.writer, ": ")?; + f(self) + } + + fn emit_tuple<F>(&mut self, len: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + self.emit_seq(len, f) + } + fn emit_tuple_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + self.emit_seq_elt(idx, f) + } + + fn emit_tuple_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + self.emit_seq(len, f) + } + fn emit_tuple_struct_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + self.emit_seq_elt(idx, f) + } + + fn emit_option<F>(&mut self, f: F) -> EncodeResult + where + F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + f(self) + } + fn emit_option_none(&mut self) -> EncodeResult { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + self.emit_unit() + } + fn emit_option_some<F>(&mut self, f: F) -> EncodeResult + where + F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + f(self) + } + + fn emit_seq<F>(&mut self, len: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + if len == 0 { + write!(self.writer, "[]")?; + } else { + write!(self.writer, "[")?; + self.curr_indent += self.indent; + f(self)?; + self.curr_indent -= self.indent; + writeln!(self.writer)?; + spaces(self.writer, self.curr_indent)?; + write!(self.writer, "]")?; + } + Ok(()) + } + + fn emit_seq_elt<F>(&mut self, idx: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + if idx == 0 { + writeln!(self.writer)?; + } else { + writeln!(self.writer, ",")?; + } + spaces(self.writer, self.curr_indent)?; + f(self) + } + + fn emit_map<F>(&mut self, len: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + if len == 0 { + write!(self.writer, "{{}}")?; + } else { + write!(self.writer, "{{")?; + self.curr_indent += self.indent; + f(self)?; + self.curr_indent -= self.indent; + writeln!(self.writer)?; + spaces(self.writer, self.curr_indent)?; + write!(self.writer, "}}")?; + } + Ok(()) + } + + fn emit_map_elt_key<F>(&mut self, idx: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + if idx == 0 { + writeln!(self.writer)?; + } else { + writeln!(self.writer, ",")?; + } + spaces(self.writer, self.curr_indent)?; + self.is_emitting_map_key = true; + f(self)?; + self.is_emitting_map_key = false; + Ok(()) + } + + fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F) -> EncodeResult + where + F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult, + { + if self.is_emitting_map_key { + return Err(EncoderError::BadHashmapKey); + } + write!(self.writer, ": ")?; + f(self) + } +} + +impl<E: crate::Encoder> Encodable<E> for Json { + fn encode(&self, e: &mut E) -> Result<(), E::Error> { + match *self { + Json::I64(v) => v.encode(e), + Json::U64(v) => v.encode(e), + Json::F64(v) => v.encode(e), + Json::String(ref v) => v.encode(e), + Json::Boolean(v) => v.encode(e), + Json::Array(ref v) => v.encode(e), + Json::Object(ref v) => v.encode(e), + Json::Null => e.emit_unit(), + } + } +} + +/// Creates an `AsJson` wrapper which can be used to print a value as JSON +/// on-the-fly via `write!` +pub fn as_json<T>(t: &T) -> AsJson<'_, T> { + AsJson { inner: t } +} + +/// Creates an `AsPrettyJson` wrapper which can be used to print a value as JSON +/// on-the-fly via `write!` +pub fn as_pretty_json<T>(t: &T) -> AsPrettyJson<'_, T> { + AsPrettyJson { inner: t, indent: None } +} + +impl Json { + /// Borrow this json object as a pretty object to generate a pretty + /// representation for it via `Display`. + pub fn pretty(&self) -> PrettyJson<'_> { + PrettyJson { inner: self } + } + + /// If the Json value is an Object, returns the value associated with the provided key. + /// Otherwise, returns None. + pub fn find(&self, key: &str) -> Option<&Json> { + match *self { + Json::Object(ref map) => map.get(key), + _ => None, + } + } + + /// Attempts to get a nested Json Object for each key in `keys`. + /// If any key is found not to exist, `find_path` will return `None`. + /// Otherwise, it will return the Json value associated with the final key. + pub fn find_path<'a>(&'a self, keys: &[&str]) -> Option<&'a Json> { + let mut target = self; + for key in keys { + target = target.find(*key)?; + } + Some(target) + } + + /// If the Json value is an Object, performs a depth-first search until + /// a value associated with the provided key is found. If no value is found + /// or the Json value is not an Object, returns `None`. + pub fn search(&self, key: &str) -> Option<&Json> { + match *self { + Json::Object(ref map) => match map.get(key) { + Some(json_value) => Some(json_value), + None => { + for v in map.values() { + match v.search(key) { + x if x.is_some() => return x, + _ => (), + } + } + None + } + }, + _ => None, + } + } + + /// Returns `true` if the Json value is an `Object`. + pub fn is_object(&self) -> bool { + self.as_object().is_some() + } + + /// If the Json value is an `Object`, returns the associated `BTreeMap`; + /// returns `None` otherwise. + pub fn as_object(&self) -> Option<&Object> { + match *self { + Json::Object(ref map) => Some(map), + _ => None, + } + } + + /// Returns `true` if the Json value is an `Array`. + pub fn is_array(&self) -> bool { + self.as_array().is_some() + } + + /// If the Json value is an `Array`, returns the associated vector; + /// returns `None` otherwise. + pub fn as_array(&self) -> Option<&Array> { + match *self { + Json::Array(ref array) => Some(&*array), + _ => None, + } + } + + /// Returns `true` if the Json value is a `String`. + pub fn is_string(&self) -> bool { + self.as_string().is_some() + } + + /// If the Json value is a `String`, returns the associated `str`; + /// returns `None` otherwise. + pub fn as_string(&self) -> Option<&str> { + match *self { + Json::String(ref s) => Some(&s[..]), + _ => None, + } + } + + /// Returns `true` if the Json value is a `Number`. + pub fn is_number(&self) -> bool { + matches!(*self, Json::I64(_) | Json::U64(_) | Json::F64(_)) + } + + /// Returns `true` if the Json value is a `i64`. + pub fn is_i64(&self) -> bool { + matches!(*self, Json::I64(_)) + } + + /// Returns `true` if the Json value is a `u64`. + pub fn is_u64(&self) -> bool { + matches!(*self, Json::U64(_)) + } + + /// Returns `true` if the Json value is a `f64`. + pub fn is_f64(&self) -> bool { + matches!(*self, Json::F64(_)) + } + + /// If the Json value is a number, returns or cast it to a `i64`; + /// returns `None` otherwise. + pub fn as_i64(&self) -> Option<i64> { + match *self { + Json::I64(n) => Some(n), + Json::U64(n) => Some(n as i64), + _ => None, + } + } + + /// If the Json value is a number, returns or cast it to a `u64`; + /// returns `None` otherwise. + pub fn as_u64(&self) -> Option<u64> { + match *self { + Json::I64(n) => Some(n as u64), + Json::U64(n) => Some(n), + _ => None, + } + } + + /// If the Json value is a number, returns or cast it to a `f64`; + /// returns `None` otherwise. + pub fn as_f64(&self) -> Option<f64> { + match *self { + Json::I64(n) => Some(n as f64), + Json::U64(n) => Some(n as f64), + Json::F64(n) => Some(n), + _ => None, + } + } + + /// Returns `true` if the Json value is a `Boolean`. + pub fn is_boolean(&self) -> bool { + self.as_boolean().is_some() + } + + /// If the Json value is a `Boolean`, returns the associated `bool`; + /// returns `None` otherwise. + pub fn as_boolean(&self) -> Option<bool> { + match *self { + Json::Boolean(b) => Some(b), + _ => None, + } + } + + /// Returns `true` if the Json value is a `Null`. + pub fn is_null(&self) -> bool { + self.as_null().is_some() + } + + /// If the Json value is a `Null`, returns `()`; + /// returns `None` otherwise. + pub fn as_null(&self) -> Option<()> { + match *self { + Json::Null => Some(()), + _ => None, + } + } +} + +impl<'a> Index<&'a str> for Json { + type Output = Json; + + fn index(&self, idx: &'a str) -> &Json { + self.find(idx).unwrap() + } +} + +impl Index<usize> for Json { + type Output = Json; + + fn index(&self, idx: usize) -> &Json { + match *self { + Json::Array(ref v) => &v[idx], + _ => panic!("can only index Json with usize if it is an array"), + } + } +} + +/// The output of the streaming parser. +#[derive(PartialEq, Clone, Debug)] +pub enum JsonEvent { + ObjectStart, + ObjectEnd, + ArrayStart, + ArrayEnd, + BooleanValue(bool), + I64Value(i64), + U64Value(u64), + F64Value(f64), + StringValue(string::String), + NullValue, + Error(ParserError), +} + +#[derive(PartialEq, Debug)] +enum ParserState { + // Parse a value in an array, true means first element. + ParseArray(bool), + // Parse ',' or ']' after an element in an array. + ParseArrayComma, + // Parse a key:value in an object, true means first element. + ParseObject(bool), + // Parse ',' or ']' after an element in an object. + ParseObjectComma, + // Initial state. + ParseStart, + // Expecting the stream to end. + ParseBeforeFinish, + // Parsing can't continue. + ParseFinished, +} + +/// A Stack represents the current position of the parser in the logical +/// structure of the JSON stream. +/// +/// An example is `foo.bar[3].x`. +#[derive(Default)] +pub struct Stack { + stack: Vec<InternalStackElement>, + str_buffer: Vec<u8>, +} + +/// StackElements compose a Stack. +/// +/// As an example, `StackElement::Key("foo")`, `StackElement::Key("bar")`, +/// `StackElement::Index(3)`, and `StackElement::Key("x")` are the +/// StackElements composing the stack that represents `foo.bar[3].x`. +#[derive(PartialEq, Clone, Debug)] +pub enum StackElement<'l> { + Index(u32), + Key(&'l str), +} + +// Internally, Key elements are stored as indices in a buffer to avoid +// allocating a string for every member of an object. +#[derive(PartialEq, Clone, Debug)] +enum InternalStackElement { + InternalIndex(u32), + InternalKey(u16, u16), // start, size +} + +impl Stack { + pub fn new() -> Stack { + Self::default() + } + + /// Returns The number of elements in the Stack. + pub fn len(&self) -> usize { + self.stack.len() + } + + /// Returns `true` if the stack is empty. + pub fn is_empty(&self) -> bool { + self.stack.is_empty() + } + + /// Provides access to the StackElement at a given index. + /// lower indices are at the bottom of the stack while higher indices are + /// at the top. + pub fn get(&self, idx: usize) -> StackElement<'_> { + match self.stack[idx] { + InternalIndex(i) => StackElement::Index(i), + InternalKey(start, size) => StackElement::Key( + str::from_utf8(&self.str_buffer[start as usize..start as usize + size as usize]) + .unwrap(), + ), + } + } + + /// Compares this stack with an array of StackElement<'_>s. + pub fn is_equal_to(&self, rhs: &[StackElement<'_>]) -> bool { + if self.stack.len() != rhs.len() { + return false; + } + for (i, r) in rhs.iter().enumerate() { + if self.get(i) != *r { + return false; + } + } + true + } + + /// Returns `true` if the bottom-most elements of this stack are the same as + /// the ones passed as parameter. + pub fn starts_with(&self, rhs: &[StackElement<'_>]) -> bool { + if self.stack.len() < rhs.len() { + return false; + } + for (i, r) in rhs.iter().enumerate() { + if self.get(i) != *r { + return false; + } + } + true + } + + /// Returns `true` if the top-most elements of this stack are the same as + /// the ones passed as parameter. + pub fn ends_with(&self, rhs: &[StackElement<'_>]) -> bool { + if self.stack.len() < rhs.len() { + return false; + } + let offset = self.stack.len() - rhs.len(); + for (i, r) in rhs.iter().enumerate() { + if self.get(i + offset) != *r { + return false; + } + } + true + } + + /// Returns the top-most element (if any). + pub fn top(&self) -> Option<StackElement<'_>> { + match self.stack.last() { + None => None, + Some(&InternalIndex(i)) => Some(StackElement::Index(i)), + Some(&InternalKey(start, size)) => Some(StackElement::Key( + str::from_utf8(&self.str_buffer[start as usize..(start + size) as usize]).unwrap(), + )), + } + } + + // Used by Parser to insert StackElement::Key elements at the top of the stack. + fn push_key(&mut self, key: string::String) { + self.stack.push(InternalKey(self.str_buffer.len() as u16, key.len() as u16)); + self.str_buffer.extend(key.as_bytes()); + } + + // Used by Parser to insert StackElement::Index elements at the top of the stack. + fn push_index(&mut self, index: u32) { + self.stack.push(InternalIndex(index)); + } + + // Used by Parser to remove the top-most element of the stack. + fn pop(&mut self) { + assert!(!self.is_empty()); + match *self.stack.last().unwrap() { + InternalKey(_, sz) => { + let new_size = self.str_buffer.len() - sz as usize; + self.str_buffer.truncate(new_size); + } + InternalIndex(_) => {} + } + self.stack.pop(); + } + + // Used by Parser to test whether the top-most element is an index. + fn last_is_index(&self) -> bool { + matches!(self.stack.last(), Some(InternalIndex(_))) + } + + // Used by Parser to increment the index of the top-most element. + fn bump_index(&mut self) { + let len = self.stack.len(); + let idx = match *self.stack.last().unwrap() { + InternalIndex(i) => i + 1, + _ => { + panic!(); + } + }; + self.stack[len - 1] = InternalIndex(idx); + } +} + +/// A streaming JSON parser implemented as an iterator of JsonEvent, consuming +/// an iterator of char. +pub struct Parser<T> { + rdr: T, + ch: Option<char>, + line: usize, + col: usize, + // We maintain a stack representing where we are in the logical structure + // of the JSON stream. + stack: Stack, + // A state machine is kept to make it possible to interrupt and resume parsing. + state: ParserState, +} + +impl<T: Iterator<Item = char>> Iterator for Parser<T> { + type Item = JsonEvent; + + fn next(&mut self) -> Option<JsonEvent> { + if self.state == ParseFinished { + return None; + } + + if self.state == ParseBeforeFinish { + self.parse_whitespace(); + // Make sure there is no trailing characters. + if self.eof() { + self.state = ParseFinished; + return None; + } else { + return Some(self.error_event(TrailingCharacters)); + } + } + + Some(self.parse()) + } +} + +impl<T: Iterator<Item = char>> Parser<T> { + /// Creates the JSON parser. + pub fn new(rdr: T) -> Parser<T> { + let mut p = Parser { + rdr, + ch: Some('\x00'), + line: 1, + col: 0, + stack: Stack::new(), + state: ParseStart, + }; + p.bump(); + p + } + + /// Provides access to the current position in the logical structure of the + /// JSON stream. + pub fn stack(&self) -> &Stack { + &self.stack + } + + fn eof(&self) -> bool { + self.ch.is_none() + } + fn ch_or_null(&self) -> char { + self.ch.unwrap_or('\x00') + } + fn bump(&mut self) { + self.ch = self.rdr.next(); + + if self.ch_is('\n') { + self.line += 1; + self.col = 1; + } else { + self.col += 1; + } + } + + fn next_char(&mut self) -> Option<char> { + self.bump(); + self.ch + } + fn ch_is(&self, c: char) -> bool { + self.ch == Some(c) + } + + fn error<U>(&self, reason: ErrorCode) -> Result<U, ParserError> { + Err(SyntaxError(reason, self.line, self.col)) + } + + fn parse_whitespace(&mut self) { + while self.ch_is(' ') || self.ch_is('\n') || self.ch_is('\t') || self.ch_is('\r') { + self.bump(); + } + } + + fn parse_number(&mut self) -> JsonEvent { + let neg = if self.ch_is('-') { + self.bump(); + true + } else { + false + }; + + let res = match self.parse_u64() { + Ok(res) => res, + Err(e) => { + return Error(e); + } + }; + + if self.ch_is('.') || self.ch_is('e') || self.ch_is('E') { + let mut res = res as f64; + + if self.ch_is('.') { + res = match self.parse_decimal(res) { + Ok(res) => res, + Err(e) => { + return Error(e); + } + }; + } + + if self.ch_is('e') || self.ch_is('E') { + res = match self.parse_exponent(res) { + Ok(res) => res, + Err(e) => { + return Error(e); + } + }; + } + + if neg { + res *= -1.0; + } + + F64Value(res) + } else if neg { + let res = (res as i64).wrapping_neg(); + + // Make sure we didn't underflow. + if res > 0 { + Error(SyntaxError(InvalidNumber, self.line, self.col)) + } else { + I64Value(res) + } + } else { + U64Value(res) + } + } + + fn parse_u64(&mut self) -> Result<u64, ParserError> { + let mut accum = 0u64; + let last_accum = 0; // necessary to detect overflow. + + match self.ch_or_null() { + '0' => { + self.bump(); + + // A leading '0' must be the only digit before the decimal point. + if let '0'..='9' = self.ch_or_null() { + return self.error(InvalidNumber); + } + } + '1'..='9' => { + while !self.eof() { + match self.ch_or_null() { + c @ '0'..='9' => { + accum = accum.wrapping_mul(10); + accum = accum.wrapping_add((c as u64) - ('0' as u64)); + + // Detect overflow by comparing to the last value. + if accum <= last_accum { + return self.error(InvalidNumber); + } + + self.bump(); + } + _ => break, + } + } + } + _ => return self.error(InvalidNumber), + } + + Ok(accum) + } + + fn parse_decimal(&mut self, mut res: f64) -> Result<f64, ParserError> { + self.bump(); + + // Make sure a digit follows the decimal place. + match self.ch_or_null() { + '0'..='9' => (), + _ => return self.error(InvalidNumber), + } + + let mut dec = 1.0; + while !self.eof() { + match self.ch_or_null() { + c @ '0'..='9' => { + dec /= 10.0; + res += (((c as isize) - ('0' as isize)) as f64) * dec; + self.bump(); + } + _ => break, + } + } + + Ok(res) + } + + fn parse_exponent(&mut self, mut res: f64) -> Result<f64, ParserError> { + self.bump(); + + let mut exp = 0; + let mut neg_exp = false; + + if self.ch_is('+') { + self.bump(); + } else if self.ch_is('-') { + self.bump(); + neg_exp = true; + } + + // Make sure a digit follows the exponent place. + match self.ch_or_null() { + '0'..='9' => (), + _ => return self.error(InvalidNumber), + } + while !self.eof() { + match self.ch_or_null() { + c @ '0'..='9' => { + exp *= 10; + exp += (c as usize) - ('0' as usize); + + self.bump(); + } + _ => break, + } + } + + let exp = 10_f64.powi(exp as i32); + if neg_exp { + res /= exp; + } else { + res *= exp; + } + + Ok(res) + } + + fn decode_hex_escape(&mut self) -> Result<u16, ParserError> { + let mut i = 0; + let mut n = 0; + while i < 4 && !self.eof() { + self.bump(); + n = match self.ch_or_null() { + c @ '0'..='9' => n * 16 + ((c as u16) - ('0' as u16)), + 'a' | 'A' => n * 16 + 10, + 'b' | 'B' => n * 16 + 11, + 'c' | 'C' => n * 16 + 12, + 'd' | 'D' => n * 16 + 13, + 'e' | 'E' => n * 16 + 14, + 'f' | 'F' => n * 16 + 15, + _ => return self.error(InvalidEscape), + }; + + i += 1; + } + + // Error out if we didn't parse 4 digits. + if i != 4 { + return self.error(InvalidEscape); + } + + Ok(n) + } + + fn parse_str(&mut self) -> Result<string::String, ParserError> { + let mut escape = false; + let mut res = string::String::new(); + + loop { + self.bump(); + if self.eof() { + return self.error(EOFWhileParsingString); + } + + if escape { + match self.ch_or_null() { + '"' => res.push('"'), + '\\' => res.push('\\'), + '/' => res.push('/'), + 'b' => res.push('\x08'), + 'f' => res.push('\x0c'), + 'n' => res.push('\n'), + 'r' => res.push('\r'), + 't' => res.push('\t'), + 'u' => match self.decode_hex_escape()? { + 0xDC00..=0xDFFF => return self.error(LoneLeadingSurrogateInHexEscape), + + // Non-BMP characters are encoded as a sequence of + // two hex escapes, representing UTF-16 surrogates. + n1 @ 0xD800..=0xDBFF => { + match (self.next_char(), self.next_char()) { + (Some('\\'), Some('u')) => (), + _ => return self.error(UnexpectedEndOfHexEscape), + } + + let n2 = self.decode_hex_escape()?; + if n2 < 0xDC00 || n2 > 0xDFFF { + return self.error(LoneLeadingSurrogateInHexEscape); + } + let c = + (u32::from(n1 - 0xD800) << 10 | u32::from(n2 - 0xDC00)) + 0x1_0000; + res.push(char::from_u32(c).unwrap()); + } + + n => match char::from_u32(u32::from(n)) { + Some(c) => res.push(c), + None => return self.error(InvalidUnicodeCodePoint), + }, + }, + _ => return self.error(InvalidEscape), + } + escape = false; + } else if self.ch_is('\\') { + escape = true; + } else { + match self.ch { + Some('"') => { + self.bump(); + return Ok(res); + } + Some(c) => res.push(c), + None => unreachable!(), + } + } + } + } + + // Invoked at each iteration, consumes the stream until it has enough + // information to return a JsonEvent. + // Manages an internal state so that parsing can be interrupted and resumed. + // Also keeps track of the position in the logical structure of the json + // stream isize the form of a stack that can be queried by the user using the + // stack() method. + fn parse(&mut self) -> JsonEvent { + loop { + // The only paths where the loop can spin a new iteration + // are in the cases ParseArrayComma and ParseObjectComma if ',' + // is parsed. In these cases the state is set to (respectively) + // ParseArray(false) and ParseObject(false), which always return, + // so there is no risk of getting stuck in an infinite loop. + // All other paths return before the end of the loop's iteration. + self.parse_whitespace(); + + match self.state { + ParseStart => { + return self.parse_start(); + } + ParseArray(first) => { + return self.parse_array(first); + } + ParseArrayComma => { + if let Some(evt) = self.parse_array_comma_or_end() { + return evt; + } + } + ParseObject(first) => { + return self.parse_object(first); + } + ParseObjectComma => { + self.stack.pop(); + if self.ch_is(',') { + self.state = ParseObject(false); + self.bump(); + } else { + return self.parse_object_end(); + } + } + _ => { + return self.error_event(InvalidSyntax); + } + } + } + } + + fn parse_start(&mut self) -> JsonEvent { + let val = self.parse_value(); + self.state = match val { + Error(_) => ParseFinished, + ArrayStart => ParseArray(true), + ObjectStart => ParseObject(true), + _ => ParseBeforeFinish, + }; + val + } + + fn parse_array(&mut self, first: bool) -> JsonEvent { + if self.ch_is(']') { + if !first { + self.error_event(InvalidSyntax) + } else { + self.state = if self.stack.is_empty() { + ParseBeforeFinish + } else if self.stack.last_is_index() { + ParseArrayComma + } else { + ParseObjectComma + }; + self.bump(); + ArrayEnd + } + } else { + if first { + self.stack.push_index(0); + } + let val = self.parse_value(); + self.state = match val { + Error(_) => ParseFinished, + ArrayStart => ParseArray(true), + ObjectStart => ParseObject(true), + _ => ParseArrayComma, + }; + val + } + } + + fn parse_array_comma_or_end(&mut self) -> Option<JsonEvent> { + if self.ch_is(',') { + self.stack.bump_index(); + self.state = ParseArray(false); + self.bump(); + None + } else if self.ch_is(']') { + self.stack.pop(); + self.state = if self.stack.is_empty() { + ParseBeforeFinish + } else if self.stack.last_is_index() { + ParseArrayComma + } else { + ParseObjectComma + }; + self.bump(); + Some(ArrayEnd) + } else if self.eof() { + Some(self.error_event(EOFWhileParsingArray)) + } else { + Some(self.error_event(InvalidSyntax)) + } + } + + fn parse_object(&mut self, first: bool) -> JsonEvent { + if self.ch_is('}') { + if !first { + if self.stack.is_empty() { + return self.error_event(TrailingComma); + } else { + self.stack.pop(); + } + } + self.state = if self.stack.is_empty() { + ParseBeforeFinish + } else if self.stack.last_is_index() { + ParseArrayComma + } else { + ParseObjectComma + }; + self.bump(); + return ObjectEnd; + } + if self.eof() { + return self.error_event(EOFWhileParsingObject); + } + if !self.ch_is('"') { + return self.error_event(KeyMustBeAString); + } + let s = match self.parse_str() { + Ok(s) => s, + Err(e) => { + self.state = ParseFinished; + return Error(e); + } + }; + self.parse_whitespace(); + if self.eof() { + return self.error_event(EOFWhileParsingObject); + } else if self.ch_or_null() != ':' { + return self.error_event(ExpectedColon); + } + self.stack.push_key(s); + self.bump(); + self.parse_whitespace(); + + let val = self.parse_value(); + + self.state = match val { + Error(_) => ParseFinished, + ArrayStart => ParseArray(true), + ObjectStart => ParseObject(true), + _ => ParseObjectComma, + }; + val + } + + fn parse_object_end(&mut self) -> JsonEvent { + if self.ch_is('}') { + self.state = if self.stack.is_empty() { + ParseBeforeFinish + } else if self.stack.last_is_index() { + ParseArrayComma + } else { + ParseObjectComma + }; + self.bump(); + ObjectEnd + } else if self.eof() { + self.error_event(EOFWhileParsingObject) + } else { + self.error_event(InvalidSyntax) + } + } + + fn parse_value(&mut self) -> JsonEvent { + if self.eof() { + return self.error_event(EOFWhileParsingValue); + } + match self.ch_or_null() { + 'n' => self.parse_ident("ull", NullValue), + 't' => self.parse_ident("rue", BooleanValue(true)), + 'f' => self.parse_ident("alse", BooleanValue(false)), + '0'..='9' | '-' => self.parse_number(), + '"' => match self.parse_str() { + Ok(s) => StringValue(s), + Err(e) => Error(e), + }, + '[' => { + self.bump(); + ArrayStart + } + '{' => { + self.bump(); + ObjectStart + } + _ => self.error_event(InvalidSyntax), + } + } + + fn parse_ident(&mut self, ident: &str, value: JsonEvent) -> JsonEvent { + if ident.chars().all(|c| Some(c) == self.next_char()) { + self.bump(); + value + } else { + Error(SyntaxError(InvalidSyntax, self.line, self.col)) + } + } + + fn error_event(&mut self, reason: ErrorCode) -> JsonEvent { + self.state = ParseFinished; + Error(SyntaxError(reason, self.line, self.col)) + } +} + +/// A Builder consumes a json::Parser to create a generic Json structure. +pub struct Builder<T> { + parser: Parser<T>, + token: Option<JsonEvent>, +} + +impl<T: Iterator<Item = char>> Builder<T> { + /// Creates a JSON Builder. + pub fn new(src: T) -> Builder<T> { + Builder { parser: Parser::new(src), token: None } + } + + // Decode a Json value from a Parser. + pub fn build(&mut self) -> Result<Json, BuilderError> { + self.bump(); + let result = self.build_value(); + self.bump(); + match self.token { + None => {} + Some(Error(ref e)) => { + return Err(e.clone()); + } + ref tok => { + panic!("unexpected token {:?}", tok.clone()); + } + } + result + } + + fn bump(&mut self) { + self.token = self.parser.next(); + } + + fn build_value(&mut self) -> Result<Json, BuilderError> { + match self.token { + Some(NullValue) => Ok(Json::Null), + Some(I64Value(n)) => Ok(Json::I64(n)), + Some(U64Value(n)) => Ok(Json::U64(n)), + Some(F64Value(n)) => Ok(Json::F64(n)), + Some(BooleanValue(b)) => Ok(Json::Boolean(b)), + Some(StringValue(ref mut s)) => { + let mut temp = string::String::new(); + swap(s, &mut temp); + Ok(Json::String(temp)) + } + Some(Error(ref e)) => Err(e.clone()), + Some(ArrayStart) => self.build_array(), + Some(ObjectStart) => self.build_object(), + Some(ObjectEnd) => self.parser.error(InvalidSyntax), + Some(ArrayEnd) => self.parser.error(InvalidSyntax), + None => self.parser.error(EOFWhileParsingValue), + } + } + + fn build_array(&mut self) -> Result<Json, BuilderError> { + self.bump(); + let mut values = Vec::new(); + + loop { + if self.token == Some(ArrayEnd) { + return Ok(Json::Array(values.into_iter().collect())); + } + match self.build_value() { + Ok(v) => values.push(v), + Err(e) => return Err(e), + } + self.bump(); + } + } + + fn build_object(&mut self) -> Result<Json, BuilderError> { + self.bump(); + + let mut values = BTreeMap::new(); + + loop { + match self.token { + Some(ObjectEnd) => { + return Ok(Json::Object(values)); + } + Some(Error(ref e)) => { + return Err(e.clone()); + } + None => { + break; + } + _ => {} + } + let key = match self.parser.stack().top() { + Some(StackElement::Key(k)) => k.to_owned(), + _ => { + panic!("invalid state"); + } + }; + match self.build_value() { + Ok(value) => { + values.insert(key, value); + } + Err(e) => { + return Err(e); + } + } + self.bump(); + } + self.parser.error(EOFWhileParsingObject) + } +} + +/// Decodes a json value from an `&mut io::Read` +pub fn from_reader(rdr: &mut dyn Read) -> Result<Json, BuilderError> { + let mut contents = Vec::new(); + match rdr.read_to_end(&mut contents) { + Ok(c) => c, + Err(e) => return Err(io_error_to_error(e)), + }; + let s = match str::from_utf8(&contents).ok() { + Some(s) => s, + _ => return Err(SyntaxError(NotUtf8, 0, 0)), + }; + let mut builder = Builder::new(s.chars()); + builder.build() +} + +/// Decodes a json value from a string +pub fn from_str(s: &str) -> Result<Json, BuilderError> { + let mut builder = Builder::new(s.chars()); + builder.build() +} + +/// A structure to decode JSON to values in rust. +pub struct Decoder { + stack: Vec<Json>, +} + +impl Decoder { + /// Creates a new decoder instance for decoding the specified JSON value. + pub fn new(json: Json) -> Decoder { + Decoder { stack: vec![json] } + } + + fn pop(&mut self) -> Json { + self.stack.pop().unwrap() + } +} + +macro_rules! expect { + ($e:expr, Null) => {{ + match $e { + Json::Null => Ok(()), + other => Err(ExpectedError("Null".to_owned(), other.to_string())), + } + }}; + ($e:expr, $t:ident) => {{ + match $e { + Json::$t(v) => Ok(v), + other => Err(ExpectedError(stringify!($t).to_owned(), other.to_string())), + } + }}; +} + +macro_rules! read_primitive { + ($name:ident, $ty:ty) => { + fn $name(&mut self) -> DecodeResult<$ty> { + match self.pop() { + Json::I64(f) => Ok(f as $ty), + Json::U64(f) => Ok(f as $ty), + Json::F64(f) => Err(ExpectedError("Integer".to_owned(), f.to_string())), + // re: #12967.. a type w/ numeric keys (ie HashMap<usize, V> etc) + // is going to have a string here, as per JSON spec. + Json::String(s) => match s.parse().ok() { + Some(f) => Ok(f), + None => Err(ExpectedError("Number".to_owned(), s)), + }, + value => Err(ExpectedError("Number".to_owned(), value.to_string())), + } + } + }; +} + +impl crate::Decoder for Decoder { + type Error = DecoderError; + + fn read_nil(&mut self) -> DecodeResult<()> { + expect!(self.pop(), Null) + } + + read_primitive! { read_usize, usize } + read_primitive! { read_u8, u8 } + read_primitive! { read_u16, u16 } + read_primitive! { read_u32, u32 } + read_primitive! { read_u64, u64 } + read_primitive! { read_u128, u128 } + read_primitive! { read_isize, isize } + read_primitive! { read_i8, i8 } + read_primitive! { read_i16, i16 } + read_primitive! { read_i32, i32 } + read_primitive! { read_i64, i64 } + read_primitive! { read_i128, i128 } + + fn read_f32(&mut self) -> DecodeResult<f32> { + self.read_f64().map(|x| x as f32) + } + + fn read_f64(&mut self) -> DecodeResult<f64> { + match self.pop() { + Json::I64(f) => Ok(f as f64), + Json::U64(f) => Ok(f as f64), + Json::F64(f) => Ok(f), + Json::String(s) => { + // re: #12967.. a type w/ numeric keys (ie HashMap<usize, V> etc) + // is going to have a string here, as per JSON spec. + match s.parse().ok() { + Some(f) => Ok(f), + None => Err(ExpectedError("Number".to_owned(), s)), + } + } + Json::Null => Ok(f64::NAN), + value => Err(ExpectedError("Number".to_owned(), value.to_string())), + } + } + + fn read_bool(&mut self) -> DecodeResult<bool> { + expect!(self.pop(), Boolean) + } + + fn read_char(&mut self) -> DecodeResult<char> { + let s = self.read_str()?; + { + let mut it = s.chars(); + if let (Some(c), None) = (it.next(), it.next()) { + // exactly one character + return Ok(c); + } + } + Err(ExpectedError("single character string".to_owned(), s.to_string())) + } + + fn read_str(&mut self) -> DecodeResult<Cow<'_, str>> { + expect!(self.pop(), String).map(Cow::Owned) + } + + fn read_enum<T, F>(&mut self, _name: &str, f: F) -> DecodeResult<T> + where + F: FnOnce(&mut Decoder) -> DecodeResult<T>, + { + f(self) + } + + fn read_enum_variant<T, F>(&mut self, names: &[&str], mut f: F) -> DecodeResult<T> + where + F: FnMut(&mut Decoder, usize) -> DecodeResult<T>, + { + let name = match self.pop() { + Json::String(s) => s, + Json::Object(mut o) => { + let n = match o.remove(&"variant".to_owned()) { + Some(Json::String(s)) => s, + Some(val) => return Err(ExpectedError("String".to_owned(), val.to_string())), + None => return Err(MissingFieldError("variant".to_owned())), + }; + match o.remove(&"fields".to_string()) { + Some(Json::Array(l)) => { + self.stack.extend(l.into_iter().rev()); + } + Some(val) => return Err(ExpectedError("Array".to_owned(), val.to_string())), + None => return Err(MissingFieldError("fields".to_owned())), + } + n + } + json => return Err(ExpectedError("String or Object".to_owned(), json.to_string())), + }; + let idx = match names.iter().position(|n| *n == &name[..]) { + Some(idx) => idx, + None => return Err(UnknownVariantError(name)), + }; + f(self, idx) + } + + fn read_enum_variant_arg<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> + where + F: FnOnce(&mut Decoder) -> DecodeResult<T>, + { + f(self) + } + + fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> DecodeResult<T> + where + F: FnMut(&mut Decoder, usize) -> DecodeResult<T>, + { + self.read_enum_variant(names, f) + } + + fn read_enum_struct_variant_field<T, F>( + &mut self, + _name: &str, + idx: usize, + f: F, + ) -> DecodeResult<T> + where + F: FnOnce(&mut Decoder) -> DecodeResult<T>, + { + self.read_enum_variant_arg(idx, f) + } + + fn read_struct<T, F>(&mut self, _name: &str, _len: usize, f: F) -> DecodeResult<T> + where + F: FnOnce(&mut Decoder) -> DecodeResult<T>, + { + let value = f(self)?; + self.pop(); + Ok(value) + } + + fn read_struct_field<T, F>(&mut self, name: &str, _idx: usize, f: F) -> DecodeResult<T> + where + F: FnOnce(&mut Decoder) -> DecodeResult<T>, + { + let mut obj = expect!(self.pop(), Object)?; + + let value = match obj.remove(&name.to_string()) { + None => { + // Add a Null and try to parse it as an Option<_> + // to get None as a default value. + self.stack.push(Json::Null); + match f(self) { + Ok(x) => x, + Err(_) => return Err(MissingFieldError(name.to_string())), + } + } + Some(json) => { + self.stack.push(json); + f(self)? + } + }; + self.stack.push(Json::Object(obj)); + Ok(value) + } + + fn read_tuple<T, F>(&mut self, tuple_len: usize, f: F) -> DecodeResult<T> + where + F: FnOnce(&mut Decoder) -> DecodeResult<T>, + { + self.read_seq(move |d, len| { + if len == tuple_len { + f(d) + } else { + Err(ExpectedError(format!("Tuple{}", tuple_len), format!("Tuple{}", len))) + } + }) + } + + fn read_tuple_arg<T, F>(&mut self, idx: usize, f: F) -> DecodeResult<T> + where + F: FnOnce(&mut Decoder) -> DecodeResult<T>, + { + self.read_seq_elt(idx, f) + } + + fn read_tuple_struct<T, F>(&mut self, _name: &str, len: usize, f: F) -> DecodeResult<T> + where + F: FnOnce(&mut Decoder) -> DecodeResult<T>, + { + self.read_tuple(len, f) + } + + fn read_tuple_struct_arg<T, F>(&mut self, idx: usize, f: F) -> DecodeResult<T> + where + F: FnOnce(&mut Decoder) -> DecodeResult<T>, + { + self.read_tuple_arg(idx, f) + } + + fn read_option<T, F>(&mut self, mut f: F) -> DecodeResult<T> + where + F: FnMut(&mut Decoder, bool) -> DecodeResult<T>, + { + match self.pop() { + Json::Null => f(self, false), + value => { + self.stack.push(value); + f(self, true) + } + } + } + + fn read_seq<T, F>(&mut self, f: F) -> DecodeResult<T> + where + F: FnOnce(&mut Decoder, usize) -> DecodeResult<T>, + { + let array = expect!(self.pop(), Array)?; + let len = array.len(); + self.stack.extend(array.into_iter().rev()); + f(self, len) + } + + fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> + where + F: FnOnce(&mut Decoder) -> DecodeResult<T>, + { + f(self) + } + + fn read_map<T, F>(&mut self, f: F) -> DecodeResult<T> + where + F: FnOnce(&mut Decoder, usize) -> DecodeResult<T>, + { + let obj = expect!(self.pop(), Object)?; + let len = obj.len(); + for (key, value) in obj { + self.stack.push(value); + self.stack.push(Json::String(key)); + } + f(self, len) + } + + fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> + where + F: FnOnce(&mut Decoder) -> DecodeResult<T>, + { + f(self) + } + + fn read_map_elt_val<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> + where + F: FnOnce(&mut Decoder) -> DecodeResult<T>, + { + f(self) + } + + fn error(&mut self, err: &str) -> DecoderError { + ApplicationError(err.to_string()) + } +} + +/// A trait for converting values to JSON +pub trait ToJson { + /// Converts the value of `self` to an instance of JSON + fn to_json(&self) -> Json; +} + +macro_rules! to_json_impl_i64 { + ($($t:ty), +) => ( + $(impl ToJson for $t { + fn to_json(&self) -> Json { + Json::I64(*self as i64) + } + })+ + ) +} + +to_json_impl_i64! { isize, i8, i16, i32, i64 } + +macro_rules! to_json_impl_u64 { + ($($t:ty), +) => ( + $(impl ToJson for $t { + fn to_json(&self) -> Json { + Json::U64(*self as u64) + } + })+ + ) +} + +to_json_impl_u64! { usize, u8, u16, u32, u64 } + +impl ToJson for Json { + fn to_json(&self) -> Json { + self.clone() + } +} + +impl ToJson for f32 { + fn to_json(&self) -> Json { + f64::from(*self).to_json() + } +} + +impl ToJson for f64 { + fn to_json(&self) -> Json { + match self.classify() { + Fp::Nan | Fp::Infinite => Json::Null, + _ => Json::F64(*self), + } + } +} + +impl ToJson for () { + fn to_json(&self) -> Json { + Json::Null + } +} + +impl ToJson for bool { + fn to_json(&self) -> Json { + Json::Boolean(*self) + } +} + +impl ToJson for str { + fn to_json(&self) -> Json { + Json::String(self.to_string()) + } +} + +impl ToJson for string::String { + fn to_json(&self) -> Json { + Json::String((*self).clone()) + } +} + +macro_rules! tuple_impl { + // use variables to indicate the arity of the tuple + ($($tyvar:ident),* ) => { + // the trailing commas are for the 1 tuple + impl< + $( $tyvar : ToJson ),* + > ToJson for ( $( $tyvar ),* , ) { + + #[inline] + #[allow(non_snake_case)] + fn to_json(&self) -> Json { + match *self { + ($(ref $tyvar),*,) => Json::Array(vec![$($tyvar.to_json()),*]) + } + } + } + } +} + +tuple_impl! {A} +tuple_impl! {A, B} +tuple_impl! {A, B, C} +tuple_impl! {A, B, C, D} +tuple_impl! {A, B, C, D, E} +tuple_impl! {A, B, C, D, E, F} +tuple_impl! {A, B, C, D, E, F, G} +tuple_impl! {A, B, C, D, E, F, G, H} +tuple_impl! {A, B, C, D, E, F, G, H, I} +tuple_impl! {A, B, C, D, E, F, G, H, I, J} +tuple_impl! {A, B, C, D, E, F, G, H, I, J, K} +tuple_impl! {A, B, C, D, E, F, G, H, I, J, K, L} + +impl<A: ToJson> ToJson for [A] { + fn to_json(&self) -> Json { + Json::Array(self.iter().map(|elt| elt.to_json()).collect()) + } +} + +impl<A: ToJson> ToJson for Vec<A> { + fn to_json(&self) -> Json { + Json::Array(self.iter().map(|elt| elt.to_json()).collect()) + } +} + +impl<T: ToString, A: ToJson> ToJson for BTreeMap<T, A> { + fn to_json(&self) -> Json { + let mut d = BTreeMap::new(); + for (key, value) in self { + d.insert(key.to_string(), value.to_json()); + } + Json::Object(d) + } +} + +impl<A: ToJson> ToJson for HashMap<string::String, A> { + fn to_json(&self) -> Json { + let mut d = BTreeMap::new(); + for (key, value) in self { + d.insert((*key).clone(), value.to_json()); + } + Json::Object(d) + } +} + +impl<A: ToJson> ToJson for Option<A> { + fn to_json(&self) -> Json { + match *self { + None => Json::Null, + Some(ref value) => value.to_json(), + } + } +} + +struct FormatShim<'a, 'b> { + inner: &'a mut fmt::Formatter<'b>, +} + +impl<'a, 'b> fmt::Write for FormatShim<'a, 'b> { + fn write_str(&mut self, s: &str) -> fmt::Result { + match self.inner.write_str(s) { + Ok(_) => Ok(()), + Err(_) => Err(fmt::Error), + } + } +} + +impl fmt::Display for Json { + /// Encodes a json value into a string + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let mut shim = FormatShim { inner: f }; + let mut encoder = Encoder::new(&mut shim); + match self.encode(&mut encoder) { + Ok(_) => Ok(()), + Err(_) => Err(fmt::Error), + } + } +} + +impl<'a> fmt::Display for PrettyJson<'a> { + /// Encodes a json value into a string + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let mut shim = FormatShim { inner: f }; + let mut encoder = PrettyEncoder::new(&mut shim); + match self.inner.encode(&mut encoder) { + Ok(_) => Ok(()), + Err(_) => Err(fmt::Error), + } + } +} + +impl<'a, T: for<'r> Encodable<Encoder<'r>>> fmt::Display for AsJson<'a, T> { + /// Encodes a json value into a string + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let mut shim = FormatShim { inner: f }; + let mut encoder = Encoder::new(&mut shim); + match self.inner.encode(&mut encoder) { + Ok(_) => Ok(()), + Err(_) => Err(fmt::Error), + } + } +} + +impl<'a, T> AsPrettyJson<'a, T> { + /// Sets the indentation level for the emitted JSON + pub fn indent(mut self, indent: usize) -> AsPrettyJson<'a, T> { + self.indent = Some(indent); + self + } +} + +impl<'a, T: for<'x> Encodable<PrettyEncoder<'x>>> fmt::Display for AsPrettyJson<'a, T> { + /// Encodes a json value into a string + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let mut shim = FormatShim { inner: f }; + let mut encoder = PrettyEncoder::new(&mut shim); + if let Some(n) = self.indent { + encoder.set_indent(n); + } + match self.inner.encode(&mut encoder) { + Ok(_) => Ok(()), + Err(_) => Err(fmt::Error), + } + } +} + +impl FromStr for Json { + type Err = BuilderError; + fn from_str(s: &str) -> Result<Json, BuilderError> { + from_str(s) + } +} + +#[cfg(test)] +mod tests; diff --git a/compiler/rustc_serialize/src/json/tests.rs b/compiler/rustc_serialize/src/json/tests.rs new file mode 100644 index 00000000000..01678fbf0b7 --- /dev/null +++ b/compiler/rustc_serialize/src/json/tests.rs @@ -0,0 +1,147 @@ +// Benchmarks and tests that require private items + +extern crate test; +use super::{from_str, Parser, Stack, StackElement}; +use std::string; +use test::Bencher; + +#[test] +fn test_stack() { + let mut stack = Stack::new(); + + assert!(stack.is_empty()); + assert!(stack.is_empty()); + assert!(!stack.last_is_index()); + + stack.push_index(0); + stack.bump_index(); + + assert!(stack.len() == 1); + assert!(stack.is_equal_to(&[StackElement::Index(1)])); + assert!(stack.starts_with(&[StackElement::Index(1)])); + assert!(stack.ends_with(&[StackElement::Index(1)])); + assert!(stack.last_is_index()); + assert!(stack.get(0) == StackElement::Index(1)); + + stack.push_key("foo".to_string()); + + assert!(stack.len() == 2); + assert!(stack.is_equal_to(&[StackElement::Index(1), StackElement::Key("foo")])); + assert!(stack.starts_with(&[StackElement::Index(1), StackElement::Key("foo")])); + assert!(stack.starts_with(&[StackElement::Index(1)])); + assert!(stack.ends_with(&[StackElement::Index(1), StackElement::Key("foo")])); + assert!(stack.ends_with(&[StackElement::Key("foo")])); + assert!(!stack.last_is_index()); + assert!(stack.get(0) == StackElement::Index(1)); + assert!(stack.get(1) == StackElement::Key("foo")); + + stack.push_key("bar".to_string()); + + assert!(stack.len() == 3); + assert!(stack.is_equal_to(&[ + StackElement::Index(1), + StackElement::Key("foo"), + StackElement::Key("bar") + ])); + assert!(stack.starts_with(&[StackElement::Index(1)])); + assert!(stack.starts_with(&[StackElement::Index(1), StackElement::Key("foo")])); + assert!(stack.starts_with(&[ + StackElement::Index(1), + StackElement::Key("foo"), + StackElement::Key("bar") + ])); + assert!(stack.ends_with(&[StackElement::Key("bar")])); + assert!(stack.ends_with(&[StackElement::Key("foo"), StackElement::Key("bar")])); + assert!(stack.ends_with(&[ + StackElement::Index(1), + StackElement::Key("foo"), + StackElement::Key("bar") + ])); + assert!(!stack.last_is_index()); + assert!(stack.get(0) == StackElement::Index(1)); + assert!(stack.get(1) == StackElement::Key("foo")); + assert!(stack.get(2) == StackElement::Key("bar")); + + stack.pop(); + + assert!(stack.len() == 2); + assert!(stack.is_equal_to(&[StackElement::Index(1), StackElement::Key("foo")])); + assert!(stack.starts_with(&[StackElement::Index(1), StackElement::Key("foo")])); + assert!(stack.starts_with(&[StackElement::Index(1)])); + assert!(stack.ends_with(&[StackElement::Index(1), StackElement::Key("foo")])); + assert!(stack.ends_with(&[StackElement::Key("foo")])); + assert!(!stack.last_is_index()); + assert!(stack.get(0) == StackElement::Index(1)); + assert!(stack.get(1) == StackElement::Key("foo")); +} + +#[bench] +fn bench_streaming_small(b: &mut Bencher) { + b.iter(|| { + let mut parser = Parser::new( + r#"{ + "a": 1.0, + "b": [ + true, + "foo\nbar", + { "c": {"d": null} } + ] + }"# + .chars(), + ); + loop { + match parser.next() { + None => return, + _ => {} + } + } + }); +} +#[bench] +fn bench_small(b: &mut Bencher) { + b.iter(|| { + let _ = from_str( + r#"{ + "a": 1.0, + "b": [ + true, + "foo\nbar", + { "c": {"d": null} } + ] + }"#, + ); + }); +} + +fn big_json() -> string::String { + let mut src = "[\n".to_string(); + for _ in 0..500 { + src.push_str( + r#"{ "a": true, "b": null, "c":3.1415, "d": "Hello world", "e": \ + [1,2,3]},"#, + ); + } + src.push_str("{}]"); + return src; +} + +#[bench] +fn bench_streaming_large(b: &mut Bencher) { + let src = big_json(); + b.iter(|| { + let mut parser = Parser::new(src.chars()); + loop { + match parser.next() { + None => return, + _ => {} + } + } + }); +} +#[bench] +fn bench_large(b: &mut Bencher) { + let src = big_json(); + b.iter(|| { + let _ = from_str(&src); + }); +} diff --git a/compiler/rustc_serialize/src/leb128.rs b/compiler/rustc_serialize/src/leb128.rs new file mode 100644 index 00000000000..1fe6a309e96 --- /dev/null +++ b/compiler/rustc_serialize/src/leb128.rs @@ -0,0 +1,110 @@ +macro_rules! impl_write_unsigned_leb128 { + ($fn_name:ident, $int_ty:ident) => { + #[inline] + pub fn $fn_name(out: &mut Vec<u8>, mut value: $int_ty) { + loop { + if value < 0x80 { + out.push(value as u8); + break; + } else { + out.push(((value & 0x7f) | 0x80) as u8); + value >>= 7; + } + } + } + }; +} + +impl_write_unsigned_leb128!(write_u16_leb128, u16); +impl_write_unsigned_leb128!(write_u32_leb128, u32); +impl_write_unsigned_leb128!(write_u64_leb128, u64); +impl_write_unsigned_leb128!(write_u128_leb128, u128); +impl_write_unsigned_leb128!(write_usize_leb128, usize); + +macro_rules! impl_read_unsigned_leb128 { + ($fn_name:ident, $int_ty:ident) => { + #[inline] + pub fn $fn_name(slice: &[u8]) -> ($int_ty, usize) { + let mut result = 0; + let mut shift = 0; + let mut position = 0; + loop { + let byte = slice[position]; + position += 1; + if (byte & 0x80) == 0 { + result |= (byte as $int_ty) << shift; + return (result, position); + } else { + result |= ((byte & 0x7F) as $int_ty) << shift; + } + shift += 7; + } + } + }; +} + +impl_read_unsigned_leb128!(read_u16_leb128, u16); +impl_read_unsigned_leb128!(read_u32_leb128, u32); +impl_read_unsigned_leb128!(read_u64_leb128, u64); +impl_read_unsigned_leb128!(read_u128_leb128, u128); +impl_read_unsigned_leb128!(read_usize_leb128, usize); + +#[inline] +/// encodes an integer using signed leb128 encoding and stores +/// the result using a callback function. +/// +/// The callback `write` is called once for each position +/// that is to be written to with the byte to be encoded +/// at that position. +pub fn write_signed_leb128_to<W>(mut value: i128, mut write: W) +where + W: FnMut(u8), +{ + loop { + let mut byte = (value as u8) & 0x7f; + value >>= 7; + let more = + !(((value == 0) && ((byte & 0x40) == 0)) || ((value == -1) && ((byte & 0x40) != 0))); + + if more { + byte |= 0x80; // Mark this byte to show that more bytes will follow. + } + + write(byte); + + if !more { + break; + } + } +} + +#[inline] +pub fn write_signed_leb128(out: &mut Vec<u8>, value: i128) { + write_signed_leb128_to(value, |v| out.push(v)) +} + +#[inline] +pub fn read_signed_leb128(data: &[u8], start_position: usize) -> (i128, usize) { + let mut result = 0; + let mut shift = 0; + let mut position = start_position; + let mut byte; + + loop { + byte = data[position]; + position += 1; + result |= i128::from(byte & 0x7F) << shift; + shift += 7; + + if (byte & 0x80) == 0 { + break; + } + } + + if (shift < 64) && ((byte & 0x40) != 0) { + // sign extend + result |= -(1 << shift); + } + + (result, position - start_position) +} diff --git a/compiler/rustc_serialize/src/lib.rs b/compiler/rustc_serialize/src/lib.rs new file mode 100644 index 00000000000..265b3b95e95 --- /dev/null +++ b/compiler/rustc_serialize/src/lib.rs @@ -0,0 +1,27 @@ +//! Support code for encoding and decoding types. + +/* +Core encoding and decoding interfaces. +*/ + +#![doc( + html_root_url = "https://doc.rust-lang.org/nightly/", + html_playground_url = "https://play.rust-lang.org/", + test(attr(allow(unused_variables), deny(warnings))) +)] +#![feature(box_syntax)] +#![feature(never_type)] +#![feature(nll)] +#![feature(associated_type_bounds)] +#![cfg_attr(test, feature(test))] +#![allow(rustc::internal)] + +pub use self::serialize::{Decodable, Decoder, Encodable, Encoder}; + +mod collection_impls; +mod serialize; + +pub mod json; + +pub mod leb128; +pub mod opaque; diff --git a/compiler/rustc_serialize/src/opaque.rs b/compiler/rustc_serialize/src/opaque.rs new file mode 100644 index 00000000000..fa4423e261d --- /dev/null +++ b/compiler/rustc_serialize/src/opaque.rs @@ -0,0 +1,318 @@ +use crate::leb128::{self, read_signed_leb128, write_signed_leb128}; +use crate::serialize; +use std::borrow::Cow; + +// ----------------------------------------------------------------------------- +// Encoder +// ----------------------------------------------------------------------------- + +pub type EncodeResult = Result<(), !>; + +pub struct Encoder { + pub data: Vec<u8>, +} + +impl Encoder { + pub fn new(data: Vec<u8>) -> Encoder { + Encoder { data } + } + + pub fn into_inner(self) -> Vec<u8> { + self.data + } + + #[inline] + pub fn emit_raw_bytes(&mut self, s: &[u8]) { + self.data.extend_from_slice(s); + } +} + +macro_rules! write_uleb128 { + ($enc:expr, $value:expr, $fun:ident) => {{ + leb128::$fun(&mut $enc.data, $value); + Ok(()) + }}; +} + +macro_rules! write_sleb128 { + ($enc:expr, $value:expr) => {{ + write_signed_leb128(&mut $enc.data, $value as i128); + Ok(()) + }}; +} + +impl serialize::Encoder for Encoder { + type Error = !; + + #[inline] + fn emit_unit(&mut self) -> EncodeResult { + Ok(()) + } + + #[inline] + fn emit_usize(&mut self, v: usize) -> EncodeResult { + write_uleb128!(self, v, write_usize_leb128) + } + + #[inline] + fn emit_u128(&mut self, v: u128) -> EncodeResult { + write_uleb128!(self, v, write_u128_leb128) + } + + #[inline] + fn emit_u64(&mut self, v: u64) -> EncodeResult { + write_uleb128!(self, v, write_u64_leb128) + } + + #[inline] + fn emit_u32(&mut self, v: u32) -> EncodeResult { + write_uleb128!(self, v, write_u32_leb128) + } + + #[inline] + fn emit_u16(&mut self, v: u16) -> EncodeResult { + write_uleb128!(self, v, write_u16_leb128) + } + + #[inline] + fn emit_u8(&mut self, v: u8) -> EncodeResult { + self.data.push(v); + Ok(()) + } + + #[inline] + fn emit_isize(&mut self, v: isize) -> EncodeResult { + write_sleb128!(self, v) + } + + #[inline] + fn emit_i128(&mut self, v: i128) -> EncodeResult { + write_sleb128!(self, v) + } + + #[inline] + fn emit_i64(&mut self, v: i64) -> EncodeResult { + write_sleb128!(self, v) + } + + #[inline] + fn emit_i32(&mut self, v: i32) -> EncodeResult { + write_sleb128!(self, v) + } + + #[inline] + fn emit_i16(&mut self, v: i16) -> EncodeResult { + write_sleb128!(self, v) + } + + #[inline] + fn emit_i8(&mut self, v: i8) -> EncodeResult { + let as_u8: u8 = unsafe { ::std::mem::transmute(v) }; + self.emit_u8(as_u8) + } + + #[inline] + fn emit_bool(&mut self, v: bool) -> EncodeResult { + self.emit_u8(if v { 1 } else { 0 }) + } + + #[inline] + fn emit_f64(&mut self, v: f64) -> EncodeResult { + let as_u64: u64 = v.to_bits(); + self.emit_u64(as_u64) + } + + #[inline] + fn emit_f32(&mut self, v: f32) -> EncodeResult { + let as_u32: u32 = v.to_bits(); + self.emit_u32(as_u32) + } + + #[inline] + fn emit_char(&mut self, v: char) -> EncodeResult { + self.emit_u32(v as u32) + } + + #[inline] + fn emit_str(&mut self, v: &str) -> EncodeResult { + self.emit_usize(v.len())?; + self.emit_raw_bytes(v.as_bytes()); + Ok(()) + } +} + +impl Encoder { + #[inline] + pub fn position(&self) -> usize { + self.data.len() + } +} + +// ----------------------------------------------------------------------------- +// Decoder +// ----------------------------------------------------------------------------- + +pub struct Decoder<'a> { + pub data: &'a [u8], + position: usize, +} + +impl<'a> Decoder<'a> { + #[inline] + pub fn new(data: &'a [u8], position: usize) -> Decoder<'a> { + Decoder { data, position } + } + + #[inline] + pub fn position(&self) -> usize { + self.position + } + + #[inline] + pub fn set_position(&mut self, pos: usize) { + self.position = pos + } + + #[inline] + pub fn advance(&mut self, bytes: usize) { + self.position += bytes; + } + + #[inline] + pub fn read_raw_bytes(&mut self, s: &mut [u8]) -> Result<(), String> { + let start = self.position; + let end = start + s.len(); + + s.copy_from_slice(&self.data[start..end]); + + self.position = end; + + Ok(()) + } +} + +macro_rules! read_uleb128 { + ($dec:expr, $fun:ident) => {{ + let (value, bytes_read) = leb128::$fun(&$dec.data[$dec.position..]); + $dec.position += bytes_read; + Ok(value) + }}; +} + +macro_rules! read_sleb128 { + ($dec:expr, $t:ty) => {{ + let (value, bytes_read) = read_signed_leb128($dec.data, $dec.position); + $dec.position += bytes_read; + Ok(value as $t) + }}; +} + +impl<'a> serialize::Decoder for Decoder<'a> { + type Error = String; + + #[inline] + fn read_nil(&mut self) -> Result<(), Self::Error> { + Ok(()) + } + + #[inline] + fn read_u128(&mut self) -> Result<u128, Self::Error> { + read_uleb128!(self, read_u128_leb128) + } + + #[inline] + fn read_u64(&mut self) -> Result<u64, Self::Error> { + read_uleb128!(self, read_u64_leb128) + } + + #[inline] + fn read_u32(&mut self) -> Result<u32, Self::Error> { + read_uleb128!(self, read_u32_leb128) + } + + #[inline] + fn read_u16(&mut self) -> Result<u16, Self::Error> { + read_uleb128!(self, read_u16_leb128) + } + + #[inline] + fn read_u8(&mut self) -> Result<u8, Self::Error> { + let value = self.data[self.position]; + self.position += 1; + Ok(value) + } + + #[inline] + fn read_usize(&mut self) -> Result<usize, Self::Error> { + read_uleb128!(self, read_usize_leb128) + } + + #[inline] + fn read_i128(&mut self) -> Result<i128, Self::Error> { + read_sleb128!(self, i128) + } + + #[inline] + fn read_i64(&mut self) -> Result<i64, Self::Error> { + read_sleb128!(self, i64) + } + + #[inline] + fn read_i32(&mut self) -> Result<i32, Self::Error> { + read_sleb128!(self, i32) + } + + #[inline] + fn read_i16(&mut self) -> Result<i16, Self::Error> { + read_sleb128!(self, i16) + } + + #[inline] + fn read_i8(&mut self) -> Result<i8, Self::Error> { + let as_u8 = self.data[self.position]; + self.position += 1; + unsafe { Ok(::std::mem::transmute(as_u8)) } + } + + #[inline] + fn read_isize(&mut self) -> Result<isize, Self::Error> { + read_sleb128!(self, isize) + } + + #[inline] + fn read_bool(&mut self) -> Result<bool, Self::Error> { + let value = self.read_u8()?; + Ok(value != 0) + } + + #[inline] + fn read_f64(&mut self) -> Result<f64, Self::Error> { + let bits = self.read_u64()?; + Ok(f64::from_bits(bits)) + } + + #[inline] + fn read_f32(&mut self) -> Result<f32, Self::Error> { + let bits = self.read_u32()?; + Ok(f32::from_bits(bits)) + } + + #[inline] + fn read_char(&mut self) -> Result<char, Self::Error> { + let bits = self.read_u32()?; + Ok(::std::char::from_u32(bits).unwrap()) + } + + #[inline] + fn read_str(&mut self) -> Result<Cow<'_, str>, Self::Error> { + let len = self.read_usize()?; + let s = ::std::str::from_utf8(&self.data[self.position..self.position + len]).unwrap(); + self.position += len; + Ok(Cow::Borrowed(s)) + } + + #[inline] + fn error(&mut self, err: &str) -> Self::Error { + err.to_string() + } +} diff --git a/compiler/rustc_serialize/src/serialize.rs b/compiler/rustc_serialize/src/serialize.rs new file mode 100644 index 00000000000..c0e23b89a60 --- /dev/null +++ b/compiler/rustc_serialize/src/serialize.rs @@ -0,0 +1,782 @@ +//! Support code for encoding and decoding types. + +/* +Core encoding and decoding interfaces. +*/ + +use std::borrow::Cow; +use std::cell::{Cell, RefCell}; +use std::marker::PhantomData; +use std::path; +use std::rc::Rc; +use std::sync::Arc; + +pub trait Encoder { + type Error; + + // Primitive types: + fn emit_unit(&mut self) -> Result<(), Self::Error>; + fn emit_usize(&mut self, v: usize) -> Result<(), Self::Error>; + fn emit_u128(&mut self, v: u128) -> Result<(), Self::Error>; + fn emit_u64(&mut self, v: u64) -> Result<(), Self::Error>; + fn emit_u32(&mut self, v: u32) -> Result<(), Self::Error>; + fn emit_u16(&mut self, v: u16) -> Result<(), Self::Error>; + fn emit_u8(&mut self, v: u8) -> Result<(), Self::Error>; + fn emit_isize(&mut self, v: isize) -> Result<(), Self::Error>; + fn emit_i128(&mut self, v: i128) -> Result<(), Self::Error>; + fn emit_i64(&mut self, v: i64) -> Result<(), Self::Error>; + fn emit_i32(&mut self, v: i32) -> Result<(), Self::Error>; + fn emit_i16(&mut self, v: i16) -> Result<(), Self::Error>; + fn emit_i8(&mut self, v: i8) -> Result<(), Self::Error>; + fn emit_bool(&mut self, v: bool) -> Result<(), Self::Error>; + fn emit_f64(&mut self, v: f64) -> Result<(), Self::Error>; + fn emit_f32(&mut self, v: f32) -> Result<(), Self::Error>; + fn emit_char(&mut self, v: char) -> Result<(), Self::Error>; + fn emit_str(&mut self, v: &str) -> Result<(), Self::Error>; + + // Compound types: + #[inline] + fn emit_enum<F>(&mut self, _name: &str, f: F) -> Result<(), Self::Error> + where + F: FnOnce(&mut Self) -> Result<(), Self::Error>, + { + f(self) + } + + fn emit_enum_variant<F>( + &mut self, + _v_name: &str, + v_id: usize, + _len: usize, + f: F, + ) -> Result<(), Self::Error> + where + F: FnOnce(&mut Self) -> Result<(), Self::Error>, + { + self.emit_usize(v_id)?; + f(self) + } + + #[inline] + fn emit_enum_variant_arg<F>(&mut self, _a_idx: usize, f: F) -> Result<(), Self::Error> + where + F: FnOnce(&mut Self) -> Result<(), Self::Error>, + { + f(self) + } + + fn emit_enum_struct_variant<F>( + &mut self, + v_name: &str, + v_id: usize, + len: usize, + f: F, + ) -> Result<(), Self::Error> + where + F: FnOnce(&mut Self) -> Result<(), Self::Error>, + { + self.emit_enum_variant(v_name, v_id, len, f) + } + + fn emit_enum_struct_variant_field<F>( + &mut self, + _f_name: &str, + f_idx: usize, + f: F, + ) -> Result<(), Self::Error> + where + F: FnOnce(&mut Self) -> Result<(), Self::Error>, + { + self.emit_enum_variant_arg(f_idx, f) + } + + #[inline] + fn emit_struct<F>(&mut self, _name: &str, _len: usize, f: F) -> Result<(), Self::Error> + where + F: FnOnce(&mut Self) -> Result<(), Self::Error>, + { + f(self) + } + + #[inline] + fn emit_struct_field<F>( + &mut self, + _f_name: &str, + _f_idx: usize, + f: F, + ) -> Result<(), Self::Error> + where + F: FnOnce(&mut Self) -> Result<(), Self::Error>, + { + f(self) + } + + #[inline] + fn emit_tuple<F>(&mut self, _len: usize, f: F) -> Result<(), Self::Error> + where + F: FnOnce(&mut Self) -> Result<(), Self::Error>, + { + f(self) + } + + #[inline] + fn emit_tuple_arg<F>(&mut self, _idx: usize, f: F) -> Result<(), Self::Error> + where + F: FnOnce(&mut Self) -> Result<(), Self::Error>, + { + f(self) + } + + fn emit_tuple_struct<F>(&mut self, _name: &str, len: usize, f: F) -> Result<(), Self::Error> + where + F: FnOnce(&mut Self) -> Result<(), Self::Error>, + { + self.emit_tuple(len, f) + } + + fn emit_tuple_struct_arg<F>(&mut self, f_idx: usize, f: F) -> Result<(), Self::Error> + where + F: FnOnce(&mut Self) -> Result<(), Self::Error>, + { + self.emit_tuple_arg(f_idx, f) + } + + // Specialized types: + fn emit_option<F>(&mut self, f: F) -> Result<(), Self::Error> + where + F: FnOnce(&mut Self) -> Result<(), Self::Error>, + { + self.emit_enum("Option", f) + } + + #[inline] + fn emit_option_none(&mut self) -> Result<(), Self::Error> { + self.emit_enum_variant("None", 0, 0, |_| Ok(())) + } + + fn emit_option_some<F>(&mut self, f: F) -> Result<(), Self::Error> + where + F: FnOnce(&mut Self) -> Result<(), Self::Error>, + { + self.emit_enum_variant("Some", 1, 1, f) + } + + fn emit_seq<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error> + where + F: FnOnce(&mut Self) -> Result<(), Self::Error>, + { + self.emit_usize(len)?; + f(self) + } + + #[inline] + fn emit_seq_elt<F>(&mut self, _idx: usize, f: F) -> Result<(), Self::Error> + where + F: FnOnce(&mut Self) -> Result<(), Self::Error>, + { + f(self) + } + + fn emit_map<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error> + where + F: FnOnce(&mut Self) -> Result<(), Self::Error>, + { + self.emit_usize(len)?; + f(self) + } + + #[inline] + fn emit_map_elt_key<F>(&mut self, _idx: usize, f: F) -> Result<(), Self::Error> + where + F: FnOnce(&mut Self) -> Result<(), Self::Error>, + { + f(self) + } + + #[inline] + fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F) -> Result<(), Self::Error> + where + F: FnOnce(&mut Self) -> Result<(), Self::Error>, + { + f(self) + } +} + +pub trait Decoder { + type Error; + + // Primitive types: + fn read_nil(&mut self) -> Result<(), Self::Error>; + fn read_usize(&mut self) -> Result<usize, Self::Error>; + fn read_u128(&mut self) -> Result<u128, Self::Error>; + fn read_u64(&mut self) -> Result<u64, Self::Error>; + fn read_u32(&mut self) -> Result<u32, Self::Error>; + fn read_u16(&mut self) -> Result<u16, Self::Error>; + fn read_u8(&mut self) -> Result<u8, Self::Error>; + fn read_isize(&mut self) -> Result<isize, Self::Error>; + fn read_i128(&mut self) -> Result<i128, Self::Error>; + fn read_i64(&mut self) -> Result<i64, Self::Error>; + fn read_i32(&mut self) -> Result<i32, Self::Error>; + fn read_i16(&mut self) -> Result<i16, Self::Error>; + fn read_i8(&mut self) -> Result<i8, Self::Error>; + fn read_bool(&mut self) -> Result<bool, Self::Error>; + fn read_f64(&mut self) -> Result<f64, Self::Error>; + fn read_f32(&mut self) -> Result<f32, Self::Error>; + fn read_char(&mut self) -> Result<char, Self::Error>; + fn read_str(&mut self) -> Result<Cow<'_, str>, Self::Error>; + + // Compound types: + #[inline] + fn read_enum<T, F>(&mut self, _name: &str, f: F) -> Result<T, Self::Error> + where + F: FnOnce(&mut Self) -> Result<T, Self::Error>, + { + f(self) + } + + #[inline] + fn read_enum_variant<T, F>(&mut self, _names: &[&str], mut f: F) -> Result<T, Self::Error> + where + F: FnMut(&mut Self, usize) -> Result<T, Self::Error>, + { + let disr = self.read_usize()?; + f(self, disr) + } + + #[inline] + fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, f: F) -> Result<T, Self::Error> + where + F: FnOnce(&mut Self) -> Result<T, Self::Error>, + { + f(self) + } + + fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> Result<T, Self::Error> + where + F: FnMut(&mut Self, usize) -> Result<T, Self::Error>, + { + self.read_enum_variant(names, f) + } + + fn read_enum_struct_variant_field<T, F>( + &mut self, + _f_name: &str, + f_idx: usize, + f: F, + ) -> Result<T, Self::Error> + where + F: FnOnce(&mut Self) -> Result<T, Self::Error>, + { + self.read_enum_variant_arg(f_idx, f) + } + + #[inline] + fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, f: F) -> Result<T, Self::Error> + where + F: FnOnce(&mut Self) -> Result<T, Self::Error>, + { + f(self) + } + + #[inline] + fn read_struct_field<T, F>( + &mut self, + _f_name: &str, + _f_idx: usize, + f: F, + ) -> Result<T, Self::Error> + where + F: FnOnce(&mut Self) -> Result<T, Self::Error>, + { + f(self) + } + + #[inline] + fn read_tuple<T, F>(&mut self, _len: usize, f: F) -> Result<T, Self::Error> + where + F: FnOnce(&mut Self) -> Result<T, Self::Error>, + { + f(self) + } + + #[inline] + fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, f: F) -> Result<T, Self::Error> + where + F: FnOnce(&mut Self) -> Result<T, Self::Error>, + { + f(self) + } + + fn read_tuple_struct<T, F>(&mut self, _s_name: &str, len: usize, f: F) -> Result<T, Self::Error> + where + F: FnOnce(&mut Self) -> Result<T, Self::Error>, + { + self.read_tuple(len, f) + } + + fn read_tuple_struct_arg<T, F>(&mut self, a_idx: usize, f: F) -> Result<T, Self::Error> + where + F: FnOnce(&mut Self) -> Result<T, Self::Error>, + { + self.read_tuple_arg(a_idx, f) + } + + // Specialized types: + fn read_option<T, F>(&mut self, mut f: F) -> Result<T, Self::Error> + where + F: FnMut(&mut Self, bool) -> Result<T, Self::Error>, + { + self.read_enum("Option", move |this| { + this.read_enum_variant(&["None", "Some"], move |this, idx| match idx { + 0 => f(this, false), + 1 => f(this, true), + _ => Err(this.error("read_option: expected 0 for None or 1 for Some")), + }) + }) + } + + fn read_seq<T, F>(&mut self, f: F) -> Result<T, Self::Error> + where + F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>, + { + let len = self.read_usize()?; + f(self, len) + } + + #[inline] + fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Self::Error> + where + F: FnOnce(&mut Self) -> Result<T, Self::Error>, + { + f(self) + } + + fn read_map<T, F>(&mut self, f: F) -> Result<T, Self::Error> + where + F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>, + { + let len = self.read_usize()?; + f(self, len) + } + + #[inline] + fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Self::Error> + where + F: FnOnce(&mut Self) -> Result<T, Self::Error>, + { + f(self) + } + + #[inline] + fn read_map_elt_val<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Self::Error> + where + F: FnOnce(&mut Self) -> Result<T, Self::Error>, + { + f(self) + } + + // Failure + fn error(&mut self, err: &str) -> Self::Error; +} + +/// Trait for types that can be serialized +/// +/// This can be implemented using the `Encodable`, `TyEncodable` and +/// `MetadataEncodable` macros. +/// +/// * `Encodable` should be used in crates that don't depend on +/// `rustc_middle`. +/// * `MetadataEncodable` is used in `rustc_metadata` for types that contain +/// `rustc_metadata::rmeta::Lazy`. +/// * `TyEncodable` should be used for types that are only serialized in crate +/// metadata or the incremental cache. This is most types in `rustc_middle`. +pub trait Encodable<S: Encoder> { + fn encode(&self, s: &mut S) -> Result<(), S::Error>; +} + +/// Trait for types that can be deserialized +/// +/// This can be implemented using the `Decodable`, `TyDecodable` and +/// `MetadataDecodable` macros. +/// +/// * `Decodable` should be used in crates that don't depend on +/// `rustc_middle`. +/// * `MetadataDecodable` is used in `rustc_metadata` for types that contain +/// `rustc_metadata::rmeta::Lazy`. +/// * `TyDecodable` should be used for types that are only serialized in crate +/// metadata or the incremental cache. This is most types in `rustc_middle`. +pub trait Decodable<D: Decoder>: Sized { + fn decode(d: &mut D) -> Result<Self, D::Error>; +} + +macro_rules! direct_serialize_impls { + ($($ty:ident $emit_method:ident $read_method:ident),*) => { + $( + impl<S: Encoder> Encodable<S> for $ty { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.$emit_method(*self) + } + } + + impl<D: Decoder> Decodable<D> for $ty { + fn decode(d: &mut D) -> Result<$ty, D::Error> { + d.$read_method() + } + } + )* + } +} + +direct_serialize_impls! { + usize emit_usize read_usize, + u8 emit_u8 read_u8, + u16 emit_u16 read_u16, + u32 emit_u32 read_u32, + u64 emit_u64 read_u64, + u128 emit_u128 read_u128, + isize emit_isize read_isize, + i8 emit_i8 read_i8, + i16 emit_i16 read_i16, + i32 emit_i32 read_i32, + i64 emit_i64 read_i64, + i128 emit_i128 read_i128, + f32 emit_f32 read_f32, + f64 emit_f64 read_f64, + bool emit_bool read_bool, + char emit_char read_char +} + +impl<S: Encoder> Encodable<S> for ::std::num::NonZeroU32 { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.emit_u32(self.get()) + } +} + +impl<D: Decoder> Decodable<D> for ::std::num::NonZeroU32 { + fn decode(d: &mut D) -> Result<Self, D::Error> { + d.read_u32().map(|d| ::std::num::NonZeroU32::new(d).unwrap()) + } +} + +impl<S: Encoder> Encodable<S> for str { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.emit_str(self) + } +} + +impl<S: Encoder> Encodable<S> for &str { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.emit_str(self) + } +} + +impl<S: Encoder> Encodable<S> for String { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.emit_str(&self[..]) + } +} + +impl<D: Decoder> Decodable<D> for String { + fn decode(d: &mut D) -> Result<String, D::Error> { + Ok(d.read_str()?.into_owned()) + } +} + +impl<S: Encoder> Encodable<S> for () { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.emit_unit() + } +} + +impl<D: Decoder> Decodable<D> for () { + fn decode(d: &mut D) -> Result<(), D::Error> { + d.read_nil() + } +} + +impl<S: Encoder, T> Encodable<S> for PhantomData<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.emit_unit() + } +} + +impl<D: Decoder, T> Decodable<D> for PhantomData<T> { + fn decode(d: &mut D) -> Result<PhantomData<T>, D::Error> { + d.read_nil()?; + Ok(PhantomData) + } +} + +impl<D: Decoder, T: Decodable<D>> Decodable<D> for Box<[T]> { + fn decode(d: &mut D) -> Result<Box<[T]>, D::Error> { + let v: Vec<T> = Decodable::decode(d)?; + Ok(v.into_boxed_slice()) + } +} + +impl<S: Encoder, T: Encodable<S>> Encodable<S> for Rc<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + (**self).encode(s) + } +} + +impl<D: Decoder, T: Decodable<D>> Decodable<D> for Rc<T> { + fn decode(d: &mut D) -> Result<Rc<T>, D::Error> { + Ok(Rc::new(Decodable::decode(d)?)) + } +} + +impl<S: Encoder, T: Encodable<S>> Encodable<S> for [T] { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.emit_seq(self.len(), |s| { + for (i, e) in self.iter().enumerate() { + s.emit_seq_elt(i, |s| e.encode(s))? + } + Ok(()) + }) + } +} + +impl<S: Encoder, T: Encodable<S>> Encodable<S> for Vec<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.emit_seq(self.len(), |s| { + for (i, e) in self.iter().enumerate() { + s.emit_seq_elt(i, |s| e.encode(s))? + } + Ok(()) + }) + } +} + +impl<D: Decoder, T: Decodable<D>> Decodable<D> for Vec<T> { + fn decode(d: &mut D) -> Result<Vec<T>, D::Error> { + d.read_seq(|d, len| { + let mut v = Vec::with_capacity(len); + for i in 0..len { + v.push(d.read_seq_elt(i, |d| Decodable::decode(d))?); + } + Ok(v) + }) + } +} + +impl<S: Encoder> Encodable<S> for [u8; 20] { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.emit_seq(self.len(), |s| { + for (i, e) in self.iter().enumerate() { + s.emit_seq_elt(i, |s| e.encode(s))? + } + Ok(()) + }) + } +} + +impl<D: Decoder> Decodable<D> for [u8; 20] { + fn decode(d: &mut D) -> Result<[u8; 20], D::Error> { + d.read_seq(|d, len| { + assert!(len == 20); + let mut v = [0u8; 20]; + for i in 0..len { + v[i] = d.read_seq_elt(i, |d| Decodable::decode(d))?; + } + Ok(v) + }) + } +} + +impl<'a, S: Encoder, T: Encodable<S>> Encodable<S> for Cow<'a, [T]> +where + [T]: ToOwned<Owned = Vec<T>>, +{ + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.emit_seq(self.len(), |s| { + for (i, e) in self.iter().enumerate() { + s.emit_seq_elt(i, |s| e.encode(s))? + } + Ok(()) + }) + } +} + +impl<D: Decoder, T: Decodable<D> + ToOwned> Decodable<D> for Cow<'static, [T]> +where + [T]: ToOwned<Owned = Vec<T>>, +{ + fn decode(d: &mut D) -> Result<Cow<'static, [T]>, D::Error> { + d.read_seq(|d, len| { + let mut v = Vec::with_capacity(len); + for i in 0..len { + v.push(d.read_seq_elt(i, |d| Decodable::decode(d))?); + } + Ok(Cow::Owned(v)) + }) + } +} + +impl<S: Encoder, T: Encodable<S>> Encodable<S> for Option<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.emit_option(|s| match *self { + None => s.emit_option_none(), + Some(ref v) => s.emit_option_some(|s| v.encode(s)), + }) + } +} + +impl<D: Decoder, T: Decodable<D>> Decodable<D> for Option<T> { + fn decode(d: &mut D) -> Result<Option<T>, D::Error> { + d.read_option(|d, b| if b { Ok(Some(Decodable::decode(d)?)) } else { Ok(None) }) + } +} + +impl<S: Encoder, T1: Encodable<S>, T2: Encodable<S>> Encodable<S> for Result<T1, T2> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.emit_enum("Result", |s| match *self { + Ok(ref v) => { + s.emit_enum_variant("Ok", 0, 1, |s| s.emit_enum_variant_arg(0, |s| v.encode(s))) + } + Err(ref v) => { + s.emit_enum_variant("Err", 1, 1, |s| s.emit_enum_variant_arg(0, |s| v.encode(s))) + } + }) + } +} + +impl<D: Decoder, T1: Decodable<D>, T2: Decodable<D>> Decodable<D> for Result<T1, T2> { + fn decode(d: &mut D) -> Result<Result<T1, T2>, D::Error> { + d.read_enum("Result", |d| { + d.read_enum_variant(&["Ok", "Err"], |d, disr| match disr { + 0 => Ok(Ok(d.read_enum_variant_arg(0, |d| T1::decode(d))?)), + 1 => Ok(Err(d.read_enum_variant_arg(0, |d| T2::decode(d))?)), + _ => { + panic!( + "Encountered invalid discriminant while \ + decoding `Result`." + ); + } + }) + }) + } +} + +macro_rules! peel { + ($name:ident, $($other:ident,)*) => (tuple! { $($other,)* }) +} + +/// Evaluates to the number of tokens passed to it. +/// +/// Logarithmic counting: every one or two recursive expansions, the number of +/// tokens to count is divided by two, instead of being reduced by one. +/// Therefore, the recursion depth is the binary logarithm of the number of +/// tokens to count, and the expanded tree is likewise very small. +macro_rules! count { + () => (0usize); + ($one:tt) => (1usize); + ($($pairs:tt $_p:tt)*) => (count!($($pairs)*) << 1usize); + ($odd:tt $($rest:tt)*) => (count!($($rest)*) | 1usize); +} + +macro_rules! tuple { + () => (); + ( $($name:ident,)+ ) => ( + impl<D: Decoder, $($name: Decodable<D>),+> Decodable<D> for ($($name,)+) { + #[allow(non_snake_case)] + fn decode(d: &mut D) -> Result<($($name,)+), D::Error> { + let len: usize = count!($($name)+); + d.read_tuple(len, |d| { + let mut i = 0; + let ret = ($(d.read_tuple_arg({ i+=1; i-1 }, |d| -> Result<$name, D::Error> { + Decodable::decode(d) + })?,)+); + Ok(ret) + }) + } + } + impl<S: Encoder, $($name: Encodable<S>),+> Encodable<S> for ($($name,)+) { + #[allow(non_snake_case)] + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + let ($(ref $name,)+) = *self; + let mut n = 0; + $(let $name = $name; n += 1;)+ + s.emit_tuple(n, |s| { + let mut i = 0; + $(s.emit_tuple_arg({ i+=1; i-1 }, |s| $name.encode(s))?;)+ + Ok(()) + }) + } + } + peel! { $($name,)+ } + ) +} + +tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, } + +impl<S: Encoder> Encodable<S> for path::Path { + fn encode(&self, e: &mut S) -> Result<(), S::Error> { + self.to_str().unwrap().encode(e) + } +} + +impl<S: Encoder> Encodable<S> for path::PathBuf { + fn encode(&self, e: &mut S) -> Result<(), S::Error> { + path::Path::encode(self, e) + } +} + +impl<D: Decoder> Decodable<D> for path::PathBuf { + fn decode(d: &mut D) -> Result<path::PathBuf, D::Error> { + let bytes: String = Decodable::decode(d)?; + Ok(path::PathBuf::from(bytes)) + } +} + +impl<S: Encoder, T: Encodable<S> + Copy> Encodable<S> for Cell<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + self.get().encode(s) + } +} + +impl<D: Decoder, T: Decodable<D> + Copy> Decodable<D> for Cell<T> { + fn decode(d: &mut D) -> Result<Cell<T>, D::Error> { + Ok(Cell::new(Decodable::decode(d)?)) + } +} + +// FIXME: #15036 +// Should use `try_borrow`, returning a +// `encoder.error("attempting to Encode borrowed RefCell")` +// from `encode` when `try_borrow` returns `None`. + +impl<S: Encoder, T: Encodable<S>> Encodable<S> for RefCell<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + self.borrow().encode(s) + } +} + +impl<D: Decoder, T: Decodable<D>> Decodable<D> for RefCell<T> { + fn decode(d: &mut D) -> Result<RefCell<T>, D::Error> { + Ok(RefCell::new(Decodable::decode(d)?)) + } +} + +impl<S: Encoder, T: Encodable<S>> Encodable<S> for Arc<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + (**self).encode(s) + } +} + +impl<D: Decoder, T: Decodable<D>> Decodable<D> for Arc<T> { + fn decode(d: &mut D) -> Result<Arc<T>, D::Error> { + Ok(Arc::new(Decodable::decode(d)?)) + } +} + +impl<S: Encoder, T: ?Sized + Encodable<S>> Encodable<S> for Box<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + (**self).encode(s) + } +} +impl<D: Decoder, T: Decodable<D>> Decodable<D> for Box<T> { + fn decode(d: &mut D) -> Result<Box<T>, D::Error> { + Ok(box Decodable::decode(d)?) + } +} |