2012-12-03 18:48:01 -06:00
|
|
|
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
// file at the top-level directory of this distribution and at
|
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
|
|
|
|
2011-11-07 17:24:44 -06:00
|
|
|
// Rust JSON serialization library
|
|
|
|
// Copyright (c) 2011 Google Inc.
|
2012-09-13 00:09:55 -05:00
|
|
|
#[forbid(non_camel_case_types)];
|
2011-11-07 13:01:28 -06:00
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
//! json serialization
|
2012-03-07 20:17:30 -06:00
|
|
|
|
2013-01-25 18:57:39 -06:00
|
|
|
use serialize::Encodable;
|
2012-12-23 16:41:37 -06:00
|
|
|
use serialize;
|
2012-09-07 20:53:14 -05:00
|
|
|
use sort::Sort;
|
2011-11-07 13:01:28 -06:00
|
|
|
|
2012-12-23 16:41:37 -06:00
|
|
|
use core::char;
|
|
|
|
use core::cmp::{Eq, Ord};
|
|
|
|
use core::float;
|
|
|
|
use core::io::{WriterUtil, ReaderUtil};
|
|
|
|
use core::io;
|
2013-01-08 21:37:25 -06:00
|
|
|
use core::prelude::*;
|
2013-01-23 16:06:32 -06:00
|
|
|
use core::hashmap::linear::LinearMap;
|
2012-12-23 16:41:37 -06:00
|
|
|
use core::str;
|
|
|
|
use core::to_str;
|
|
|
|
use core::vec;
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Represents a json value
|
2012-09-24 11:55:42 -05:00
|
|
|
pub enum Json {
|
|
|
|
Number(float),
|
|
|
|
String(~str),
|
2012-08-11 09:08:42 -05:00
|
|
|
Boolean(bool),
|
2012-09-24 11:55:42 -05:00
|
|
|
List(List),
|
|
|
|
Object(~Object),
|
2012-08-11 09:08:42 -05:00
|
|
|
Null,
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
|
|
|
|
2012-09-24 11:55:42 -05:00
|
|
|
pub type List = ~[Json];
|
2013-01-23 16:06:32 -06:00
|
|
|
pub type Object = LinearMap<~str, Json>;
|
2012-09-24 11:55:42 -05:00
|
|
|
|
|
|
|
pub struct Error {
|
2012-02-25 18:39:32 -06:00
|
|
|
line: uint,
|
|
|
|
col: uint,
|
2012-07-14 00:57:48 -05:00
|
|
|
msg: @~str,
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
2012-02-25 18:39:32 -06:00
|
|
|
|
2012-09-24 11:55:42 -05:00
|
|
|
fn escape_str(s: &str) -> ~str {
|
|
|
|
let mut escaped = ~"\"";
|
|
|
|
for str::chars_each(s) |c| {
|
|
|
|
match c {
|
|
|
|
'"' => escaped += ~"\\\"",
|
|
|
|
'\\' => escaped += ~"\\\\",
|
|
|
|
'\x08' => escaped += ~"\\b",
|
|
|
|
'\x0c' => escaped += ~"\\f",
|
|
|
|
'\n' => escaped += ~"\\n",
|
|
|
|
'\r' => escaped += ~"\\r",
|
|
|
|
'\t' => escaped += ~"\\t",
|
|
|
|
_ => escaped += str::from_char(c)
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
2012-09-24 11:55:42 -05:00
|
|
|
};
|
2012-02-25 18:39:32 -06:00
|
|
|
|
2012-09-24 11:55:42 -05:00
|
|
|
escaped += ~"\"";
|
|
|
|
|
|
|
|
escaped
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
|
|
|
|
2012-09-24 11:55:42 -05:00
|
|
|
fn spaces(n: uint) -> ~str {
|
|
|
|
let mut ss = ~"";
|
2012-10-11 16:12:50 -05:00
|
|
|
for n.times { str::push_str(&mut ss, " "); }
|
2012-09-24 11:55:42 -05:00
|
|
|
return ss;
|
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
pub struct Encoder {
|
2012-09-24 11:55:42 -05:00
|
|
|
priv wr: io::Writer,
|
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
pub fn Encoder(wr: io::Writer) -> Encoder {
|
|
|
|
Encoder { wr: wr }
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
|
|
|
|
2013-02-14 23:17:26 -06:00
|
|
|
pub impl serialize::Encoder for Encoder {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn emit_nil(&self) { self.wr.write_str("null") }
|
|
|
|
|
|
|
|
fn emit_uint(&self, v: uint) { self.emit_float(v as float); }
|
|
|
|
fn emit_u64(&self, v: u64) { self.emit_float(v as float); }
|
|
|
|
fn emit_u32(&self, v: u32) { self.emit_float(v as float); }
|
|
|
|
fn emit_u16(&self, v: u16) { self.emit_float(v as float); }
|
|
|
|
fn emit_u8(&self, v: u8) { self.emit_float(v as float); }
|
|
|
|
|
|
|
|
fn emit_int(&self, v: int) { self.emit_float(v as float); }
|
|
|
|
fn emit_i64(&self, v: i64) { self.emit_float(v as float); }
|
|
|
|
fn emit_i32(&self, v: i32) { self.emit_float(v as float); }
|
|
|
|
fn emit_i16(&self, v: i16) { self.emit_float(v as float); }
|
|
|
|
fn emit_i8(&self, v: i8) { self.emit_float(v as float); }
|
|
|
|
|
|
|
|
fn emit_bool(&self, v: bool) {
|
|
|
|
if v {
|
|
|
|
self.wr.write_str("true");
|
|
|
|
} else {
|
|
|
|
self.wr.write_str("false");
|
2012-08-30 23:03:19 -05:00
|
|
|
}
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
2012-08-30 23:03:19 -05:00
|
|
|
|
2012-09-24 11:55:42 -05:00
|
|
|
fn emit_f64(&self, v: f64) { self.emit_float(v as float); }
|
|
|
|
fn emit_f32(&self, v: f32) { self.emit_float(v as float); }
|
|
|
|
fn emit_float(&self, v: float) {
|
2013-01-26 20:28:39 -06:00
|
|
|
self.wr.write_str(float::to_str_digits(v, 6u));
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
2012-08-30 23:03:19 -05:00
|
|
|
|
2012-09-26 23:35:13 -05:00
|
|
|
fn emit_char(&self, v: char) { self.emit_borrowed_str(str::from_char(v)) }
|
|
|
|
|
|
|
|
fn emit_borrowed_str(&self, v: &str) { self.wr.write_str(escape_str(v)) }
|
|
|
|
fn emit_owned_str(&self, v: &str) { self.emit_borrowed_str(v) }
|
|
|
|
fn emit_managed_str(&self, v: &str) { self.emit_borrowed_str(v) }
|
|
|
|
|
|
|
|
fn emit_borrowed(&self, f: fn()) { f() }
|
|
|
|
fn emit_owned(&self, f: fn()) { f() }
|
|
|
|
fn emit_managed(&self, f: fn()) { f() }
|
2012-08-30 18:39:56 -05:00
|
|
|
|
2013-02-06 19:23:41 -06:00
|
|
|
fn emit_enum(&self, _name: &str, f: fn()) {
|
2013-02-06 19:19:11 -06:00
|
|
|
f()
|
|
|
|
}
|
2013-02-06 19:23:41 -06:00
|
|
|
|
|
|
|
fn emit_enum_variant(&self, name: &str, _id: uint, _cnt: uint, f: fn()) {
|
2013-02-08 17:36:40 -06:00
|
|
|
// encoding of enums is special-cased for Option. Specifically:
|
|
|
|
// Some(34) => 34
|
|
|
|
// None => null
|
|
|
|
|
|
|
|
// other enums are encoded as vectors:
|
|
|
|
// Kangaroo(34,"William") => ["Kangaroo",[34,"William"]]
|
2013-02-08 20:58:33 -06:00
|
|
|
|
2013-02-08 17:36:40 -06:00
|
|
|
// the default expansion for enums is more verbose than I'd like;
|
|
|
|
// specifically, the inner pair of brackets seems superfluous,
|
|
|
|
// BUT the design of the enumeration framework and the requirements
|
|
|
|
// of the special-case for Option mean that a first argument must
|
|
|
|
// be encoded "naked"--with no commas--and that the option name
|
|
|
|
// can't be followed by just a comma, because there might not
|
|
|
|
// be any elements in the tuple.
|
2013-02-08 20:58:33 -06:00
|
|
|
|
2013-02-10 13:25:46 -06:00
|
|
|
// FIXME #4872: this would be more precise and less frightening
|
2013-02-08 17:36:40 -06:00
|
|
|
// with fully-qualified option names. To get that information,
|
2013-02-08 20:58:33 -06:00
|
|
|
// we'd have to change the expansion of auto-encode to pass
|
|
|
|
// those along.
|
2013-02-08 17:36:40 -06:00
|
|
|
|
|
|
|
if (name == ~"Some") {
|
|
|
|
f();
|
|
|
|
} else if (name == ~"None") {
|
|
|
|
self.wr.write_str(~"null");
|
|
|
|
} else {
|
|
|
|
self.wr.write_char('[');
|
|
|
|
self.wr.write_str(escape_str(name));
|
|
|
|
self.wr.write_char(',');
|
|
|
|
self.wr.write_char('[');
|
|
|
|
f();
|
|
|
|
self.wr.write_char(']');
|
|
|
|
self.wr.write_char(']');
|
|
|
|
}
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
2013-02-07 19:06:26 -06:00
|
|
|
|
2013-02-08 17:36:40 -06:00
|
|
|
fn emit_enum_variant_arg(&self, idx: uint, f: fn()) {
|
|
|
|
if (idx != 0) {self.wr.write_char(',');}
|
2013-02-06 19:19:11 -06:00
|
|
|
f();
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
|
|
|
|
2012-09-26 23:35:13 -05:00
|
|
|
fn emit_borrowed_vec(&self, _len: uint, f: fn()) {
|
2012-09-24 11:55:42 -05:00
|
|
|
self.wr.write_char('[');
|
|
|
|
f();
|
|
|
|
self.wr.write_char(']');
|
|
|
|
}
|
2013-02-08 20:58:33 -06:00
|
|
|
|
2012-09-26 23:35:13 -05:00
|
|
|
fn emit_owned_vec(&self, len: uint, f: fn()) {
|
|
|
|
self.emit_borrowed_vec(len, f)
|
|
|
|
}
|
|
|
|
fn emit_managed_vec(&self, len: uint, f: fn()) {
|
|
|
|
self.emit_borrowed_vec(len, f)
|
|
|
|
}
|
2012-09-24 11:55:42 -05:00
|
|
|
fn emit_vec_elt(&self, idx: uint, f: fn()) {
|
|
|
|
if idx != 0 { self.wr.write_char(','); }
|
|
|
|
f()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn emit_rec(&self, f: fn()) {
|
|
|
|
self.wr.write_char('{');
|
|
|
|
f();
|
|
|
|
self.wr.write_char('}');
|
|
|
|
}
|
2012-12-27 06:16:16 -06:00
|
|
|
fn emit_struct(&self, _name: &str, _len: uint, f: fn()) {
|
2012-09-26 23:35:13 -05:00
|
|
|
self.wr.write_char('{');
|
|
|
|
f();
|
|
|
|
self.wr.write_char('}');
|
|
|
|
}
|
|
|
|
fn emit_field(&self, name: &str, idx: uint, f: fn()) {
|
2012-09-24 11:55:42 -05:00
|
|
|
if idx != 0 { self.wr.write_char(','); }
|
|
|
|
self.wr.write_str(escape_str(name));
|
|
|
|
self.wr.write_char(':');
|
|
|
|
f();
|
|
|
|
}
|
2012-09-26 23:35:13 -05:00
|
|
|
|
|
|
|
fn emit_tup(&self, len: uint, f: fn()) {
|
|
|
|
self.emit_borrowed_vec(len, f);
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
|
|
|
fn emit_tup_elt(&self, idx: uint, f: fn()) {
|
|
|
|
self.emit_vec_elt(idx, f)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
pub struct PrettyEncoder {
|
2012-09-24 11:55:42 -05:00
|
|
|
priv wr: io::Writer,
|
|
|
|
priv mut indent: uint,
|
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
pub fn PrettyEncoder(wr: io::Writer) -> PrettyEncoder {
|
|
|
|
PrettyEncoder { wr: wr, indent: 0 }
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
2012-08-30 18:39:56 -05:00
|
|
|
|
2013-02-14 23:17:26 -06:00
|
|
|
pub impl serialize::Encoder for PrettyEncoder {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn emit_nil(&self) { self.wr.write_str("null") }
|
|
|
|
|
|
|
|
fn emit_uint(&self, v: uint) { self.emit_float(v as float); }
|
|
|
|
fn emit_u64(&self, v: u64) { self.emit_float(v as float); }
|
|
|
|
fn emit_u32(&self, v: u32) { self.emit_float(v as float); }
|
|
|
|
fn emit_u16(&self, v: u16) { self.emit_float(v as float); }
|
|
|
|
fn emit_u8(&self, v: u8) { self.emit_float(v as float); }
|
|
|
|
|
|
|
|
fn emit_int(&self, v: int) { self.emit_float(v as float); }
|
|
|
|
fn emit_i64(&self, v: i64) { self.emit_float(v as float); }
|
|
|
|
fn emit_i32(&self, v: i32) { self.emit_float(v as float); }
|
|
|
|
fn emit_i16(&self, v: i16) { self.emit_float(v as float); }
|
|
|
|
fn emit_i8(&self, v: i8) { self.emit_float(v as float); }
|
|
|
|
|
|
|
|
fn emit_bool(&self, v: bool) {
|
|
|
|
if v {
|
|
|
|
self.wr.write_str("true");
|
|
|
|
} else {
|
|
|
|
self.wr.write_str("false");
|
2012-08-30 23:03:19 -05:00
|
|
|
}
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn emit_f64(&self, v: f64) { self.emit_float(v as float); }
|
|
|
|
fn emit_f32(&self, v: f32) { self.emit_float(v as float); }
|
|
|
|
fn emit_float(&self, v: float) {
|
2013-01-26 20:28:39 -06:00
|
|
|
self.wr.write_str(float::to_str_digits(v, 6u));
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
2012-08-30 23:03:19 -05:00
|
|
|
|
2012-09-26 23:35:13 -05:00
|
|
|
fn emit_char(&self, v: char) { self.emit_borrowed_str(str::from_char(v)) }
|
|
|
|
|
|
|
|
fn emit_borrowed_str(&self, v: &str) { self.wr.write_str(escape_str(v)); }
|
|
|
|
fn emit_owned_str(&self, v: &str) { self.emit_borrowed_str(v) }
|
|
|
|
fn emit_managed_str(&self, v: &str) { self.emit_borrowed_str(v) }
|
|
|
|
|
|
|
|
fn emit_borrowed(&self, f: fn()) { f() }
|
|
|
|
fn emit_owned(&self, f: fn()) { f() }
|
|
|
|
fn emit_managed(&self, f: fn()) { f() }
|
2012-08-30 23:03:19 -05:00
|
|
|
|
2012-09-24 11:55:42 -05:00
|
|
|
fn emit_enum(&self, name: &str, f: fn()) {
|
2013-02-11 21:26:38 -06:00
|
|
|
if name != "option" { fail!(~"only supports option enum") }
|
2012-09-24 11:55:42 -05:00
|
|
|
f()
|
|
|
|
}
|
|
|
|
fn emit_enum_variant(&self, _name: &str, id: uint, _cnt: uint, f: fn()) {
|
|
|
|
if id == 0 {
|
|
|
|
self.emit_nil();
|
|
|
|
} else {
|
|
|
|
f()
|
2012-08-30 19:38:07 -05:00
|
|
|
}
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
|
|
|
fn emit_enum_variant_arg(&self, _idx: uint, f: fn()) {
|
|
|
|
f()
|
|
|
|
}
|
2012-08-30 19:38:07 -05:00
|
|
|
|
2012-09-26 23:35:13 -05:00
|
|
|
fn emit_borrowed_vec(&self, _len: uint, f: fn()) {
|
2012-09-24 11:55:42 -05:00
|
|
|
self.wr.write_char('[');
|
|
|
|
self.indent += 2;
|
|
|
|
f();
|
|
|
|
self.indent -= 2;
|
|
|
|
self.wr.write_char(']');
|
|
|
|
}
|
2012-09-26 23:35:13 -05:00
|
|
|
fn emit_owned_vec(&self, len: uint, f: fn()) {
|
|
|
|
self.emit_borrowed_vec(len, f)
|
|
|
|
}
|
|
|
|
fn emit_managed_vec(&self, len: uint, f: fn()) {
|
|
|
|
self.emit_borrowed_vec(len, f)
|
|
|
|
}
|
2012-09-24 11:55:42 -05:00
|
|
|
fn emit_vec_elt(&self, idx: uint, f: fn()) {
|
|
|
|
if idx == 0 {
|
|
|
|
self.wr.write_char('\n');
|
|
|
|
} else {
|
|
|
|
self.wr.write_str(",\n");
|
|
|
|
}
|
|
|
|
self.wr.write_str(spaces(self.indent));
|
|
|
|
f()
|
|
|
|
}
|
2012-08-30 18:39:56 -05:00
|
|
|
|
2012-09-24 11:55:42 -05:00
|
|
|
fn emit_rec(&self, f: fn()) {
|
|
|
|
self.wr.write_char('{');
|
|
|
|
self.indent += 2;
|
|
|
|
f();
|
|
|
|
self.indent -= 2;
|
|
|
|
self.wr.write_char('}');
|
|
|
|
}
|
2012-12-27 06:16:16 -06:00
|
|
|
fn emit_struct(&self, _name: &str, _len: uint, f: fn()) {
|
2012-09-26 23:35:13 -05:00
|
|
|
self.emit_rec(f)
|
|
|
|
}
|
|
|
|
fn emit_field(&self, name: &str, idx: uint, f: fn()) {
|
2012-09-24 11:55:42 -05:00
|
|
|
if idx == 0 {
|
|
|
|
self.wr.write_char('\n');
|
|
|
|
} else {
|
|
|
|
self.wr.write_str(",\n");
|
|
|
|
}
|
|
|
|
self.wr.write_str(spaces(self.indent));
|
|
|
|
self.wr.write_str(escape_str(name));
|
|
|
|
self.wr.write_str(": ");
|
|
|
|
f();
|
|
|
|
}
|
|
|
|
fn emit_tup(&self, sz: uint, f: fn()) {
|
2012-09-26 23:35:13 -05:00
|
|
|
self.emit_borrowed_vec(sz, f);
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
|
|
|
fn emit_tup_elt(&self, idx: uint, f: fn()) {
|
|
|
|
self.emit_vec_elt(idx, f)
|
2012-08-30 18:39:56 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-20 19:07:17 -06:00
|
|
|
pub impl<S:serialize::Encoder> serialize::Encodable<S> for Json {
|
2012-12-17 21:31:04 -06:00
|
|
|
fn encode(&self, s: &S) {
|
2012-10-13 11:11:33 -05:00
|
|
|
match *self {
|
2012-12-17 21:31:04 -06:00
|
|
|
Number(v) => v.encode(s),
|
|
|
|
String(ref v) => v.encode(s),
|
|
|
|
Boolean(v) => v.encode(s),
|
|
|
|
List(ref v) => v.encode(s),
|
2012-10-13 11:11:33 -05:00
|
|
|
Object(ref v) => {
|
|
|
|
do s.emit_rec || {
|
|
|
|
let mut idx = 0;
|
2013-02-07 20:03:13 -06:00
|
|
|
for v.each |&(key, value)| {
|
2012-10-13 11:11:33 -05:00
|
|
|
do s.emit_field(*key, idx) {
|
2012-12-17 21:31:04 -06:00
|
|
|
value.encode(s);
|
2012-10-13 11:11:33 -05:00
|
|
|
}
|
|
|
|
idx += 1;
|
|
|
|
}
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
2012-09-26 23:35:13 -05:00
|
|
|
},
|
|
|
|
Null => s.emit_nil(),
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-06-12 19:20:51 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
/// Encodes a json value into a io::writer
|
2012-09-24 11:55:42 -05:00
|
|
|
pub fn to_writer(wr: io::Writer, json: &Json) {
|
2012-12-17 21:31:04 -06:00
|
|
|
json.encode(&Encoder(wr))
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
2012-06-12 19:20:51 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
/// Encodes a json value into a string
|
2013-01-23 13:43:58 -06:00
|
|
|
pub pure fn to_str(json: &Json) -> ~str {
|
|
|
|
unsafe {
|
|
|
|
// ugh, should be safe
|
|
|
|
io::with_str_writer(|wr| to_writer(wr, json))
|
|
|
|
}
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
/// Encodes a json value into a io::writer
|
2012-09-24 11:55:42 -05:00
|
|
|
pub fn to_pretty_writer(wr: io::Writer, json: &Json) {
|
2012-12-17 21:31:04 -06:00
|
|
|
json.encode(&PrettyEncoder(wr))
|
2012-06-12 19:20:51 -05:00
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
/// Encodes a json value into a string
|
2012-09-24 11:55:42 -05:00
|
|
|
pub fn to_pretty_str(json: &Json) -> ~str {
|
|
|
|
io::with_str_writer(|wr| to_pretty_writer(wr, json))
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
|
|
|
|
2012-09-24 11:55:42 -05:00
|
|
|
pub struct Parser {
|
|
|
|
priv rdr: io::Reader,
|
|
|
|
priv mut ch: char,
|
|
|
|
priv mut line: uint,
|
|
|
|
priv mut col: uint,
|
2012-08-30 18:39:56 -05:00
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
/// Decode a json value from an io::reader
|
2012-09-24 11:55:42 -05:00
|
|
|
pub fn Parser(rdr: io::Reader) -> Parser {
|
|
|
|
Parser {
|
|
|
|
rdr: rdr,
|
|
|
|
ch: rdr.read_char(),
|
2012-09-19 00:35:42 -05:00
|
|
|
line: 1,
|
|
|
|
col: 1,
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
|
|
|
}
|
2011-11-07 13:01:28 -06:00
|
|
|
|
2012-09-24 11:55:42 -05:00
|
|
|
pub impl Parser {
|
|
|
|
fn parse() -> Result<Json, Error> {
|
2013-02-15 01:30:30 -06:00
|
|
|
match self.parse_value() {
|
|
|
|
Ok(value) => {
|
2012-09-24 11:55:42 -05:00
|
|
|
// Skip trailing whitespaces.
|
|
|
|
self.parse_whitespace();
|
|
|
|
// Make sure there is no trailing characters.
|
|
|
|
if self.eof() {
|
2013-02-15 01:30:30 -06:00
|
|
|
Ok(value)
|
2012-09-24 11:55:42 -05:00
|
|
|
} else {
|
|
|
|
self.error(~"trailing characters")
|
|
|
|
}
|
|
|
|
}
|
2013-02-15 01:30:30 -06:00
|
|
|
Err(e) => Err(e)
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
|
|
|
}
|
2012-07-11 17:00:40 -05:00
|
|
|
}
|
|
|
|
|
2012-09-24 11:55:42 -05:00
|
|
|
priv impl Parser {
|
2012-02-25 18:39:32 -06:00
|
|
|
fn eof() -> bool { self.ch == -1 as char }
|
|
|
|
|
|
|
|
fn bump() {
|
|
|
|
self.ch = self.rdr.read_char();
|
2011-11-07 13:01:28 -06:00
|
|
|
|
2012-02-25 18:39:32 -06:00
|
|
|
if self.ch == '\n' {
|
|
|
|
self.line += 1u;
|
|
|
|
self.col = 1u;
|
|
|
|
} else {
|
|
|
|
self.col += 1u;
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
fn next_char() -> char {
|
|
|
|
self.bump();
|
|
|
|
self.ch
|
|
|
|
}
|
|
|
|
|
2012-10-03 14:21:48 -05:00
|
|
|
fn error<T>(msg: ~str) -> Result<T, Error> {
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error { line: self.line, col: self.col, msg: @msg })
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
|
|
|
|
2012-08-11 09:08:42 -05:00
|
|
|
fn parse_value() -> Result<Json, Error> {
|
2012-02-25 18:39:32 -06:00
|
|
|
self.parse_whitespace();
|
|
|
|
|
2012-08-01 19:30:05 -05:00
|
|
|
if self.eof() { return self.error(~"EOF while parsing value"); }
|
2011-11-07 13:01:28 -06:00
|
|
|
|
2012-08-06 14:34:08 -05:00
|
|
|
match self.ch {
|
2012-08-11 09:08:42 -05:00
|
|
|
'n' => self.parse_ident(~"ull", Null),
|
|
|
|
't' => self.parse_ident(~"rue", Boolean(true)),
|
|
|
|
'f' => self.parse_ident(~"alse", Boolean(false)),
|
2012-09-01 20:38:05 -05:00
|
|
|
'0' .. '9' | '-' => self.parse_number(),
|
2012-09-24 11:55:42 -05:00
|
|
|
'"' =>
|
2013-02-15 01:30:30 -06:00
|
|
|
match self.parse_str() {
|
|
|
|
Ok(s) => Ok(String(s)),
|
|
|
|
Err(e) => Err(e),
|
2012-09-24 11:55:42 -05:00
|
|
|
},
|
2012-08-03 21:59:04 -05:00
|
|
|
'[' => self.parse_list(),
|
|
|
|
'{' => self.parse_object(),
|
|
|
|
_ => self.error(~"invalid syntax")
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
fn parse_whitespace() {
|
|
|
|
while char::is_whitespace(self.ch) { self.bump(); }
|
|
|
|
}
|
|
|
|
|
2012-10-04 21:58:31 -05:00
|
|
|
fn parse_ident(ident: &str, value: Json) -> Result<Json, Error> {
|
2012-06-30 18:19:07 -05:00
|
|
|
if str::all(ident, |c| c == self.next_char()) {
|
2012-02-25 18:39:32 -06:00
|
|
|
self.bump();
|
2013-02-15 01:30:30 -06:00
|
|
|
Ok(value)
|
2012-02-25 18:39:32 -06:00
|
|
|
} else {
|
2012-07-14 00:57:48 -05:00
|
|
|
self.error(~"invalid syntax")
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-11 09:08:42 -05:00
|
|
|
fn parse_number() -> Result<Json, Error> {
|
2012-03-14 13:03:56 -05:00
|
|
|
let mut neg = 1f;
|
2012-02-25 18:39:32 -06:00
|
|
|
|
|
|
|
if self.ch == '-' {
|
|
|
|
self.bump();
|
|
|
|
neg = -1f;
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
2012-02-25 18:39:32 -06:00
|
|
|
|
2012-08-06 14:34:08 -05:00
|
|
|
let mut res = match self.parse_integer() {
|
2012-08-26 18:54:31 -05:00
|
|
|
Ok(res) => res,
|
|
|
|
Err(e) => return Err(e)
|
2012-02-25 18:39:32 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
if self.ch == '.' {
|
2012-08-06 14:34:08 -05:00
|
|
|
match self.parse_decimal(res) {
|
2012-08-26 18:54:31 -05:00
|
|
|
Ok(r) => res = r,
|
|
|
|
Err(e) => return Err(e)
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
2012-02-25 18:39:32 -06:00
|
|
|
|
|
|
|
if self.ch == 'e' || self.ch == 'E' {
|
2012-08-06 14:34:08 -05:00
|
|
|
match self.parse_exponent(res) {
|
2012-08-26 18:54:31 -05:00
|
|
|
Ok(r) => res = r,
|
|
|
|
Err(e) => return Err(e)
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
2012-02-25 18:39:32 -06:00
|
|
|
|
2012-09-24 11:55:42 -05:00
|
|
|
Ok(Number(neg * res))
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
|
|
|
|
2012-08-11 09:08:42 -05:00
|
|
|
fn parse_integer() -> Result<float, Error> {
|
2012-03-14 13:03:56 -05:00
|
|
|
let mut res = 0f;
|
2011-11-07 13:01:28 -06:00
|
|
|
|
2012-08-06 14:34:08 -05:00
|
|
|
match self.ch {
|
2012-08-03 21:59:04 -05:00
|
|
|
'0' => {
|
2012-02-25 18:39:32 -06:00
|
|
|
self.bump();
|
|
|
|
|
|
|
|
// There can be only one leading '0'.
|
2012-08-06 14:34:08 -05:00
|
|
|
match self.ch {
|
2012-09-01 20:38:05 -05:00
|
|
|
'0' .. '9' => return self.error(~"invalid number"),
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => ()
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
}
|
2012-09-01 20:38:05 -05:00
|
|
|
'1' .. '9' => {
|
2012-02-25 18:39:32 -06:00
|
|
|
while !self.eof() {
|
2012-08-06 14:34:08 -05:00
|
|
|
match self.ch {
|
2012-09-01 20:38:05 -05:00
|
|
|
'0' .. '9' => {
|
2012-02-25 18:39:32 -06:00
|
|
|
res *= 10f;
|
|
|
|
res += ((self.ch as int) - ('0' as int)) as float;
|
|
|
|
|
|
|
|
self.bump();
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => break
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => return self.error(~"invalid number")
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
2012-02-25 18:39:32 -06:00
|
|
|
|
2012-08-26 18:54:31 -05:00
|
|
|
Ok(res)
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
|
|
|
|
2012-08-11 09:08:42 -05:00
|
|
|
fn parse_decimal(res: float) -> Result<float, Error> {
|
2012-02-25 18:39:32 -06:00
|
|
|
self.bump();
|
|
|
|
|
|
|
|
// Make sure a digit follows the decimal place.
|
2012-08-06 14:34:08 -05:00
|
|
|
match self.ch {
|
2012-09-01 20:38:05 -05:00
|
|
|
'0' .. '9' => (),
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => return self.error(~"invalid number")
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
|
2012-03-14 13:03:56 -05:00
|
|
|
let mut res = res;
|
|
|
|
let mut dec = 1f;
|
2012-02-25 18:39:32 -06:00
|
|
|
while !self.eof() {
|
2012-08-06 14:34:08 -05:00
|
|
|
match self.ch {
|
2012-09-01 20:38:05 -05:00
|
|
|
'0' .. '9' => {
|
2012-02-25 18:39:32 -06:00
|
|
|
dec /= 10f;
|
|
|
|
res += (((self.ch as int) - ('0' as int)) as float) * dec;
|
|
|
|
|
|
|
|
self.bump();
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => break
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
|
|
|
}
|
2012-02-25 18:39:32 -06:00
|
|
|
|
2012-08-26 18:54:31 -05:00
|
|
|
Ok(res)
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
|
|
|
|
2012-08-11 09:08:42 -05:00
|
|
|
fn parse_exponent(res: float) -> Result<float, Error> {
|
2012-02-25 18:39:32 -06:00
|
|
|
self.bump();
|
|
|
|
|
2012-03-14 13:03:56 -05:00
|
|
|
let mut res = res;
|
|
|
|
let mut exp = 0u;
|
|
|
|
let mut neg_exp = false;
|
2012-02-25 18:39:32 -06:00
|
|
|
|
2012-08-06 14:34:08 -05:00
|
|
|
match self.ch {
|
2012-08-03 21:59:04 -05:00
|
|
|
'+' => self.bump(),
|
|
|
|
'-' => { self.bump(); neg_exp = true; }
|
|
|
|
_ => ()
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure a digit follows the exponent place.
|
2012-08-06 14:34:08 -05:00
|
|
|
match self.ch {
|
2012-09-01 20:38:05 -05:00
|
|
|
'0' .. '9' => (),
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => return self.error(~"invalid number")
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
while !self.eof() {
|
2012-08-06 14:34:08 -05:00
|
|
|
match self.ch {
|
2012-09-01 20:38:05 -05:00
|
|
|
'0' .. '9' => {
|
2012-02-25 18:39:32 -06:00
|
|
|
exp *= 10u;
|
|
|
|
exp += (self.ch as uint) - ('0' as uint);
|
|
|
|
|
|
|
|
self.bump();
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => break
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
let exp = float::pow_with_uint(10u, exp);
|
|
|
|
if neg_exp {
|
|
|
|
res /= exp;
|
|
|
|
} else {
|
|
|
|
res *= exp;
|
|
|
|
}
|
|
|
|
|
2012-08-26 18:54:31 -05:00
|
|
|
Ok(res)
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
|
|
|
|
2012-09-24 11:55:42 -05:00
|
|
|
fn parse_str() -> Result<~str, Error> {
|
2012-03-14 13:03:56 -05:00
|
|
|
let mut escape = false;
|
2012-07-14 00:57:48 -05:00
|
|
|
let mut res = ~"";
|
2012-02-25 18:39:32 -06:00
|
|
|
|
|
|
|
while !self.eof() {
|
|
|
|
self.bump();
|
|
|
|
|
|
|
|
if (escape) {
|
2012-08-06 14:34:08 -05:00
|
|
|
match self.ch {
|
2012-10-11 16:12:50 -05:00
|
|
|
'"' => str::push_char(&mut res, '"'),
|
|
|
|
'\\' => str::push_char(&mut res, '\\'),
|
|
|
|
'/' => str::push_char(&mut res, '/'),
|
|
|
|
'b' => str::push_char(&mut res, '\x08'),
|
|
|
|
'f' => str::push_char(&mut res, '\x0c'),
|
|
|
|
'n' => str::push_char(&mut res, '\n'),
|
|
|
|
'r' => str::push_char(&mut res, '\r'),
|
|
|
|
't' => str::push_char(&mut res, '\t'),
|
2012-08-03 21:59:04 -05:00
|
|
|
'u' => {
|
2012-02-25 18:39:32 -06:00
|
|
|
// Parse \u1234.
|
2012-03-14 13:03:56 -05:00
|
|
|
let mut i = 0u;
|
|
|
|
let mut n = 0u;
|
2012-02-25 18:39:32 -06:00
|
|
|
while i < 4u {
|
2012-08-06 14:34:08 -05:00
|
|
|
match self.next_char() {
|
2012-09-01 20:38:05 -05:00
|
|
|
'0' .. '9' => {
|
2012-08-30 22:12:10 -05:00
|
|
|
n = n * 16u + (self.ch as uint)
|
|
|
|
- ('0' as uint);
|
|
|
|
},
|
|
|
|
'a' | 'A' => n = n * 16u + 10u,
|
|
|
|
'b' | 'B' => n = n * 16u + 11u,
|
|
|
|
'c' | 'C' => n = n * 16u + 12u,
|
|
|
|
'd' | 'D' => n = n * 16u + 13u,
|
|
|
|
'e' | 'E' => n = n * 16u + 14u,
|
|
|
|
'f' | 'F' => n = n * 16u + 15u,
|
|
|
|
_ => return self.error(
|
|
|
|
~"invalid \\u escape (unrecognized hex)")
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
2012-03-14 13:03:56 -05:00
|
|
|
i += 1u;
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// Error out if we didn't parse 4 digits.
|
|
|
|
if i != 4u {
|
2012-08-30 22:12:10 -05:00
|
|
|
return self.error(
|
|
|
|
~"invalid \\u escape (not four digits)");
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
|
2012-10-11 16:12:50 -05:00
|
|
|
str::push_char(&mut res, n as char);
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => return self.error(~"invalid escape")
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
escape = false;
|
|
|
|
} else if self.ch == '\\' {
|
|
|
|
escape = true;
|
|
|
|
} else {
|
|
|
|
if self.ch == '"' {
|
|
|
|
self.bump();
|
2012-09-24 11:55:42 -05:00
|
|
|
return Ok(res);
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
2012-10-11 16:12:50 -05:00
|
|
|
str::push_char(&mut res, self.ch);
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
|
|
|
}
|
2012-02-25 18:39:32 -06:00
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
self.error(~"EOF while parsing string")
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
|
|
|
|
2012-08-11 09:08:42 -05:00
|
|
|
fn parse_list() -> Result<Json, Error> {
|
2012-02-25 18:39:32 -06:00
|
|
|
self.bump();
|
|
|
|
self.parse_whitespace();
|
|
|
|
|
2012-06-29 18:26:56 -05:00
|
|
|
let mut values = ~[];
|
2012-02-25 18:39:32 -06:00
|
|
|
|
|
|
|
if self.ch == ']' {
|
|
|
|
self.bump();
|
2013-02-15 01:30:30 -06:00
|
|
|
return Ok(List(values));
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
|
2012-03-10 22:34:17 -06:00
|
|
|
loop {
|
2013-02-15 01:30:30 -06:00
|
|
|
match self.parse_value() {
|
|
|
|
Ok(v) => values.push(v),
|
|
|
|
Err(e) => return Err(e)
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
self.parse_whitespace();
|
2012-03-10 22:34:17 -06:00
|
|
|
if self.eof() {
|
2012-08-01 19:30:05 -05:00
|
|
|
return self.error(~"EOF while parsing list");
|
2012-03-10 22:34:17 -06:00
|
|
|
}
|
2012-02-25 18:39:32 -06:00
|
|
|
|
2012-08-06 14:34:08 -05:00
|
|
|
match self.ch {
|
2012-08-03 21:59:04 -05:00
|
|
|
',' => self.bump(),
|
2013-02-15 01:30:30 -06:00
|
|
|
']' => { self.bump(); return Ok(List(values)); }
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => return self.error(~"expected `,` or `]`")
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
2012-03-10 22:34:17 -06:00
|
|
|
};
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
|
|
|
|
2012-08-11 09:08:42 -05:00
|
|
|
fn parse_object() -> Result<Json, Error> {
|
2012-02-25 18:39:32 -06:00
|
|
|
self.bump();
|
|
|
|
self.parse_whitespace();
|
|
|
|
|
2013-01-23 16:06:32 -06:00
|
|
|
let mut values = ~LinearMap::new();
|
2012-02-25 18:39:32 -06:00
|
|
|
|
|
|
|
if self.ch == '}' {
|
|
|
|
self.bump();
|
2013-02-15 01:30:30 -06:00
|
|
|
return Ok(Object(values));
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
while !self.eof() {
|
|
|
|
self.parse_whitespace();
|
|
|
|
|
|
|
|
if self.ch != '"' {
|
2012-08-01 19:30:05 -05:00
|
|
|
return self.error(~"key must be a string");
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
|
2013-02-15 01:30:30 -06:00
|
|
|
let key = match self.parse_str() {
|
|
|
|
Ok(key) => key,
|
|
|
|
Err(e) => return Err(e)
|
2012-02-25 18:39:32 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
self.parse_whitespace();
|
|
|
|
|
|
|
|
if self.ch != ':' {
|
|
|
|
if self.eof() { break; }
|
2012-08-01 19:30:05 -05:00
|
|
|
return self.error(~"expected `:`");
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
self.bump();
|
|
|
|
|
2013-02-15 01:30:30 -06:00
|
|
|
match self.parse_value() {
|
|
|
|
Ok(value) => { values.insert(key, value); }
|
|
|
|
Err(e) => return Err(e)
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
self.parse_whitespace();
|
|
|
|
|
2012-08-06 14:34:08 -05:00
|
|
|
match self.ch {
|
2012-08-03 21:59:04 -05:00
|
|
|
',' => self.bump(),
|
2013-02-15 01:30:30 -06:00
|
|
|
'}' => { self.bump(); return Ok(Object(values)); }
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => {
|
2012-02-25 18:39:32 -06:00
|
|
|
if self.eof() { break; }
|
2012-08-01 19:30:05 -05:00
|
|
|
return self.error(~"expected `,` or `}`");
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-01 19:30:05 -05:00
|
|
|
return self.error(~"EOF while parsing object");
|
2011-12-21 14:36:43 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
/// Decodes a json value from an io::reader
|
2012-09-24 11:55:42 -05:00
|
|
|
pub fn from_reader(rdr: io::Reader) -> Result<Json, Error> {
|
|
|
|
Parser(rdr).parse()
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
/// Decodes a json value from a string
|
2012-09-24 11:55:42 -05:00
|
|
|
pub fn from_str(s: &str) -> Result<Json, Error> {
|
|
|
|
do io::with_str_reader(s) |rdr| {
|
|
|
|
from_reader(rdr)
|
|
|
|
}
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
pub struct Decoder {
|
2012-09-24 11:55:42 -05:00
|
|
|
priv json: Json,
|
|
|
|
priv mut stack: ~[&Json],
|
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
pub fn Decoder(json: Json) -> Decoder {
|
2013-02-15 01:30:30 -06:00
|
|
|
Decoder { json: json, stack: ~[] }
|
2011-11-07 13:01:28 -06:00
|
|
|
}
|
2012-01-17 21:05:07 -06:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
priv impl Decoder {
|
2012-09-26 19:33:34 -05:00
|
|
|
fn peek(&self) -> &self/Json {
|
|
|
|
if self.stack.len() == 0 { self.stack.push(&self.json); }
|
2012-09-24 11:55:42 -05:00
|
|
|
vec::last(self.stack)
|
|
|
|
}
|
|
|
|
|
2012-09-26 19:33:34 -05:00
|
|
|
fn pop(&self) -> &self/Json {
|
|
|
|
if self.stack.len() == 0 { self.stack.push(&self.json); }
|
2012-09-28 00:20:47 -05:00
|
|
|
self.stack.pop()
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-14 23:17:26 -06:00
|
|
|
pub impl serialize::Decoder for Decoder {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn read_nil(&self) -> () {
|
|
|
|
debug!("read_nil");
|
|
|
|
match *self.pop() {
|
|
|
|
Null => (),
|
2013-02-11 21:26:38 -06:00
|
|
|
_ => fail!(~"not a null")
|
2012-09-07 20:53:14 -05:00
|
|
|
}
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
2012-09-07 20:53:14 -05:00
|
|
|
|
2012-09-24 11:55:42 -05:00
|
|
|
fn read_u64(&self) -> u64 { self.read_float() as u64 }
|
|
|
|
fn read_u32(&self) -> u32 { self.read_float() as u32 }
|
|
|
|
fn read_u16(&self) -> u16 { self.read_float() as u16 }
|
|
|
|
fn read_u8 (&self) -> u8 { self.read_float() as u8 }
|
|
|
|
fn read_uint(&self) -> uint { self.read_float() as uint }
|
|
|
|
|
|
|
|
fn read_i64(&self) -> i64 { self.read_float() as i64 }
|
|
|
|
fn read_i32(&self) -> i32 { self.read_float() as i32 }
|
|
|
|
fn read_i16(&self) -> i16 { self.read_float() as i16 }
|
|
|
|
fn read_i8 (&self) -> i8 { self.read_float() as i8 }
|
|
|
|
fn read_int(&self) -> int { self.read_float() as int }
|
|
|
|
|
|
|
|
fn read_bool(&self) -> bool {
|
|
|
|
debug!("read_bool");
|
|
|
|
match *self.pop() {
|
|
|
|
Boolean(b) => b,
|
2013-02-11 21:26:38 -06:00
|
|
|
_ => fail!(~"not a boolean")
|
2012-09-07 20:53:14 -05:00
|
|
|
}
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
2012-09-07 20:53:14 -05:00
|
|
|
|
2012-09-24 11:55:42 -05:00
|
|
|
fn read_f64(&self) -> f64 { self.read_float() as f64 }
|
|
|
|
fn read_f32(&self) -> f32 { self.read_float() as f32 }
|
|
|
|
fn read_float(&self) -> float {
|
|
|
|
debug!("read_float");
|
|
|
|
match *self.pop() {
|
|
|
|
Number(f) => f,
|
2013-02-11 21:26:38 -06:00
|
|
|
_ => fail!(~"not a number")
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-26 23:35:13 -05:00
|
|
|
fn read_char(&self) -> char {
|
|
|
|
let v = str::chars(self.read_owned_str());
|
2013-02-11 21:26:38 -06:00
|
|
|
if v.len() != 1 { fail!(~"string must have one character") }
|
2012-09-26 23:35:13 -05:00
|
|
|
v[0]
|
|
|
|
}
|
|
|
|
|
|
|
|
fn read_owned_str(&self) -> ~str {
|
|
|
|
debug!("read_owned_str");
|
2012-09-24 11:55:42 -05:00
|
|
|
match *self.pop() {
|
|
|
|
String(ref s) => copy *s,
|
2013-02-11 21:26:38 -06:00
|
|
|
_ => fail!(~"not a string")
|
2012-09-07 20:53:14 -05:00
|
|
|
}
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
|
|
|
|
2012-09-26 23:35:13 -05:00
|
|
|
fn read_managed_str(&self) -> @str {
|
2012-12-09 20:29:33 -06:00
|
|
|
debug!("read_managed_str");
|
|
|
|
match *self.pop() {
|
|
|
|
String(ref s) => s.to_managed(),
|
2013-02-11 21:26:38 -06:00
|
|
|
_ => fail!(~"not a string")
|
2012-12-09 20:29:33 -06:00
|
|
|
}
|
2012-09-26 23:35:13 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn read_owned<T>(&self, f: fn() -> T) -> T {
|
|
|
|
debug!("read_owned()");
|
|
|
|
f()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn read_managed<T>(&self, f: fn() -> T) -> T {
|
|
|
|
debug!("read_managed()");
|
|
|
|
f()
|
|
|
|
}
|
|
|
|
|
2012-10-01 14:36:06 -05:00
|
|
|
fn read_enum<T>(&self, name: &str, f: fn() -> T) -> T {
|
2012-09-24 11:55:42 -05:00
|
|
|
debug!("read_enum(%s)", name);
|
2013-02-11 21:26:38 -06:00
|
|
|
if name != ~"option" { fail!(~"only supports the option enum") }
|
2012-09-24 11:55:42 -05:00
|
|
|
f()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn read_enum_variant<T>(&self, f: fn(uint) -> T) -> T {
|
|
|
|
debug!("read_enum_variant()");
|
|
|
|
let idx = match *self.peek() {
|
|
|
|
Null => 0,
|
|
|
|
_ => 1,
|
|
|
|
};
|
|
|
|
f(idx)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn read_enum_variant_arg<T>(&self, idx: uint, f: fn() -> T) -> T {
|
|
|
|
debug!("read_enum_variant_arg(idx=%u)", idx);
|
2013-02-11 21:26:38 -06:00
|
|
|
if idx != 0 { fail!(~"unknown index") }
|
2012-09-24 11:55:42 -05:00
|
|
|
f()
|
|
|
|
}
|
2012-09-07 20:53:14 -05:00
|
|
|
|
2012-09-26 23:35:13 -05:00
|
|
|
fn read_owned_vec<T>(&self, f: fn(uint) -> T) -> T {
|
|
|
|
debug!("read_owned_vec()");
|
|
|
|
let len = match *self.peek() {
|
2013-02-07 21:33:12 -06:00
|
|
|
List(ref list) => list.len(),
|
2013-02-11 21:26:38 -06:00
|
|
|
_ => fail!(~"not a list"),
|
2012-09-26 23:35:13 -05:00
|
|
|
};
|
|
|
|
let res = f(len);
|
|
|
|
self.pop();
|
2013-02-15 01:30:30 -06:00
|
|
|
res
|
2012-09-26 23:35:13 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn read_managed_vec<T>(&self, f: fn(uint) -> T) -> T {
|
|
|
|
debug!("read_owned_vec()");
|
2012-09-24 11:55:42 -05:00
|
|
|
let len = match *self.peek() {
|
2012-09-26 19:33:34 -05:00
|
|
|
List(ref list) => list.len(),
|
2013-02-11 21:26:38 -06:00
|
|
|
_ => fail!(~"not a list"),
|
2012-09-24 11:55:42 -05:00
|
|
|
};
|
|
|
|
let res = f(len);
|
|
|
|
self.pop();
|
2013-02-15 01:30:30 -06:00
|
|
|
res
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn read_vec_elt<T>(&self, idx: uint, f: fn() -> T) -> T {
|
|
|
|
debug!("read_vec_elt(idx=%u)", idx);
|
|
|
|
match *self.peek() {
|
|
|
|
List(ref list) => {
|
2012-09-26 19:33:34 -05:00
|
|
|
self.stack.push(&list[idx]);
|
2012-09-24 11:55:42 -05:00
|
|
|
f()
|
2012-09-07 20:53:14 -05:00
|
|
|
}
|
2013-02-11 21:26:38 -06:00
|
|
|
_ => fail!(~"not a list"),
|
2012-09-07 20:53:14 -05:00
|
|
|
}
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
2012-09-07 20:53:14 -05:00
|
|
|
|
2012-09-24 11:55:42 -05:00
|
|
|
fn read_rec<T>(&self, f: fn() -> T) -> T {
|
|
|
|
debug!("read_rec()");
|
|
|
|
let value = f();
|
|
|
|
self.pop();
|
2013-02-15 01:30:30 -06:00
|
|
|
value
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
2012-09-07 20:53:14 -05:00
|
|
|
|
2012-12-27 06:16:16 -06:00
|
|
|
fn read_struct<T>(&self, _name: &str, _len: uint, f: fn() -> T) -> T {
|
2012-09-26 23:35:13 -05:00
|
|
|
debug!("read_struct()");
|
|
|
|
let value = f();
|
|
|
|
self.pop();
|
2013-02-15 01:30:30 -06:00
|
|
|
value
|
2012-09-26 23:35:13 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn read_field<T>(&self, name: &str, idx: uint, f: fn() -> T) -> T {
|
|
|
|
debug!("read_rec_field(%s, idx=%u)", name, idx);
|
2012-09-24 11:55:42 -05:00
|
|
|
let top = self.peek();
|
|
|
|
match *top {
|
|
|
|
Object(ref obj) => {
|
2013-01-23 10:47:43 -06:00
|
|
|
match obj.find(&name.to_owned()) {
|
2013-02-11 21:26:38 -06:00
|
|
|
None => fail!(fmt!("no such field: %s", name)),
|
2012-09-24 11:55:42 -05:00
|
|
|
Some(json) => {
|
2012-09-26 19:33:34 -05:00
|
|
|
self.stack.push(json);
|
2012-09-24 11:55:42 -05:00
|
|
|
f()
|
2012-09-07 20:53:14 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-02-11 21:26:38 -06:00
|
|
|
Number(_) => fail!(~"num"),
|
|
|
|
String(_) => fail!(~"str"),
|
|
|
|
Boolean(_) => fail!(~"bool"),
|
|
|
|
List(_) => fail!(fmt!("list: %?", top)),
|
|
|
|
Null => fail!(~"null"),
|
2012-09-07 20:53:14 -05:00
|
|
|
|
2013-02-11 21:26:38 -06:00
|
|
|
//_ => fail!(fmt!("not an object: %?", *top))
|
2012-09-07 20:53:14 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-26 23:35:13 -05:00
|
|
|
fn read_tup<T>(&self, len: uint, f: fn() -> T) -> T {
|
|
|
|
debug!("read_tup(len=%u)", len);
|
2012-09-24 11:55:42 -05:00
|
|
|
let value = f();
|
|
|
|
self.pop();
|
2013-02-15 01:30:30 -06:00
|
|
|
value
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn read_tup_elt<T>(&self, idx: uint, f: fn() -> T) -> T {
|
|
|
|
debug!("read_tup_elt(idx=%u)", idx);
|
|
|
|
match *self.peek() {
|
2012-09-26 19:33:34 -05:00
|
|
|
List(ref list) => {
|
|
|
|
self.stack.push(&list[idx]);
|
2012-09-24 11:55:42 -05:00
|
|
|
f()
|
|
|
|
}
|
2013-02-11 21:26:38 -06:00
|
|
|
_ => fail!(~"not a list")
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl Eq for Json {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &Json) -> bool {
|
2013-01-10 22:09:16 -06:00
|
|
|
match (self) {
|
|
|
|
&Number(f0) =>
|
|
|
|
match other { &Number(f1) => f0 == f1, _ => false },
|
|
|
|
&String(ref s0) =>
|
|
|
|
match other { &String(ref s1) => s0 == s1, _ => false },
|
|
|
|
&Boolean(b0) =>
|
|
|
|
match other { &Boolean(b1) => b0 == b1, _ => false },
|
|
|
|
&Null =>
|
|
|
|
match other { &Null => true, _ => false },
|
|
|
|
&List(ref v0) =>
|
|
|
|
match other { &List(ref v1) => v0 == v1, _ => false },
|
|
|
|
&Object(ref d0) => {
|
|
|
|
match other {
|
|
|
|
&Object(ref d1) => {
|
2012-11-14 20:59:30 -06:00
|
|
|
if d0.len() == d1.len() {
|
|
|
|
let mut equal = true;
|
2013-02-07 20:03:13 -06:00
|
|
|
for d0.each |&(k, v0)| {
|
2013-01-23 10:47:43 -06:00
|
|
|
match d1.find(k) {
|
2012-11-14 20:59:30 -06:00
|
|
|
Some(v1) if v0 == v1 => { },
|
|
|
|
_ => { equal = false; break }
|
|
|
|
}
|
|
|
|
};
|
|
|
|
equal
|
|
|
|
} else {
|
|
|
|
false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-01-10 22:09:16 -06:00
|
|
|
pure fn ne(&self, other: &Json) -> bool { !self.eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2012-09-24 11:55:42 -05:00
|
|
|
/// Test if two json values are less than one another
|
2013-02-14 13:47:00 -06:00
|
|
|
impl Ord for Json {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn lt(&self, other: &Json) -> bool {
|
|
|
|
match (*self) {
|
|
|
|
Number(f0) => {
|
|
|
|
match *other {
|
|
|
|
Number(f1) => f0 < f1,
|
|
|
|
String(_) | Boolean(_) | List(_) | Object(_) |
|
|
|
|
Null => true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
String(ref s0) => {
|
|
|
|
match *other {
|
|
|
|
Number(_) => false,
|
|
|
|
String(ref s1) => s0 < s1,
|
|
|
|
Boolean(_) | List(_) | Object(_) | Null => true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Boolean(b0) => {
|
|
|
|
match *other {
|
|
|
|
Number(_) | String(_) => false,
|
|
|
|
Boolean(b1) => b0 < b1,
|
|
|
|
List(_) | Object(_) | Null => true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-07 21:34:57 -06:00
|
|
|
List(ref l0) => {
|
2012-11-14 20:59:30 -06:00
|
|
|
match *other {
|
|
|
|
Number(_) | String(_) | Boolean(_) => false,
|
2012-12-07 21:34:57 -06:00
|
|
|
List(ref l1) => (*l0) < (*l1),
|
2012-11-14 20:59:30 -06:00
|
|
|
Object(_) | Null => true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Object(ref d0) => {
|
|
|
|
match *other {
|
|
|
|
Number(_) | String(_) | Boolean(_) | List(_) => false,
|
|
|
|
Object(ref d1) => {
|
|
|
|
unsafe {
|
|
|
|
let mut d0_flat = ~[];
|
|
|
|
let mut d1_flat = ~[];
|
|
|
|
|
2013-01-10 22:09:16 -06:00
|
|
|
// FIXME #4430: this is horribly inefficient...
|
2013-02-07 20:03:13 -06:00
|
|
|
for d0.each |&(k, v)| {
|
2012-11-14 20:59:30 -06:00
|
|
|
d0_flat.push((@copy *k, @copy *v));
|
|
|
|
}
|
|
|
|
d0_flat.qsort();
|
|
|
|
|
2013-02-07 20:03:13 -06:00
|
|
|
for d1.each |&(k, v)| {
|
2012-11-14 20:59:30 -06:00
|
|
|
d1_flat.push((@copy *k, @copy *v));
|
|
|
|
}
|
|
|
|
d1_flat.qsort();
|
|
|
|
|
|
|
|
d0_flat < d1_flat
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Null => true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Null => {
|
|
|
|
match *other {
|
|
|
|
Number(_) | String(_) | Boolean(_) | List(_) |
|
|
|
|
Object(_) =>
|
|
|
|
false,
|
|
|
|
Null => true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pure fn le(&self, other: &Json) -> bool { !(*other).lt(&(*self)) }
|
|
|
|
pure fn ge(&self, other: &Json) -> bool { !(*self).lt(other) }
|
|
|
|
pure fn gt(&self, other: &Json) -> bool { (*other).lt(&(*self)) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-09-07 20:53:14 -05:00
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl Eq for Error {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &Error) -> bool {
|
|
|
|
(*self).line == other.line &&
|
|
|
|
(*self).col == other.col &&
|
|
|
|
(*self).msg == other.msg
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &Error) -> bool { !(*self).eq(other) }
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
|
|
|
|
2012-08-11 09:08:42 -05:00
|
|
|
trait ToJson { fn to_json() -> Json; }
|
2012-05-28 14:10:32 -05:00
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl ToJson for Json {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn to_json() -> Json { copy self }
|
2012-05-28 14:10:32 -05:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl ToJson for @Json {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn to_json() -> Json { (*self).to_json() }
|
2012-06-13 10:30:54 -05:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl ToJson for int {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn to_json() -> Json { Number(self as float) }
|
2012-06-13 10:30:54 -05:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl ToJson for i8 {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn to_json() -> Json { Number(self as float) }
|
2012-05-28 14:10:32 -05:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl ToJson for i16 {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn to_json() -> Json { Number(self as float) }
|
2012-05-28 14:10:32 -05:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl ToJson for i32 {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn to_json() -> Json { Number(self as float) }
|
2012-05-28 14:10:32 -05:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl ToJson for i64 {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn to_json() -> Json { Number(self as float) }
|
2012-05-28 14:10:32 -05:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl ToJson for uint {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn to_json() -> Json { Number(self as float) }
|
2012-06-13 10:30:54 -05:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl ToJson for u8 {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn to_json() -> Json { Number(self as float) }
|
2012-05-28 14:10:32 -05:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl ToJson for u16 {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn to_json() -> Json { Number(self as float) }
|
2012-05-28 14:10:32 -05:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl ToJson for u32 {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn to_json() -> Json { Number(self as float) }
|
2012-05-28 14:10:32 -05:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl ToJson for u64 {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn to_json() -> Json { Number(self as float) }
|
2012-05-28 14:10:32 -05:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl ToJson for float {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn to_json() -> Json { Number(self) }
|
2012-05-28 14:10:32 -05:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl ToJson for f32 {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn to_json() -> Json { Number(self as float) }
|
2012-05-28 14:10:32 -05:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl ToJson for f64 {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn to_json() -> Json { Number(self as float) }
|
2012-05-28 14:10:32 -05:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl ToJson for () {
|
2012-08-11 09:08:42 -05:00
|
|
|
fn to_json() -> Json { Null }
|
2012-05-28 14:10:32 -05:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl ToJson for bool {
|
2012-08-11 09:08:42 -05:00
|
|
|
fn to_json() -> Json { Boolean(self) }
|
2012-05-28 14:10:32 -05:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl ToJson for ~str {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn to_json() -> Json { String(copy self) }
|
2012-06-12 19:20:51 -05:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl ToJson for @~str {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn to_json() -> Json { String(copy *self) }
|
2012-05-28 14:10:32 -05:00
|
|
|
}
|
|
|
|
|
2013-02-20 19:07:17 -06:00
|
|
|
impl<A:ToJson,B:ToJson> ToJson for (A, B) {
|
2012-08-11 09:08:42 -05:00
|
|
|
fn to_json() -> Json {
|
2012-08-06 14:34:08 -05:00
|
|
|
match self {
|
2012-09-28 02:22:18 -05:00
|
|
|
(ref a, ref b) => {
|
2012-09-24 11:55:42 -05:00
|
|
|
List(~[a.to_json(), b.to_json()])
|
2012-08-02 17:42:56 -05:00
|
|
|
}
|
|
|
|
}
|
2012-05-28 14:10:32 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-20 19:07:17 -06:00
|
|
|
impl<A:ToJson,B:ToJson,C:ToJson> ToJson for (A, B, C) {
|
2012-08-11 09:08:42 -05:00
|
|
|
fn to_json() -> Json {
|
2012-08-06 14:34:08 -05:00
|
|
|
match self {
|
2012-09-28 02:22:18 -05:00
|
|
|
(ref a, ref b, ref c) => {
|
2012-09-24 11:55:42 -05:00
|
|
|
List(~[a.to_json(), b.to_json(), c.to_json()])
|
2012-08-02 17:42:56 -05:00
|
|
|
}
|
|
|
|
}
|
2012-05-28 14:10:32 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-20 19:07:17 -06:00
|
|
|
impl<A:ToJson> ToJson for ~[A] {
|
2012-09-24 11:55:42 -05:00
|
|
|
fn to_json() -> Json { List(self.map(|elt| elt.to_json())) }
|
2012-05-28 14:10:32 -05:00
|
|
|
}
|
|
|
|
|
2013-02-20 19:07:17 -06:00
|
|
|
impl<A:ToJson + Copy> ToJson for LinearMap<~str, A> {
|
2012-08-11 09:08:42 -05:00
|
|
|
fn to_json() -> Json {
|
2013-01-23 16:06:32 -06:00
|
|
|
let mut d = LinearMap::new();
|
2013-02-07 20:03:13 -06:00
|
|
|
for self.each |&(key, value)| {
|
2012-09-24 11:55:42 -05:00
|
|
|
d.insert(copy *key, value.to_json());
|
|
|
|
}
|
|
|
|
Object(~d)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-20 19:07:17 -06:00
|
|
|
impl<A:ToJson> ToJson for Option<A> {
|
2012-08-11 09:08:42 -05:00
|
|
|
fn to_json() -> Json {
|
2012-08-06 14:34:08 -05:00
|
|
|
match self {
|
2012-08-11 09:08:42 -05:00
|
|
|
None => Null,
|
2012-09-28 02:22:18 -05:00
|
|
|
Some(ref value) => value.to_json()
|
2012-05-28 14:10:32 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl to_str::ToStr for Json {
|
2013-02-03 22:47:26 -06:00
|
|
|
pure fn to_str(&self) -> ~str { to_str(self) }
|
2012-05-28 14:10:32 -05:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl to_str::ToStr for Error {
|
2013-02-03 22:47:26 -06:00
|
|
|
pure fn to_str(&self) -> ~str {
|
2012-08-22 19:24:52 -05:00
|
|
|
fmt!("%u:%u: %s", self.line, self.col, *self.msg)
|
2012-06-11 10:32:38 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-17 21:05:07 -06:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
2013-01-08 21:37:25 -06:00
|
|
|
use core::prelude::*;
|
|
|
|
|
|
|
|
use json::*;
|
|
|
|
|
2012-12-27 20:24:18 -06:00
|
|
|
use core::result;
|
2013-01-23 16:06:32 -06:00
|
|
|
use core::hashmap::linear::LinearMap;
|
2013-02-07 19:06:26 -06:00
|
|
|
use core::cmp;
|
|
|
|
|
2012-12-27 20:24:18 -06:00
|
|
|
|
2012-09-24 11:55:42 -05:00
|
|
|
fn mk_object(items: &[(~str, Json)]) -> Json {
|
2013-01-23 20:09:50 -06:00
|
|
|
let mut d = ~LinearMap::new();
|
2012-02-25 18:39:32 -06:00
|
|
|
|
2012-09-24 11:55:42 -05:00
|
|
|
for items.each |item| {
|
|
|
|
match *item {
|
2013-02-15 01:30:30 -06:00
|
|
|
(copy key, copy value) => { d.insert(key, value); },
|
2012-09-24 11:55:42 -05:00
|
|
|
}
|
2012-02-25 18:39:32 -06:00
|
|
|
};
|
|
|
|
|
2013-02-15 01:30:30 -06:00
|
|
|
Object(d)
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_write_null() {
|
2012-09-24 11:55:42 -05:00
|
|
|
assert to_str(&Null) == ~"null";
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2012-09-24 11:55:42 -05:00
|
|
|
fn test_write_number() {
|
|
|
|
assert to_str(&Number(3f)) == ~"3";
|
|
|
|
assert to_str(&Number(3.1f)) == ~"3.1";
|
|
|
|
assert to_str(&Number(-1.5f)) == ~"-1.5";
|
|
|
|
assert to_str(&Number(0.5f)) == ~"0.5";
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_write_str() {
|
2012-09-24 11:55:42 -05:00
|
|
|
assert to_str(&String(~"")) == ~"\"\"";
|
|
|
|
assert to_str(&String(~"foo")) == ~"\"foo\"";
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_write_bool() {
|
2012-09-24 11:55:42 -05:00
|
|
|
assert to_str(&Boolean(true)) == ~"true";
|
|
|
|
assert to_str(&Boolean(false)) == ~"false";
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_write_list() {
|
2012-09-24 11:55:42 -05:00
|
|
|
assert to_str(&List(~[])) == ~"[]";
|
|
|
|
assert to_str(&List(~[Boolean(true)])) == ~"[true]";
|
|
|
|
assert to_str(&List(~[
|
2012-08-11 09:08:42 -05:00
|
|
|
Boolean(false),
|
|
|
|
Null,
|
2012-09-24 11:55:42 -05:00
|
|
|
List(~[String(~"foo\nbar"), Number(3.5f)])
|
|
|
|
])) == ~"[false,null,[\"foo\\nbar\",3.5]]";
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2012-09-24 11:55:42 -05:00
|
|
|
fn test_write_object() {
|
|
|
|
assert to_str(&mk_object(~[])) == ~"{}";
|
|
|
|
assert to_str(&mk_object(~[(~"a", Boolean(true))]))
|
|
|
|
== ~"{\"a\":true}";
|
|
|
|
let a = mk_object(~[
|
2012-08-11 09:08:42 -05:00
|
|
|
(~"a", Boolean(true)),
|
2012-09-24 11:55:42 -05:00
|
|
|
(~"b", List(~[
|
|
|
|
mk_object(~[(~"c", String(~"\x0c\r"))]),
|
|
|
|
mk_object(~[(~"d", String(~""))])
|
2012-06-29 18:26:56 -05:00
|
|
|
]))
|
2012-08-30 18:27:15 -05:00
|
|
|
]);
|
2012-09-24 11:55:42 -05:00
|
|
|
// We can't compare the strings directly because the object fields be
|
|
|
|
// printed in a different order.
|
|
|
|
let b = result::unwrap(from_str(to_str(&a)));
|
2012-08-30 18:27:15 -05:00
|
|
|
assert a == b;
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
|
2013-02-07 19:06:26 -06:00
|
|
|
// two fns copied from libsyntax/util/testing.rs.
|
|
|
|
// Should they be in their own crate?
|
2013-02-20 19:07:17 -06:00
|
|
|
pub pure fn check_equal_ptr<T:cmp::Eq> (given : &T, expected: &T) {
|
2013-02-07 19:06:26 -06:00
|
|
|
if !((given == expected) && (expected == given )) {
|
2013-02-14 15:09:09 -06:00
|
|
|
fail!(fmt!("given %?, expected %?",given,expected));
|
2013-02-07 19:06:26 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-20 19:07:17 -06:00
|
|
|
pub pure fn check_equal<T:cmp::Eq> (given : T, expected: T) {
|
2013-02-07 19:06:26 -06:00
|
|
|
if !((given == expected) && (expected == given )) {
|
2013-02-14 15:09:09 -06:00
|
|
|
fail!(fmt!("given %?, expected %?",given,expected));
|
2013-02-07 19:06:26 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_write_enum () {
|
2013-02-14 07:51:01 -06:00
|
|
|
let bw = @io::BytesWriter();
|
2013-02-07 19:06:26 -06:00
|
|
|
let bww : @io::Writer = (bw as @io::Writer);
|
|
|
|
let encoder = (@Encoder(bww) as @serialize::Encoder);
|
|
|
|
do encoder.emit_enum(~"animal") {
|
|
|
|
do encoder.emit_enum_variant (~"frog",37,1242) {
|
|
|
|
// name of frog:
|
|
|
|
do encoder.emit_enum_variant_arg (0) {
|
|
|
|
encoder.emit_owned_str(~"Henry")
|
|
|
|
}
|
|
|
|
// mass of frog in grams:
|
|
|
|
do encoder.emit_enum_variant_arg (1) {
|
|
|
|
encoder.emit_int(349);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
check_equal(str::from_bytes(bw.bytes.data),
|
2013-02-08 17:36:40 -06:00
|
|
|
~"[\"frog\",[\"Henry\",349]]");
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_write_some () {
|
2013-02-14 07:51:01 -06:00
|
|
|
let bw = @io::BytesWriter();
|
2013-02-08 17:36:40 -06:00
|
|
|
let bww : @io::Writer = (bw as @io::Writer);
|
|
|
|
let encoder = (@Encoder(bww) as @serialize::Encoder);
|
|
|
|
do encoder.emit_enum(~"Option") {
|
|
|
|
do encoder.emit_enum_variant (~"Some",37,1242) {
|
|
|
|
do encoder.emit_enum_variant_arg (0) {
|
|
|
|
encoder.emit_owned_str(~"jodhpurs")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
check_equal(str::from_bytes(bw.bytes.data),
|
|
|
|
~"\"jodhpurs\"");
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_write_none () {
|
2013-02-14 07:51:01 -06:00
|
|
|
let bw = @io::BytesWriter();
|
2013-02-08 17:36:40 -06:00
|
|
|
let bww : @io::Writer = (bw as @io::Writer);
|
|
|
|
let encoder = (@Encoder(bww) as @serialize::Encoder);
|
|
|
|
do encoder.emit_enum(~"Option") {
|
|
|
|
do encoder.emit_enum_variant (~"None",37,1242) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
check_equal(str::from_bytes(bw.bytes.data),
|
|
|
|
~"null");
|
2013-02-07 19:06:26 -06:00
|
|
|
}
|
|
|
|
|
2012-01-17 21:05:07 -06:00
|
|
|
#[test]
|
2012-02-25 18:39:32 -06:00
|
|
|
fn test_trailing_characters() {
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"nulla") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 5u, msg: @~"trailing characters"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"truea") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 5u, msg: @~"trailing characters"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"falsea") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 6u, msg: @~"trailing characters"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"1a") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 2u, msg: @~"trailing characters"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"[]a") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 3u, msg: @~"trailing characters"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"{}a") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 3u, msg: @~"trailing characters"});
|
2012-02-25 18:39:32 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_read_identifiers() {
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"n") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"nul") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"});
|
2012-02-25 18:39:32 -06:00
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"t") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"truz") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"});
|
2012-02-25 18:39:32 -06:00
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"f") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"faz") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 3u, msg: @~"invalid syntax"});
|
2012-02-25 18:39:32 -06:00
|
|
|
|
2012-08-11 09:08:42 -05:00
|
|
|
assert from_str(~"null") == Ok(Null);
|
|
|
|
assert from_str(~"true") == Ok(Boolean(true));
|
|
|
|
assert from_str(~"false") == Ok(Boolean(false));
|
|
|
|
assert from_str(~" null ") == Ok(Null);
|
|
|
|
assert from_str(~" true ") == Ok(Boolean(true));
|
|
|
|
assert from_str(~" false ") == Ok(Boolean(false));
|
2012-01-17 21:05:07 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2012-09-24 11:55:42 -05:00
|
|
|
fn test_read_number() {
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"+") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 1u, msg: @~"invalid syntax"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~".") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 1u, msg: @~"invalid syntax"});
|
2012-07-14 00:57:48 -05:00
|
|
|
|
|
|
|
assert from_str(~"-") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 2u, msg: @~"invalid number"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"00") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 2u, msg: @~"invalid number"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"1.") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 3u, msg: @~"invalid number"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"1e") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 3u, msg: @~"invalid number"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"1e+") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 4u, msg: @~"invalid number"});
|
|
|
|
|
|
|
|
assert from_str(~"3") == Ok(Number(3f));
|
|
|
|
assert from_str(~"3.1") == Ok(Number(3.1f));
|
|
|
|
assert from_str(~"-1.2") == Ok(Number(-1.2f));
|
|
|
|
assert from_str(~"0.4") == Ok(Number(0.4f));
|
|
|
|
assert from_str(~"0.4e5") == Ok(Number(0.4e5f));
|
|
|
|
assert from_str(~"0.4e+15") == Ok(Number(0.4e15f));
|
|
|
|
assert from_str(~"0.4e-01") == Ok(Number(0.4e-01f));
|
|
|
|
assert from_str(~" 3 ") == Ok(Number(3f));
|
2012-01-17 21:05:07 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2012-02-25 18:39:32 -06:00
|
|
|
fn test_read_str() {
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"\"") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 2u, msg: @~"EOF while parsing string"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"\"lol") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 5u, msg: @~"EOF while parsing string"});
|
|
|
|
|
|
|
|
assert from_str(~"\"\"") == Ok(String(~""));
|
|
|
|
assert from_str(~"\"foo\"") == Ok(String(~"foo"));
|
|
|
|
assert from_str(~"\"\\\"\"") == Ok(String(~"\""));
|
|
|
|
assert from_str(~"\"\\b\"") == Ok(String(~"\x08"));
|
|
|
|
assert from_str(~"\"\\n\"") == Ok(String(~"\n"));
|
|
|
|
assert from_str(~"\"\\r\"") == Ok(String(~"\r"));
|
|
|
|
assert from_str(~"\"\\t\"") == Ok(String(~"\t"));
|
|
|
|
assert from_str(~" \"foo\" ") == Ok(String(~"foo"));
|
2012-01-17 21:05:07 -06:00
|
|
|
}
|
|
|
|
|
2012-08-30 23:03:19 -05:00
|
|
|
#[test]
|
|
|
|
fn test_unicode_hex_escapes_in_str() {
|
2012-09-24 11:55:42 -05:00
|
|
|
assert from_str(~"\"\\u12ab\"") == Ok(String(~"\u12ab"));
|
|
|
|
assert from_str(~"\"\\uAB12\"") == Ok(String(~"\uAB12"));
|
2012-08-30 23:03:19 -05:00
|
|
|
}
|
|
|
|
|
2012-01-17 21:05:07 -06:00
|
|
|
#[test]
|
2012-02-25 18:39:32 -06:00
|
|
|
fn test_read_list() {
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"[") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 2u, msg: @~"EOF while parsing value"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"[1") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 3u, msg: @~"EOF while parsing list"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"[1,") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 4u, msg: @~"EOF while parsing value"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"[1,]") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"[6 7]") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 4u, msg: @~"expected `,` or `]`"});
|
|
|
|
|
|
|
|
assert from_str(~"[]") == Ok(List(~[]));
|
|
|
|
assert from_str(~"[ ]") == Ok(List(~[]));
|
|
|
|
assert from_str(~"[true]") == Ok(List(~[Boolean(true)]));
|
|
|
|
assert from_str(~"[ false ]") == Ok(List(~[Boolean(false)]));
|
|
|
|
assert from_str(~"[null]") == Ok(List(~[Null]));
|
|
|
|
assert from_str(~"[3, 1]") == Ok(List(~[Number(3f), Number(1f)]));
|
|
|
|
assert from_str(~"\n[3, 2]\n") == Ok(List(~[Number(3f), Number(2f)]));
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"[2, [4, 1]]") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Ok(List(~[Number(2f), List(~[Number(4f), Number(1f)])]));
|
2012-01-17 21:05:07 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2012-09-24 11:55:42 -05:00
|
|
|
fn test_read_object() {
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"{") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 2u, msg: @~"EOF while parsing object"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"{ ") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 3u, msg: @~"EOF while parsing object"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"{1") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 2u, msg: @~"key must be a string"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"{ \"a\"") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 6u, msg: @~"EOF while parsing object"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"{\"a\"") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 5u, msg: @~"EOF while parsing object"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"{\"a\" ") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 6u, msg: @~"EOF while parsing object"});
|
2012-07-14 00:57:48 -05:00
|
|
|
|
|
|
|
assert from_str(~"{\"a\" 1") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 6u, msg: @~"expected `:`"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"{\"a\":") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 6u, msg: @~"EOF while parsing value"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"{\"a\":1") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 7u, msg: @~"EOF while parsing object"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"{\"a\":1 1") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 8u, msg: @~"expected `,` or `}`"});
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"{\"a\":1,") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 1u, col: 8u, msg: @~"EOF while parsing object"});
|
2012-07-14 00:57:48 -05:00
|
|
|
|
2012-09-24 11:55:42 -05:00
|
|
|
assert result::unwrap(from_str(~"{}")) == mk_object(~[]);
|
|
|
|
assert result::unwrap(from_str(~"{\"a\": 3}")) ==
|
|
|
|
mk_object(~[(~"a", Number(3.0f))]);
|
2012-07-14 00:57:48 -05:00
|
|
|
|
2012-09-24 11:55:42 -05:00
|
|
|
assert result::unwrap(from_str(~"{ \"a\": null, \"b\" : true }")) ==
|
|
|
|
mk_object(~[
|
2012-08-11 09:08:42 -05:00
|
|
|
(~"a", Null),
|
2012-09-24 11:55:42 -05:00
|
|
|
(~"b", Boolean(true))]);
|
|
|
|
assert result::unwrap(
|
|
|
|
from_str(~"\n{ \"a\": null, \"b\" : true }\n")) ==
|
|
|
|
mk_object(~[
|
2012-08-11 09:08:42 -05:00
|
|
|
(~"a", Null),
|
2012-09-24 11:55:42 -05:00
|
|
|
(~"b", Boolean(true))]);
|
|
|
|
assert result::unwrap(from_str(~"{\"a\" : 1.0 ,\"b\": [ true ]}")) ==
|
|
|
|
mk_object(~[
|
|
|
|
(~"a", Number(1.0)),
|
|
|
|
(~"b", List(~[Boolean(true)]))
|
|
|
|
]);
|
|
|
|
assert result::unwrap(from_str(
|
2012-07-14 00:57:48 -05:00
|
|
|
~"{" +
|
|
|
|
~"\"a\": 1.0, " +
|
|
|
|
~"\"b\": [" +
|
|
|
|
~"true," +
|
|
|
|
~"\"foo\\nbar\", " +
|
|
|
|
~"{ \"c\": {\"d\": null} } " +
|
|
|
|
~"]" +
|
2012-09-24 11:55:42 -05:00
|
|
|
~"}")) ==
|
|
|
|
mk_object(~[
|
|
|
|
(~"a", Number(1.0f)),
|
|
|
|
(~"b", List(~[
|
2012-08-11 09:08:42 -05:00
|
|
|
Boolean(true),
|
2012-09-24 11:55:42 -05:00
|
|
|
String(~"foo\nbar"),
|
|
|
|
mk_object(~[
|
|
|
|
(~"c", mk_object(~[(~"d", Null)]))
|
2012-06-29 18:26:56 -05:00
|
|
|
])
|
|
|
|
]))
|
2012-09-24 11:55:42 -05:00
|
|
|
]);
|
2012-01-17 21:05:07 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2012-02-25 18:39:32 -06:00
|
|
|
fn test_multiline_errors() {
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"{\n \"foo\":\n \"bar\"") ==
|
2012-09-24 11:55:42 -05:00
|
|
|
Err(Error {line: 3u, col: 8u, msg: @~"EOF while parsing object"});
|
2012-01-17 21:05:07 -06:00
|
|
|
}
|
|
|
|
}
|