From bdf81e11841da74277e873b9f3ef5bc2105700be Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Thu, 28 Mar 2013 08:46:08 -0700 Subject: [PATCH 01/18] core: Inline mallocing wrapper functions As far as I can tell, this doesn't make rust compile any faster, but it does at least remove one level of indirection on malloc, which might help speed up some operations. --- src/libcore/unstable/lang.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/libcore/unstable/lang.rs b/src/libcore/unstable/lang.rs index 554083fcdb53b..ff96029bc0e31 100644 --- a/src/libcore/unstable/lang.rs +++ b/src/libcore/unstable/lang.rs @@ -64,6 +64,7 @@ pub unsafe fn fail_borrowed() { // FIXME #4942: Make these signatures agree with exchange_alloc's signatures #[lang="exchange_malloc"] +#[inline(always)] pub unsafe fn exchange_malloc(td: *c_char, size: uintptr_t) -> *c_char { transmute(exchange_alloc::malloc(transmute(td), transmute(size))) } @@ -72,11 +73,13 @@ pub unsafe fn exchange_malloc(td: *c_char, size: uintptr_t) -> *c_char { // inside a landing pad may corrupt the state of the exception handler. If a // problem occurs, call exit instead. #[lang="exchange_free"] +#[inline(always)] pub unsafe fn exchange_free(ptr: *c_char) { exchange_alloc::free(transmute(ptr)) } #[lang="malloc"] +#[inline(always)] pub unsafe fn local_malloc(td: *c_char, size: uintptr_t) -> *c_char { return rustrt::rust_upcall_malloc(td, size); } @@ -85,6 +88,7 @@ pub unsafe fn local_malloc(td: *c_char, size: uintptr_t) -> *c_char { // inside a landing pad may corrupt the state of the exception handler. If a // problem occurs, call exit instead. #[lang="free"] +#[inline(always)] pub unsafe fn local_free(ptr: *c_char) { rustrt::rust_upcall_free(ptr); } @@ -117,6 +121,7 @@ pub unsafe fn check_not_borrowed(a: *u8) { } #[lang="strdup_uniq"] +#[inline(always)] pub unsafe fn strdup_uniq(ptr: *c_uchar, len: uint) -> ~str { str::raw::from_buf_len(ptr, len) } From b05e148dc954d7c1fb4666d4529653993a93eb1d Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Thu, 28 Mar 2013 13:11:14 -0700 Subject: [PATCH 02/18] std: change Decoder::read_option to return a generic type This allows read_option to be used with a custom option type instead of just core::Option. --- src/libstd/ebml.rs | 12 ++++++------ src/libstd/json.rs | 6 +++--- src/libstd/serialize.rs | 10 ++++++++-- 3 files changed, 17 insertions(+), 11 deletions(-) diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 5855add7975ca..331bede5b7af3 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -411,13 +411,13 @@ pub mod reader { } #[cfg(stage0)] - fn read_option(&self, f: &fn() -> T) -> Option { + fn read_option(&self, f: &fn(bool) -> T) -> T { debug!("read_option()"); do self.read_enum("Option") || { do self.read_enum_variant |idx| { match idx { - 0 => None, - 1 => Some(f()), + 0 => f(false), + 1 => f(true), _ => fail!(), } } @@ -427,13 +427,13 @@ pub mod reader { #[cfg(stage1)] #[cfg(stage2)] #[cfg(stage3)] - fn read_option(&self, f: &fn() -> T) -> Option { + fn read_option(&self, f: &fn(bool) -> T) -> T { debug!("read_option()"); do self.read_enum("Option") || { do self.read_enum_variant(["None", "Some"]) |idx| { match idx { - 0 => None, - 1 => Some(f()), + 0 => f(false), + 1 => f(true), _ => fail!(), } } diff --git a/src/libstd/json.rs b/src/libstd/json.rs index c48b210dca219..4b0e313330d24 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -980,10 +980,10 @@ impl<'self> serialize::Decoder for Decoder<'self> { } } - fn read_option(&self, f: &fn() -> T) -> Option { + fn read_option(&self, f: &fn(bool) -> T) -> T { match *self.peek() { - Null => { self.pop(); None } - _ => Some(f()), + Null => { self.pop(); f(false) } + _ => f(true), } } } diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs index 02f4a93487432..3c9ad0d77d1e0 100644 --- a/src/libstd/serialize.rs +++ b/src/libstd/serialize.rs @@ -118,7 +118,7 @@ pub trait Decoder { fn read_tup_elt(&self, idx: uint, f: &fn() -> T) -> T; // Specialized types: - fn read_option(&self, f: &fn() -> T) -> Option; + fn read_option(&self, f: &fn(bool) -> T) -> T; } pub trait Encodable { @@ -395,7 +395,13 @@ impl> Encodable for Option { impl> Decodable for Option { fn decode(d: &D) -> Option { - d.read_option(|| Decodable::decode(d)) + do d.read_option |b| { + if b { + Some(Decodable::decode(d)) + } else { + None + } + } } } From 2c658fabedcb4d8ca0d8c6e95184bc4ec0ae45aa Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Thu, 28 Mar 2013 19:31:19 -0700 Subject: [PATCH 03/18] std: remove prettyprint Everyone uses fmt!("%?", ...) instead of the prettyprint module, so I'm removing this file. --- src/libstd/prettyprint.rs | 199 ------------------------------- src/libstd/std.rc | 1 - src/test/run-pass/auto-encode.rs | 21 ---- 3 files changed, 221 deletions(-) delete mode 100644 src/libstd/prettyprint.rs diff --git a/src/libstd/prettyprint.rs b/src/libstd/prettyprint.rs deleted file mode 100644 index ed4f3e957c02a..0000000000000 --- a/src/libstd/prettyprint.rs +++ /dev/null @@ -1,199 +0,0 @@ -// 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 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -use serialize; - -use core::io::WriterUtil; -use core::io; - -pub struct Serializer { - wr: @io::Writer, -} - -pub fn Serializer(wr: @io::Writer) -> Serializer { - Serializer { wr: wr } -} - -impl serialize::Encoder for Serializer { - fn emit_nil(&self) { - self.wr.write_str(~"()") - } - - fn emit_uint(&self, v: uint) { - self.wr.write_str(fmt!("%?u", v)); - } - - fn emit_u64(&self, v: u64) { - self.wr.write_str(fmt!("%?_u64", v)); - } - - fn emit_u32(&self, v: u32) { - self.wr.write_str(fmt!("%?_u32", v)); - } - - fn emit_u16(&self, v: u16) { - self.wr.write_str(fmt!("%?_u16", v)); - } - - fn emit_u8(&self, v: u8) { - self.wr.write_str(fmt!("%?_u8", v)); - } - - fn emit_int(&self, v: int) { - self.wr.write_str(fmt!("%?", v)); - } - - fn emit_i64(&self, v: i64) { - self.wr.write_str(fmt!("%?_i64", v)); - } - - fn emit_i32(&self, v: i32) { - self.wr.write_str(fmt!("%?_i32", v)); - } - - fn emit_i16(&self, v: i16) { - self.wr.write_str(fmt!("%?_i16", v)); - } - - fn emit_i8(&self, v: i8) { - self.wr.write_str(fmt!("%?_i8", v)); - } - - fn emit_bool(&self, v: bool) { - self.wr.write_str(fmt!("%b", v)); - } - - fn emit_float(&self, v: float) { - self.wr.write_str(fmt!("%?_f", v)); - } - - fn emit_f64(&self, v: f64) { - self.wr.write_str(fmt!("%?_f64", v)); - } - - fn emit_f32(&self, v: f32) { - self.wr.write_str(fmt!("%?_f32", v)); - } - - fn emit_char(&self, v: char) { - self.wr.write_str(fmt!("%?", v)); - } - - fn emit_borrowed_str(&self, v: &str) { - self.wr.write_str(fmt!("&%?", v)); - } - - fn emit_owned_str(&self, v: &str) { - self.wr.write_str(fmt!("~%?", v)); - } - - fn emit_managed_str(&self, v: &str) { - self.wr.write_str(fmt!("@%?", v)); - } - - fn emit_borrowed(&self, f: &fn()) { - self.wr.write_str(~"&"); - f(); - } - - fn emit_owned(&self, f: &fn()) { - self.wr.write_str(~"~"); - f(); - } - - fn emit_managed(&self, f: &fn()) { - self.wr.write_str(~"@"); - f(); - } - - fn emit_enum(&self, _name: &str, f: &fn()) { - f(); - } - - fn emit_enum_variant(&self, v_name: &str, _v_id: uint, sz: uint, - f: &fn()) { - self.wr.write_str(v_name); - if sz > 0u { self.wr.write_str(~"("); } - f(); - if sz > 0u { self.wr.write_str(~")"); } - } - - fn emit_enum_variant_arg(&self, idx: uint, f: &fn()) { - if idx > 0u { self.wr.write_str(~", "); } - f(); - } - - fn emit_borrowed_vec(&self, _len: uint, f: &fn()) { - self.wr.write_str(~"&["); - f(); - self.wr.write_str(~"]"); - } - - fn emit_owned_vec(&self, _len: uint, f: &fn()) { - self.wr.write_str(~"~["); - f(); - self.wr.write_str(~"]"); - } - - fn emit_managed_vec(&self, _len: uint, f: &fn()) { - self.wr.write_str(~"@["); - f(); - self.wr.write_str(~"]"); - } - - fn emit_vec_elt(&self, idx: uint, f: &fn()) { - if idx > 0u { self.wr.write_str(~", "); } - f(); - } - - fn emit_rec(&self, f: &fn()) { - self.wr.write_str(~"{"); - f(); - self.wr.write_str(~"}"); - } - - fn emit_struct(&self, name: &str, _len: uint, f: &fn()) { - self.wr.write_str(fmt!("%s {", name)); - f(); - self.wr.write_str(~"}"); - } - - fn emit_field(&self, name: &str, idx: uint, f: &fn()) { - if idx > 0u { self.wr.write_str(~", "); } - self.wr.write_str(name); - self.wr.write_str(~": "); - f(); - } - - fn emit_tup(&self, _len: uint, f: &fn()) { - self.wr.write_str(~"("); - f(); - self.wr.write_str(~")"); - } - - fn emit_tup_elt(&self, idx: uint, f: &fn()) { - if idx > 0u { self.wr.write_str(~", "); } - f(); - } - - fn emit_option(&self, f: &fn()) { - f(); - } - - fn emit_option_none(&self) { - self.wr.write_str("None"); - } - - fn emit_option_some(&self, f: &fn()) { - self.wr.write_str("Some("); - f(); - self.wr.write_char(')'); - } -} diff --git a/src/libstd/std.rc b/src/libstd/std.rc index a0ab714de05f8..b28e2f0ab6df1 100644 --- a/src/libstd/std.rc +++ b/src/libstd/std.rc @@ -88,7 +88,6 @@ pub mod md4; pub mod tempfile; pub mod term; pub mod time; -pub mod prettyprint; pub mod arena; pub mod par; pub mod cmp; diff --git a/src/test/run-pass/auto-encode.rs b/src/test/run-pass/auto-encode.rs index 1a8ad446c7954..137213d815f6b 100644 --- a/src/test/run-pass/auto-encode.rs +++ b/src/test/run-pass/auto-encode.rs @@ -22,21 +22,9 @@ use EBWriter = std::ebml::writer; use core::cmp::Eq; use core::io::Writer; use std::ebml; -use std::prettyprint; use std::serialize::{Encodable, Decodable}; use std::time; -fn test_prettyprint>( - a: &A, - expected: &~str -) { - let s = do io::with_str_writer |w| { - a.encode(&prettyprint::Serializer(w)) - }; - debug!("s == %?", s); - fail_unless!(s == *expected); -} - fn test_ebml + @@ -149,36 +137,27 @@ enum CLike { A, B, C } pub fn main() { let a = &Plus(@Minus(@Val(3u), @Val(10u)), @Plus(@Val(22u), @Val(5u))); - test_prettyprint(a, &~"Plus(@Minus(@Val(3u), @Val(10u)), \ - @Plus(@Val(22u), @Val(5u)))"); test_ebml(a); let a = &Spanned {lo: 0u, hi: 5u, node: 22u}; - test_prettyprint(a, &~"Spanned {lo: 0u, hi: 5u, node: 22u}"); test_ebml(a); let a = &Point {x: 3u, y: 5u}; - test_prettyprint(a, &~"Point {x: 3u, y: 5u}"); test_ebml(a); let a = &@[1u, 2u, 3u]; - test_prettyprint(a, &~"@[1u, 2u, 3u]"); test_ebml(a); let a = &Top(22u); - test_prettyprint(a, &~"Top(22u)"); test_ebml(a); let a = &Bottom(222u); - test_prettyprint(a, &~"Bottom(222u)"); test_ebml(a); let a = &A; - test_prettyprint(a, &~"A"); test_ebml(a); let a = &B; - test_prettyprint(a, &~"B"); test_ebml(a); let a = &time::now(); From 1dd11c717922fb38e87644606f9fbc9d29ee4995 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Thu, 28 Mar 2013 20:30:50 -0700 Subject: [PATCH 04/18] core: add LinearMap::with_capacity --- src/libcore/hashmap.rs | 20 +++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-) diff --git a/src/libcore/hashmap.rs b/src/libcore/hashmap.rs index 472de88f692b8..d6684b04aa373 100644 --- a/src/libcore/hashmap.rs +++ b/src/libcore/hashmap.rs @@ -393,10 +393,16 @@ pub mod linear { } } - pub impl LinearMap { + pub impl LinearMap { /// Create an empty LinearMap fn new() -> LinearMap { - linear_map_with_capacity(INITIAL_CAPACITY) + LinearMap::with_capacity(INITIAL_CAPACITY) + } + + /// Create an empty LinearMap with space for at least `n` elements in + /// the hash table. + fn with_capacity(capacity: uint) -> LinearMap { + linear_map_with_capacity(capacity) } /// Reserve space for at least `n` elements in the hash table. @@ -652,7 +658,15 @@ pub mod linear { pub impl LinearSet { /// Create an empty LinearSet - fn new() -> LinearSet { LinearSet{map: LinearMap::new()} } + fn new() -> LinearSet { + LinearSet::with_capacity(INITIAL_CAPACITY) + } + + /// Create an empty LinearSet with space for at least `n` elements in + /// the hash table. + fn with_capacity(capacity: uint) -> LinearSet { + LinearSet { map: LinearMap::with_capacity(capacity) } + } /// Reserve space for at least `n` elements in the hash table. fn reserve_at_least(&mut self, n: uint) { From 8b43c620b971bc3cbae61ca8390ec34355add445 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Thu, 28 Mar 2013 20:51:05 -0700 Subject: [PATCH 05/18] std: remove Encoder::emit_{owned,managed}_str and Decoder::read_{owned,managed}_str --- src/libstd/ebml.rs | 15 ++--------- src/libstd/json.rs | 46 ++++++-------------------------- src/libstd/serialize.rs | 22 +++++---------- src/libsyntax/ast.rs | 4 +-- src/libsyntax/ext/auto_encode.rs | 5 +--- 5 files changed, 20 insertions(+), 72 deletions(-) diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 331bede5b7af3..513897997a52c 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -311,11 +311,8 @@ pub mod reader { fn read_f64(&self) -> f64 { fail!(~"read_f64()"); } fn read_f32(&self) -> f32 { fail!(~"read_f32()"); } fn read_float(&self) -> float { fail!(~"read_float()"); } - fn read_char(&self) -> char { fail!(~"read_char()"); } - - fn read_owned_str(&self) -> ~str { doc_as_str(self.next_doc(EsStr)) } - fn read_managed_str(&self) -> @str { fail!(~"read_managed_str()"); } + fn read_str(&self) -> ~str { doc_as_str(self.next_doc(EsStr)) } // Compound types: fn read_owned(&self, f: &fn() -> T) -> T { @@ -650,18 +647,10 @@ pub mod writer { fail!(~"Unimplemented: serializing a char"); } - fn emit_borrowed_str(&self, v: &str) { + fn emit_str(&self, v: &str) { self.wr_tagged_str(EsStr as uint, 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() } diff --git a/src/libstd/json.rs b/src/libstd/json.rs index 4b0e313330d24..373131e9e655c 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -105,20 +105,14 @@ impl serialize::Encoder for Encoder { self.wr.write_str(float::to_str_digits(v, 6u)); } - 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_char(&self, v: char) { self.emit_str(str::from_char(v)) } + fn emit_str(&self, v: &str) { self.wr.write_str(escape_str(v)) } fn emit_borrowed(&self, f: &fn()) { f() } fn emit_owned(&self, f: &fn()) { f() } fn emit_managed(&self, f: &fn()) { f() } - fn emit_enum(&self, _name: &str, f: &fn()) { - f() - } - + fn emit_enum(&self, _name: &str, f: &fn()) { f() } fn emit_enum_variant(&self, name: &str, _id: uint, cnt: uint, f: &fn()) { // enums are encoded as strings or vectors: // Bunny => "Bunny" @@ -224,15 +218,8 @@ impl serialize::Encoder for PrettyEncoder { self.wr.write_str(float::to_str_digits(v, 6u)); } - 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() } + fn emit_char(&self, v: char) { self.emit_str(str::from_char(v)) } + fn emit_str(&self, v: &str) { self.wr.write_str(escape_str(v)); } fn emit_enum(&self, _name: &str, f: &fn()) { f() } fn emit_enum_variant(&self, name: &str, _id: uint, cnt: uint, f: &fn()) { @@ -818,36 +805,19 @@ impl<'self> serialize::Decoder for Decoder<'self> { fn read_char(&self) -> char { let mut v = ~[]; - for str::each_char(self.read_owned_str()) |c| { v.push(c) } + for str::each_char(self.read_str()) |c| { v.push(c) } if v.len() != 1 { fail!(~"string must have one character") } v[0] } - fn read_owned_str(&self) -> ~str { - debug!("read_owned_str"); + fn read_str(&self) -> ~str { + debug!("read_str"); match *self.pop() { String(ref s) => copy *s, ref json => fail!(fmt!("not a string: %?", *json)) } } - fn read_managed_str(&self) -> @str { - debug!("read_managed_str"); - match *self.pop() { - String(ref s) => s.to_managed(), - ref json => fail!(fmt!("not a string: %?", *json)) - } - } - - fn read_owned(&self, f: &fn() -> T) -> T { - debug!("read_owned()"); - f() - } - - fn read_managed(&self, f: &fn() -> T) -> T { - debug!("read_managed()"); - f() - } fn read_enum(&self, name: &str, f: &fn() -> T) -> T { debug!("read_enum(%s)", name); diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs index 3c9ad0d77d1e0..daf834dad2ed8 100644 --- a/src/libstd/serialize.rs +++ b/src/libstd/serialize.rs @@ -38,9 +38,7 @@ pub trait Encoder { fn emit_f64(&self, v: f64); fn emit_f32(&self, v: f32); fn emit_char(&self, v: char); - fn emit_borrowed_str(&self, v: &str); - fn emit_owned_str(&self, v: &str); - fn emit_managed_str(&self, v: &str); + fn emit_str(&self, v: &str); // Compound types: fn emit_borrowed(&self, f: &fn()); @@ -87,20 +85,16 @@ pub trait Decoder { fn read_f32(&self) -> f32; fn read_float(&self) -> float; fn read_char(&self) -> char; - fn read_owned_str(&self) -> ~str; - fn read_managed_str(&self) -> @str; + fn read_str(&self) -> ~str; // Compound types: fn read_enum(&self, name: &str, f: &fn() -> T) -> T; - #[cfg(stage0)] fn read_enum_variant(&self, f: &fn(uint) -> T) -> T; - #[cfg(stage1)] #[cfg(stage2)] #[cfg(stage3)] fn read_enum_variant(&self, names: &[&str], f: &fn(uint) -> T) -> T; - fn read_enum_variant_arg(&self, idx: uint, f: &fn() -> T) -> T; fn read_owned(&self, f: &fn() -> T) -> T; @@ -230,27 +224,25 @@ impl Decodable for i64 { } impl<'self, S:Encoder> Encodable for &'self str { - fn encode(&self, s: &S) { s.emit_borrowed_str(*self) } + fn encode(&self, s: &S) { s.emit_str(*self) } } impl Encodable for ~str { - fn encode(&self, s: &S) { s.emit_owned_str(*self) } + fn encode(&self, s: &S) { s.emit_str(*self) } } impl Decodable for ~str { fn decode(d: &D) -> ~str { - d.read_owned_str() + d.read_str() } } impl Encodable for @str { - fn encode(&self, s: &S) { s.emit_managed_str(*self) } + fn encode(&self, s: &S) { s.emit_str(*self) } } impl Decodable for @str { - fn decode(d: &D) -> @str { - d.read_managed_str() - } + fn decode(d: &D) -> @str { d.read_str().to_managed() } } impl Encodable for float { diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index c2f098f3c3ec4..78debbba31ce2 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -70,7 +70,7 @@ impl Encodable for ident { Some(intr) => intr }; - s.emit_owned_str(*(*intr).get(*self)); + s.emit_str(*(*intr).get(*self)); } } @@ -83,7 +83,7 @@ impl Decodable for ident { Some(intr) => intr }; - (*intr).intern(@d.read_owned_str()) + (*intr).intern(@d.read_str()) } } diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs index d7e0e9aa55014..54f9967e64a4e 100644 --- a/src/libsyntax/ext/auto_encode.rs +++ b/src/libsyntax/ext/auto_encode.rs @@ -1240,10 +1240,7 @@ mod test { fn emit_float(&self, +_v: float) { self.add_unknown_to_log(); } fn emit_char(&self, +_v: char) { self.add_unknown_to_log(); } - - fn emit_borrowed_str(&self, +_v: &str) { self.add_unknown_to_log(); } - fn emit_owned_str(&self, +_v: &str) { self.add_unknown_to_log(); } - fn emit_managed_str(&self, +_v: &str) { self.add_unknown_to_log(); } + fn emit_str(&self, +_v: &str) { self.add_unknown_to_log(); } fn emit_borrowed(&self, f: &fn()) { self.add_unknown_to_log(); f() } fn emit_owned(&self, f: &fn()) { self.add_unknown_to_log(); f() } From 63fc88757f9742b763114deac75962cb897b8218 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Thu, 28 Mar 2013 20:51:40 -0700 Subject: [PATCH 06/18] std: remove Encoder::emit_{owned,managed} and Decoder::read_{owned,managed} --- src/libstd/ebml.rs | 14 -------------- src/libstd/json.rs | 4 ---- src/libstd/serialize.rs | 16 +++++----------- src/libsyntax/ext/auto_encode.rs | 4 ---- 4 files changed, 5 insertions(+), 33 deletions(-) diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 513897997a52c..fccb707ed1f3f 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -315,16 +315,6 @@ pub mod reader { fn read_str(&self) -> ~str { doc_as_str(self.next_doc(EsStr)) } // Compound types: - fn read_owned(&self, f: &fn() -> T) -> T { - debug!("read_owned()"); - f() - } - - fn read_managed(&self, f: &fn() -> T) -> T { - debug!("read_managed()"); - f() - } - fn read_enum(&self, name: &str, f: &fn() -> T) -> T { debug!("read_enum(%s)", name); self._check_label(name); @@ -651,10 +641,6 @@ pub mod writer { self.wr_tagged_str(EsStr as uint, v) } - fn emit_borrowed(&self, f: &fn()) { f() } - fn emit_owned(&self, f: &fn()) { f() } - fn emit_managed(&self, f: &fn()) { f() } - fn emit_enum(&self, name: &str, f: &fn()) { self._emit_label(name); self.wr_tag(EsEnum as uint, f) diff --git a/src/libstd/json.rs b/src/libstd/json.rs index 373131e9e655c..c936f8e4dcdba 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -108,10 +108,6 @@ impl serialize::Encoder for Encoder { fn emit_char(&self, v: char) { self.emit_str(str::from_char(v)) } fn emit_str(&self, v: &str) { self.wr.write_str(escape_str(v)) } - fn emit_borrowed(&self, f: &fn()) { f() } - fn emit_owned(&self, f: &fn()) { f() } - fn emit_managed(&self, f: &fn()) { f() } - fn emit_enum(&self, _name: &str, f: &fn()) { f() } fn emit_enum_variant(&self, name: &str, _id: uint, cnt: uint, f: &fn()) { // enums are encoded as strings or vectors: diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs index daf834dad2ed8..42a9e24b1cbd6 100644 --- a/src/libstd/serialize.rs +++ b/src/libstd/serialize.rs @@ -41,9 +41,6 @@ pub trait Encoder { fn emit_str(&self, v: &str); // Compound types: - fn emit_borrowed(&self, f: &fn()); - fn emit_owned(&self, f: &fn()); - fn emit_managed(&self, f: &fn()); fn emit_enum(&self, name: &str, f: &fn()); fn emit_enum_variant(&self, v_name: &str, v_id: uint, sz: uint, f: &fn()); @@ -97,9 +94,6 @@ pub trait Decoder { fn read_enum_variant(&self, names: &[&str], f: &fn(uint) -> T) -> T; fn read_enum_variant_arg(&self, idx: uint, f: &fn() -> T) -> T; - fn read_owned(&self, f: &fn() -> T) -> T; - fn read_managed(&self, f: &fn() -> T) -> T; - fn read_owned_vec(&self, f: &fn(uint) -> T) -> T; fn read_managed_vec(&self, f: &fn(uint) -> T) -> T; fn read_vec_elt(&self, idx: uint, f: &fn() -> T) -> T; @@ -296,31 +290,31 @@ impl Decodable for () { impl<'self, S:Encoder,T:Encodable> Encodable for &'self T { fn encode(&self, s: &S) { - s.emit_borrowed(|| (**self).encode(s)) + (**self).encode(s) } } impl> Encodable for ~T { fn encode(&self, s: &S) { - s.emit_owned(|| (**self).encode(s)) + (**self).encode(s) } } impl> Decodable for ~T { fn decode(d: &D) -> ~T { - d.read_owned(|| ~Decodable::decode(d)) + ~Decodable::decode(d) } } impl> Encodable for @T { fn encode(&self, s: &S) { - s.emit_managed(|| (**self).encode(s)) + (**self).encode(s) } } impl> Decodable for @T { fn decode(d: &D) -> @T { - d.read_managed(|| @Decodable::decode(d)) + @Decodable::decode(d) } } diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs index 54f9967e64a4e..c9357c9d86729 100644 --- a/src/libsyntax/ext/auto_encode.rs +++ b/src/libsyntax/ext/auto_encode.rs @@ -1242,10 +1242,6 @@ mod test { fn emit_char(&self, +_v: char) { self.add_unknown_to_log(); } fn emit_str(&self, +_v: &str) { self.add_unknown_to_log(); } - fn emit_borrowed(&self, f: &fn()) { self.add_unknown_to_log(); f() } - fn emit_owned(&self, f: &fn()) { self.add_unknown_to_log(); f() } - fn emit_managed(&self, f: &fn()) { self.add_unknown_to_log(); f() } - fn emit_enum(&self, name: &str, f: &fn()) { self.add_to_log(CallToEmitEnum(name.to_str())); f(); } From 590bbcebe9401293e642c89a6a623f5461b96dde Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Thu, 28 Mar 2013 21:34:47 -0700 Subject: [PATCH 07/18] std: remove Encoder::emit_{owned,managed}_vec and Decoder::read_{owned,managed}_vec --- src/libstd/ebml.rs | 29 ++------ src/libstd/json.rs | 47 ++++--------- src/libstd/serialize.rs | 115 ++++++++++++++++--------------- src/libsyntax/ext/auto_encode.rs | 11 +-- 4 files changed, 78 insertions(+), 124 deletions(-) diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index fccb707ed1f3f..18cf807f4f176 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -348,8 +348,8 @@ pub mod reader { f() } - fn read_owned_vec(&self, f: &fn(uint) -> T) -> T { - debug!("read_owned_vec()"); + fn read_seq(&self, f: &fn(uint) -> T) -> T { + debug!("read_seq()"); do self.push_doc(self.next_doc(EsVec)) { let len = self._next_uint(EsVecLen); debug!(" len=%u", len); @@ -357,17 +357,8 @@ pub mod reader { } } - fn read_managed_vec(&self, f: &fn(uint) -> T) -> T { - debug!("read_managed_vec()"); - do self.push_doc(self.next_doc(EsVec)) { - let len = self._next_uint(EsVecLen); - debug!(" len=%u", len); - f(len) - } - } - - fn read_vec_elt(&self, idx: uint, f: &fn() -> T) -> T { - debug!("read_vec_elt(idx=%u)", idx); + fn read_seq_elt(&self, idx: uint, f: &fn() -> T) -> T { + debug!("read_seq_elt(idx=%u)", idx); self.push_doc(self.next_doc(EsVecElt), f) } @@ -652,22 +643,14 @@ pub mod writer { } fn emit_enum_variant_arg(&self, _idx: uint, f: &fn()) { f() } - fn emit_borrowed_vec(&self, len: uint, f: &fn()) { + fn emit_seq(&self, len: uint, f: &fn()) { do self.wr_tag(EsVec as uint) { self._emit_tagged_uint(EsVecLen, len); f() } } - 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) - } - - fn emit_vec_elt(&self, _idx: uint, f: &fn()) { + fn emit_seq_elt(&self, _idx: uint, f: &fn()) { self.wr_tag(EsVecElt as uint, f) } diff --git a/src/libstd/json.rs b/src/libstd/json.rs index c936f8e4dcdba..d2dd9bc34326e 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -130,19 +130,13 @@ impl serialize::Encoder for Encoder { f(); } - fn emit_borrowed_vec(&self, _len: uint, f: &fn()) { + fn emit_seq(&self, _len: uint, f: &fn()) { self.wr.write_char('['); f(); self.wr.write_char(']'); } - 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) - } - fn emit_vec_elt(&self, idx: uint, f: &fn()) { + fn emit_seq_elt(&self, idx: uint, f: &fn()) { if idx != 0 { self.wr.write_char(','); } f() } @@ -165,10 +159,10 @@ impl serialize::Encoder for Encoder { } fn emit_tup(&self, len: uint, f: &fn()) { - self.emit_borrowed_vec(len, f); + self.emit_seq(len, f); } fn emit_tup_elt(&self, idx: uint, f: &fn()) { - self.emit_vec_elt(idx, f) + self.emit_seq_elt(idx, f) } fn emit_option(&self, f: &fn()) { f(); } @@ -243,7 +237,7 @@ impl serialize::Encoder for PrettyEncoder { f() } - fn emit_borrowed_vec(&self, len: uint, f: &fn()) { + fn emit_seq(&self, len: uint, f: &fn()) { if len == 0 { self.wr.write_str("[]"); } else { @@ -256,13 +250,7 @@ impl serialize::Encoder for PrettyEncoder { self.wr.write_char(']'); } } - 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) - } - fn emit_vec_elt(&self, idx: uint, f: &fn()) { + fn emit_seq_elt(&self, idx: uint, f: &fn()) { if idx == 0 { self.wr.write_char('\n'); } else { @@ -300,10 +288,10 @@ impl serialize::Encoder for PrettyEncoder { f(); } fn emit_tup(&self, sz: uint, f: &fn()) { - self.emit_borrowed_vec(sz, f); + self.emit_seq(sz, f); } fn emit_tup_elt(&self, idx: uint, f: &fn()) { - self.emit_vec_elt(idx, f) + self.emit_seq_elt(idx, f) } fn emit_option(&self, f: &fn()) { f(); } @@ -858,19 +846,8 @@ impl<'self> serialize::Decoder for Decoder<'self> { } } - fn read_owned_vec(&self, f: &fn(uint) -> T) -> T { - debug!("read_owned_vec()"); - let len = match *self.peek() { - List(ref list) => list.len(), - _ => fail!(~"not a list"), - }; - let res = f(len); - self.pop(); - res - } - - fn read_managed_vec(&self, f: &fn(uint) -> T) -> T { - debug!("read_owned_vec()"); + fn read_seq(&self, f: &fn(uint) -> T) -> T { + debug!("read_seq()"); let len = match *self.peek() { List(ref list) => list.len(), _ => fail!(~"not a list"), @@ -880,8 +857,8 @@ impl<'self> serialize::Decoder for Decoder<'self> { res } - fn read_vec_elt(&self, idx: uint, f: &fn() -> T) -> T { - debug!("read_vec_elt(idx=%u)", idx); + fn read_seq_elt(&self, idx: uint, f: &fn() -> T) -> T { + debug!("read_seq_elt(idx=%u)", idx); match *self.peek() { List(ref list) => { self.stack.push(&list[idx]); diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs index 42a9e24b1cbd6..512a12aace8f4 100644 --- a/src/libstd/serialize.rs +++ b/src/libstd/serialize.rs @@ -46,10 +46,8 @@ pub trait Encoder { fn emit_enum_variant(&self, v_name: &str, v_id: uint, sz: uint, f: &fn()); fn emit_enum_variant_arg(&self, idx: uint, f: &fn()); - fn emit_borrowed_vec(&self, len: uint, f: &fn()); - fn emit_owned_vec(&self, len: uint, f: &fn()); - fn emit_managed_vec(&self, len: uint, f: &fn()); - fn emit_vec_elt(&self, idx: uint, f: &fn()); + fn emit_seq(&self, len: uint, f: &fn()); + fn emit_seq_elt(&self, idx: uint, f: &fn()); fn emit_rec(&self, f: &fn()); fn emit_struct(&self, name: &str, _len: uint, f: &fn()); @@ -94,9 +92,8 @@ pub trait Decoder { fn read_enum_variant(&self, names: &[&str], f: &fn(uint) -> T) -> T; fn read_enum_variant_arg(&self, idx: uint, f: &fn() -> T) -> T; - fn read_owned_vec(&self, f: &fn(uint) -> T) -> T; - fn read_managed_vec(&self, f: &fn(uint) -> T) -> T; - fn read_vec_elt(&self, idx: uint, f: &fn() -> T) -> T; + fn read_seq(&self, f: &fn(uint) -> T) -> T; + fn read_seq_elt(&self, idx: uint, f: &fn() -> T) -> T; fn read_rec(&self, f: &fn() -> T) -> T; fn read_struct(&self, name: &str, _len: uint, f: &fn() -> T) -> T; @@ -320,9 +317,9 @@ impl> Decodable for @T { impl<'self, S:Encoder,T:Encodable> Encodable for &'self [T] { fn encode(&self, s: &S) { - do s.emit_borrowed_vec(self.len()) { + do s.emit_seq(self.len()) { for self.eachi |i, e| { - s.emit_vec_elt(i, || e.encode(s)) + s.emit_seq_elt(i, || e.encode(s)) } } } @@ -330,9 +327,9 @@ impl<'self, S:Encoder,T:Encodable> Encodable for &'self [T] { impl> Encodable for ~[T] { fn encode(&self, s: &S) { - do s.emit_owned_vec(self.len()) { + do s.emit_seq(self.len()) { for self.eachi |i, e| { - s.emit_vec_elt(i, || e.encode(s)) + s.emit_seq_elt(i, || e.encode(s)) } } } @@ -340,9 +337,9 @@ impl> Encodable for ~[T] { impl> Decodable for ~[T] { fn decode(d: &D) -> ~[T] { - do d.read_owned_vec |len| { + do d.read_seq |len| { do vec::from_fn(len) |i| { - d.read_vec_elt(i, || Decodable::decode(d)) + d.read_seq_elt(i, || Decodable::decode(d)) } } } @@ -350,9 +347,9 @@ impl> Decodable for ~[T] { impl> Encodable for @[T] { fn encode(&self, s: &S) { - do s.emit_managed_vec(self.len()) { + do s.emit_seq(self.len()) { for self.eachi |i, e| { - s.emit_vec_elt(i, || e.encode(s)) + s.emit_seq_elt(i, || e.encode(s)) } } } @@ -360,9 +357,9 @@ impl> Encodable for @[T] { impl> Decodable for @[T] { fn decode(d: &D) -> @[T] { - do d.read_managed_vec |len| { + do d.read_seq |len| { do at_vec::from_fn(len) |i| { - d.read_vec_elt(i, || Decodable::decode(d)) + d.read_seq_elt(i, || Decodable::decode(d)) } } } @@ -395,9 +392,9 @@ impl,T1:Encodable> Encodable for (T0, T1) { fn encode(&self, s: &S) { match *self { (ref t0, ref t1) => { - do s.emit_tup(2) { - s.emit_tup_elt(0, || t0.encode(s)); - s.emit_tup_elt(1, || t1.encode(s)); + do s.emit_seq(2) { + s.emit_seq_elt(0, || t0.encode(s)); + s.emit_seq_elt(1, || t1.encode(s)); } } } @@ -406,10 +403,11 @@ impl,T1:Encodable> Encodable for (T0, T1) { impl,T1:Decodable> Decodable for (T0, T1) { fn decode(d: &D) -> (T0, T1) { - do d.read_tup(2) { + do d.read_seq |len| { + fail_unless!(len == 2); ( - d.read_tup_elt(0, || Decodable::decode(d)), - d.read_tup_elt(1, || Decodable::decode(d)) + d.read_seq_elt(0, || Decodable::decode(d)), + d.read_seq_elt(1, || Decodable::decode(d)) ) } } @@ -424,10 +422,10 @@ impl< fn encode(&self, s: &S) { match *self { (ref t0, ref t1, ref t2) => { - do s.emit_tup(3) { - s.emit_tup_elt(0, || t0.encode(s)); - s.emit_tup_elt(1, || t1.encode(s)); - s.emit_tup_elt(2, || t2.encode(s)); + do s.emit_seq(3) { + s.emit_seq_elt(0, || t0.encode(s)); + s.emit_seq_elt(1, || t1.encode(s)); + s.emit_seq_elt(2, || t2.encode(s)); } } } @@ -441,11 +439,12 @@ impl< T2: Decodable > Decodable for (T0, T1, T2) { fn decode(d: &D) -> (T0, T1, T2) { - do d.read_tup(3) { + do d.read_seq |len| { + fail_unless!(len == 3); ( - d.read_tup_elt(0, || Decodable::decode(d)), - d.read_tup_elt(1, || Decodable::decode(d)), - d.read_tup_elt(2, || Decodable::decode(d)) + d.read_seq_elt(0, || Decodable::decode(d)), + d.read_seq_elt(1, || Decodable::decode(d)), + d.read_seq_elt(2, || Decodable::decode(d)) ) } } @@ -461,11 +460,11 @@ impl< fn encode(&self, s: &S) { match *self { (ref t0, ref t1, ref t2, ref t3) => { - do s.emit_tup(4) { - s.emit_tup_elt(0, || t0.encode(s)); - s.emit_tup_elt(1, || t1.encode(s)); - s.emit_tup_elt(2, || t2.encode(s)); - s.emit_tup_elt(3, || t3.encode(s)); + do s.emit_seq(4) { + s.emit_seq_elt(0, || t0.encode(s)); + s.emit_seq_elt(1, || t1.encode(s)); + s.emit_seq_elt(2, || t2.encode(s)); + s.emit_seq_elt(3, || t3.encode(s)); } } } @@ -480,12 +479,13 @@ impl< T3: Decodable > Decodable for (T0, T1, T2, T3) { fn decode(d: &D) -> (T0, T1, T2, T3) { - do d.read_tup(4) { + do d.read_seq |len| { + fail_unless!(len == 4); ( - d.read_tup_elt(0, || Decodable::decode(d)), - d.read_tup_elt(1, || Decodable::decode(d)), - d.read_tup_elt(2, || Decodable::decode(d)), - d.read_tup_elt(3, || Decodable::decode(d)) + d.read_seq_elt(0, || Decodable::decode(d)), + d.read_seq_elt(1, || Decodable::decode(d)), + d.read_seq_elt(2, || Decodable::decode(d)), + d.read_seq_elt(3, || Decodable::decode(d)) ) } } @@ -502,12 +502,12 @@ impl< fn encode(&self, s: &S) { match *self { (ref t0, ref t1, ref t2, ref t3, ref t4) => { - do s.emit_tup(5) { - s.emit_tup_elt(0, || t0.encode(s)); - s.emit_tup_elt(1, || t1.encode(s)); - s.emit_tup_elt(2, || t2.encode(s)); - s.emit_tup_elt(3, || t3.encode(s)); - s.emit_tup_elt(4, || t4.encode(s)); + do s.emit_seq(5) { + s.emit_seq_elt(0, || t0.encode(s)); + s.emit_seq_elt(1, || t1.encode(s)); + s.emit_seq_elt(2, || t2.encode(s)); + s.emit_seq_elt(3, || t3.encode(s)); + s.emit_seq_elt(4, || t4.encode(s)); } } } @@ -524,13 +524,14 @@ impl< > Decodable for (T0, T1, T2, T3, T4) { fn decode(d: &D) -> (T0, T1, T2, T3, T4) { - do d.read_tup(5) { + do d.read_seq |len| { + fail_unless!(len == 5); ( - d.read_tup_elt(0, || Decodable::decode(d)), - d.read_tup_elt(1, || Decodable::decode(d)), - d.read_tup_elt(2, || Decodable::decode(d)), - d.read_tup_elt(3, || Decodable::decode(d)), - d.read_tup_elt(4, || Decodable::decode(d)) + d.read_seq_elt(0, || Decodable::decode(d)), + d.read_seq_elt(1, || Decodable::decode(d)), + d.read_seq_elt(2, || Decodable::decode(d)), + d.read_seq_elt(3, || Decodable::decode(d)), + d.read_seq_elt(4, || Decodable::decode(d)) ) } } @@ -547,9 +548,9 @@ pub trait EncoderHelpers { impl EncoderHelpers for S { fn emit_from_vec(&self, v: &[T], f: &fn(v: &T)) { - do self.emit_owned_vec(v.len()) { + do self.emit_seq(v.len()) { for v.eachi |i, e| { - do self.emit_vec_elt(i) { + do self.emit_seq_elt(i) { f(e) } } @@ -563,9 +564,9 @@ pub trait DecoderHelpers { impl DecoderHelpers for D { fn read_to_vec(&self, f: &fn() -> T) -> ~[T] { - do self.read_owned_vec |len| { + do self.read_seq |len| { do vec::from_fn(len) |i| { - self.read_vec_elt(i, || f()) + self.read_seq_elt(i, || f()) } } } diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs index c9357c9d86729..4b262df36a620 100644 --- a/src/libsyntax/ext/auto_encode.rs +++ b/src/libsyntax/ext/auto_encode.rs @@ -1255,17 +1255,10 @@ mod test { self.add_to_log(CallToEmitEnumVariantArg (idx)); f(); } - fn emit_borrowed_vec(&self, +_len: uint, f: &fn()) { + fn emit_seq(&self, +_len: uint, f: &fn()) { self.add_unknown_to_log(); f(); } - - fn emit_owned_vec(&self, +_len: uint, f: &fn()) { - self.add_unknown_to_log(); f(); - } - fn emit_managed_vec(&self, +_len: uint, f: &fn()) { - self.add_unknown_to_log(); f(); - } - fn emit_vec_elt(&self, +_idx: uint, f: &fn()) { + fn emit_seq_elt(&self, +_idx: uint, f: &fn()) { self.add_unknown_to_log(); f(); } From e99cdcfba847ade51791afbc95478306c6c3e7c1 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Thu, 28 Mar 2013 21:47:17 -0700 Subject: [PATCH 08/18] std: remove Encoder::emit_tup{,_elt} and Decoder::read_tup{,_elt} --- src/libstd/ebml.rs | 13 ------------- src/libstd/json.rs | 31 ------------------------------- src/libstd/serialize.rs | 6 ------ src/libsyntax/ext/auto_encode.rs | 7 ------- 4 files changed, 57 deletions(-) diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 18cf807f4f176..12a4ea149093a 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -378,16 +378,6 @@ pub mod reader { f() } - fn read_tup(&self, len: uint, f: &fn() -> T) -> T { - debug!("read_tup(len=%u)", len); - f() - } - - fn read_tup_elt(&self, idx: uint, f: &fn() -> T) -> T { - debug!("read_tup_elt(idx=%u)", idx); - f() - } - #[cfg(stage0)] fn read_option(&self, f: &fn(bool) -> T) -> T { debug!("read_option()"); @@ -661,9 +651,6 @@ pub mod writer { f() } - fn emit_tup(&self, _len: uint, f: &fn()) { f() } - fn emit_tup_elt(&self, _idx: uint, f: &fn()) { f() } - fn emit_option(&self, f: &fn()) { self.emit_enum("Option", f); } diff --git a/src/libstd/json.rs b/src/libstd/json.rs index d2dd9bc34326e..fe5b0cf88e674 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -158,13 +158,6 @@ impl serialize::Encoder for Encoder { f(); } - fn emit_tup(&self, len: uint, f: &fn()) { - self.emit_seq(len, f); - } - fn emit_tup_elt(&self, idx: uint, f: &fn()) { - self.emit_seq_elt(idx, f) - } - fn emit_option(&self, f: &fn()) { f(); } fn emit_option_none(&self) { self.emit_nil(); } fn emit_option_some(&self, f: &fn()) { f(); } @@ -287,12 +280,6 @@ impl serialize::Encoder for PrettyEncoder { self.wr.write_str(": "); f(); } - fn emit_tup(&self, sz: uint, f: &fn()) { - self.emit_seq(sz, f); - } - fn emit_tup_elt(&self, idx: uint, f: &fn()) { - self.emit_seq_elt(idx, f) - } fn emit_option(&self, f: &fn()) { f(); } fn emit_option_none(&self) { self.emit_nil(); } @@ -905,24 +892,6 @@ impl<'self> serialize::Decoder for Decoder<'self> { } } - fn read_tup(&self, len: uint, f: &fn() -> T) -> T { - debug!("read_tup(len=%u)", len); - let value = f(); - self.pop(); - value - } - - fn read_tup_elt(&self, idx: uint, f: &fn() -> T) -> T { - debug!("read_tup_elt(idx=%u)", idx); - match *self.peek() { - List(ref list) => { - self.stack.push(&list[idx]); - f() - } - _ => fail!(~"not a list") - } - } - fn read_option(&self, f: &fn(bool) -> T) -> T { match *self.peek() { Null => { self.pop(); f(false) } diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs index 512a12aace8f4..d0127bb099915 100644 --- a/src/libstd/serialize.rs +++ b/src/libstd/serialize.rs @@ -53,9 +53,6 @@ pub trait Encoder { fn emit_struct(&self, name: &str, _len: uint, f: &fn()); fn emit_field(&self, f_name: &str, f_idx: uint, f: &fn()); - fn emit_tup(&self, len: uint, f: &fn()); - fn emit_tup_elt(&self, idx: uint, f: &fn()); - // Specialized types: fn emit_option(&self, f: &fn()); fn emit_option_none(&self); @@ -99,9 +96,6 @@ pub trait Decoder { fn read_struct(&self, name: &str, _len: uint, f: &fn() -> T) -> T; fn read_field(&self, name: &str, idx: uint, f: &fn() -> T) -> T; - fn read_tup(&self, sz: uint, f: &fn() -> T) -> T; - fn read_tup_elt(&self, idx: uint, f: &fn() -> T) -> T; - // Specialized types: fn read_option(&self, f: &fn(bool) -> T) -> T; } diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs index 4b262df36a620..d4e1fa3abf737 100644 --- a/src/libsyntax/ext/auto_encode.rs +++ b/src/libsyntax/ext/auto_encode.rs @@ -1272,13 +1272,6 @@ mod test { self.add_to_log(CallToEmitField (name.to_str(),idx)); f(); } - fn emit_tup(&self, +_len: uint, f: &fn()) { - self.add_unknown_to_log(); f(); - } - fn emit_tup_elt(&self, +_idx: uint, f: &fn()) { - self.add_unknown_to_log(); f(); - } - fn emit_option(&self, f: &fn()) { self.add_to_log(CallToEmitOption); f(); From 90b3658cd69f63d95f3bf568e6f23406c56f11a7 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Thu, 28 Mar 2013 22:19:43 -0700 Subject: [PATCH 09/18] std: remove Encoder::read_rec and Decoder::emit_rec --- src/librustc/middle/astencode.rs | 8 ++--- src/libstd/ebml.rs | 6 ---- src/libstd/json.rs | 51 +++++++++++--------------------- src/libstd/serialize.rs | 2 -- src/libsyntax/ext/auto_encode.rs | 3 -- 5 files changed, 22 insertions(+), 48 deletions(-) diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index c2692e9fa105d..719ffe9bb87d7 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -558,7 +558,7 @@ trait read_method_map_entry_helper { fn encode_method_map_entry(ecx: @e::EncodeContext, ebml_w: writer::Encoder, mme: method_map_entry) { - do ebml_w.emit_rec { + do ebml_w.emit_struct("method_map_entry", 3) { do ebml_w.emit_field(~"self_arg", 0u) { ebml_w.emit_arg(ecx, mme.self_arg); } @@ -574,7 +574,7 @@ fn encode_method_map_entry(ecx: @e::EncodeContext, impl read_method_map_entry_helper for reader::Decoder { fn read_method_map_entry(&self, xcx: @ExtendedDecodeContext) -> method_map_entry { - do self.read_rec { + do self.read_struct("method_map_entry", 3) { method_map_entry { self_arg: self.read_field(~"self_arg", 0u, || { self.read_arg(xcx) @@ -817,7 +817,7 @@ impl ebml_writer_helpers for writer::Encoder { fn emit_tpbt(&self, ecx: @e::EncodeContext, tpbt: ty::ty_param_bounds_and_ty) { - do self.emit_rec { + do self.emit_struct("ty_param_bounds_and_ty", 3) { do self.emit_field(~"bounds", 0) { do self.emit_from_vec(*tpbt.bounds) |bs| { self.emit_bounds(ecx, *bs); @@ -1084,7 +1084,7 @@ impl ebml_decoder_decoder_helpers for reader::Decoder { fn read_ty_param_bounds_and_ty(&self, xcx: @ExtendedDecodeContext) -> ty::ty_param_bounds_and_ty { - do self.read_rec { + do self.read_struct("ty_param_bounds_and_ty", 3) { ty::ty_param_bounds_and_ty { bounds: self.read_field(~"bounds", 0u, || { @self.read_to_vec(|| self.read_bounds(xcx) ) diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 12a4ea149093a..6b216504e543e 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -362,11 +362,6 @@ pub mod reader { self.push_doc(self.next_doc(EsVecElt), f) } - fn read_rec(&self, f: &fn() -> T) -> T { - debug!("read_rec()"); - f() - } - fn read_struct(&self, name: &str, _len: uint, f: &fn() -> T) -> T { debug!("read_struct(name=%s)", name); f() @@ -644,7 +639,6 @@ pub mod writer { self.wr_tag(EsVecElt as uint, f) } - fn emit_rec(&self, f: &fn()) { f() } fn emit_struct(&self, _name: &str, _len: uint, f: &fn()) { f() } fn emit_field(&self, name: &str, _idx: uint, f: &fn()) { self._emit_label(name); diff --git a/src/libstd/json.rs b/src/libstd/json.rs index fe5b0cf88e674..ac7119d8ed8c5 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -141,11 +141,6 @@ impl serialize::Encoder for Encoder { f() } - fn emit_rec(&self, f: &fn()) { - self.wr.write_char('{'); - f(); - self.wr.write_char('}'); - } fn emit_struct(&self, _name: &str, _len: uint, f: &fn()) { self.wr.write_char('{'); f(); @@ -253,20 +248,17 @@ impl serialize::Encoder for PrettyEncoder { f() } - fn emit_rec(&self, f: &fn()) { - self.wr.write_char('{'); - self.indent += 2; - f(); - self.wr.write_char('\n'); - self.indent -= 2; - self.wr.write_str(spaces(self.indent)); - self.wr.write_char('}'); - } fn emit_struct(&self, _name: &str, len: uint, f: &fn()) { if len == 0 { self.wr.write_str("{}"); } else { - self.emit_rec(f) + self.wr.write_char('{'); + self.indent += 2; + f(); + self.wr.write_char('\n'); + self.indent -= 2; + self.wr.write_str(spaces(self.indent)); + self.wr.write_char('}'); } } fn emit_field(&self, name: &str, idx: uint, f: &fn()) { @@ -286,25 +278,25 @@ impl serialize::Encoder for PrettyEncoder { fn emit_option_some(&self, f: &fn()) { f(); } } -impl serialize::Encodable for Json { - fn encode(&self, s: &S) { +impl serialize::Encodable for Json { + fn encode(&self, e: &E) { match *self { - Number(v) => v.encode(s), - String(ref v) => v.encode(s), - Boolean(v) => v.encode(s), - List(ref v) => v.encode(s), + Number(v) => v.encode(e), + String(ref v) => v.encode(e), + Boolean(v) => v.encode(e), + List(ref v) => v.encode(e), Object(ref v) => { - do s.emit_rec || { + do e.emit_struct("Object", v.len())|| { let mut idx = 0; for v.each |&(key, value)| { - do s.emit_field(*key, idx) { - value.encode(s); + do e.emit_field(*key, idx) { + value.encode(e); } idx += 1; } } }, - Null => s.emit_nil(), + Null => e.emit_nil(), } } } @@ -855,13 +847,6 @@ impl<'self> serialize::Decoder for Decoder<'self> { } } - fn read_rec(&self, f: &fn() -> T) -> T { - debug!("read_rec()"); - let value = f(); - self.pop(); - value - } - fn read_struct(&self, _name: &str, _len: uint, f: &fn() -> T) -> T { debug!("read_struct()"); let value = f(); @@ -870,7 +855,7 @@ impl<'self> serialize::Decoder for Decoder<'self> { } fn read_field(&self, name: &str, idx: uint, f: &fn() -> T) -> T { - debug!("read_rec_field(%s, idx=%u)", name, idx); + debug!("read_field(%s, idx=%u)", name, idx); let top = self.peek(); match *top { Object(ref obj) => { diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs index d0127bb099915..8320165347401 100644 --- a/src/libstd/serialize.rs +++ b/src/libstd/serialize.rs @@ -49,7 +49,6 @@ pub trait Encoder { fn emit_seq(&self, len: uint, f: &fn()); fn emit_seq_elt(&self, idx: uint, f: &fn()); - fn emit_rec(&self, f: &fn()); fn emit_struct(&self, name: &str, _len: uint, f: &fn()); fn emit_field(&self, f_name: &str, f_idx: uint, f: &fn()); @@ -92,7 +91,6 @@ pub trait Decoder { fn read_seq(&self, f: &fn(uint) -> T) -> T; fn read_seq_elt(&self, idx: uint, f: &fn() -> T) -> T; - fn read_rec(&self, f: &fn() -> T) -> T; fn read_struct(&self, name: &str, _len: uint, f: &fn() -> T) -> T; fn read_field(&self, name: &str, idx: uint, f: &fn() -> T) -> T; diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs index d4e1fa3abf737..3aceef9c73ada 100644 --- a/src/libsyntax/ext/auto_encode.rs +++ b/src/libsyntax/ext/auto_encode.rs @@ -1262,9 +1262,6 @@ mod test { self.add_unknown_to_log(); f(); } - fn emit_rec(&self, f: &fn()) { - self.add_unknown_to_log(); f(); - } fn emit_struct(&self, name: &str, +len: uint, f: &fn()) { self.add_to_log(CallToEmitStruct (name.to_str(),len)); f(); } From ed62f6dfe0c8f3b8b2769c65bb7b7bb8b3815b1a Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Fri, 29 Mar 2013 07:29:52 -0700 Subject: [PATCH 10/18] core: add consume_reverse --- src/libcore/vec.rs | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs index 174960560dfd6..426166ec430ae 100644 --- a/src/libcore/vec.rs +++ b/src/libcore/vec.rs @@ -558,6 +558,28 @@ pub fn consume(mut v: ~[T], f: &fn(uint, v: T)) { } } +pub fn consume_reverse(mut v: ~[T], f: &fn(uint, v: T)) { + unsafe { + do as_mut_buf(v) |p, ln| { + let mut i = ln; + while i > 0 { + i -= 1; + + // NB: This unsafe operation counts on init writing 0s to the + // holes we create in the vector. That ensures that, if the + // iterator fails then we won't try to clean up the consumed + // elements during unwinding + let mut x = intrinsics::init(); + let p = ptr::mut_offset(p, i); + x <-> *p; + f(i, x); + } + } + + raw::set_len(&mut v, 0); + } +} + /// Remove the last element from a vector and return it pub fn pop(v: &mut ~[T]) -> T { let ln = v.len(); @@ -1983,6 +2005,7 @@ pub trait OwnedVector { fn truncate(&mut self, newlen: uint); fn retain(&mut self, f: &fn(t: &T) -> bool); fn consume(self, f: &fn(uint, v: T)); + fn consume_reverse(self, f: &fn(uint, v: T)); fn filter(self, f: &fn(t: &T) -> bool) -> ~[T]; fn partition(self, f: &fn(&T) -> bool) -> (~[T], ~[T]); fn grow_fn(&mut self, n: uint, op: iter::InitOp); @@ -2044,6 +2067,11 @@ impl OwnedVector for ~[T] { consume(self, f) } + #[inline] + fn consume_reverse(self, f: &fn(uint, v: T)) { + consume_reverse(self, f) + } + #[inline] fn filter(self, f: &fn(&T) -> bool) -> ~[T] { filter(self, f) From d1a83e6986470d2db81474bb7fd3eadada78b0a4 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Fri, 29 Mar 2013 09:04:35 -0700 Subject: [PATCH 11/18] std: add Encoder::emit_map and Decoder::read_map --- src/libstd/ebml.rs | 27 ++++ src/libstd/flatpipes.rs | 4 +- src/libstd/json.rs | 221 +++++++++++++++++++------------ src/libstd/serialize.rs | 63 ++++++++- src/libstd/workcache.rs | 41 ++++-- src/libsyntax/ext/auto_encode.rs | 10 ++ 6 files changed, 263 insertions(+), 103 deletions(-) diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 6b216504e543e..f7fe2f54c57ee 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -402,6 +402,21 @@ pub mod reader { } } } + + fn read_map(&self, _f: &fn(uint) -> T) -> T { + debug!("read_map()"); + fail!(~"read_map is unimplemented"); + } + + fn read_map_elt_key(&self, idx: uint, _f: &fn() -> T) -> T { + debug!("read_map_elt_key(idx=%u)", idx); + fail!(~"read_map_elt_val is unimplemented"); + } + + fn read_map_elt_val(&self, idx: uint, _f: &fn() -> T) -> T { + debug!("read_map_elt_val(idx=%u)", idx); + fail!(~"read_map_elt_val is unimplemented"); + } } } @@ -654,6 +669,18 @@ pub mod writer { fn emit_option_some(&self, f: &fn()) { self.emit_enum_variant("Some", 1, 1, f) } + + fn emit_map(&self, _len: uint, _f: &fn()) { + fail!(~"emit_map is unimplemented"); + } + + fn emit_map_elt_key(&self, _idx: uint, _f: &fn()) { + fail!(~"emit_map_elt_key is unimplemented"); + } + + fn emit_map_elt_val(&self, _idx: uint, _f: &fn()) { + fail!(~"emit_map_elt_val is unimplemented"); + } } } diff --git a/src/libstd/flatpipes.rs b/src/libstd/flatpipes.rs index 1a3a28f749279..f042e2226cd4b 100644 --- a/src/libstd/flatpipes.rs +++ b/src/libstd/flatpipes.rs @@ -466,8 +466,8 @@ pub mod flatteners { fn from_writer(w: @Writer) -> Self; } - impl<'self> FromReader for json::Decoder<'self> { - fn from_reader(r: @Reader) -> json::Decoder<'self> { + impl FromReader for json::Decoder { + fn from_reader(r: @Reader) -> json::Decoder { match json::from_reader(r) { Ok(json) => { json::Decoder(json) diff --git a/src/libstd/json.rs b/src/libstd/json.rs index ac7119d8ed8c5..f069547bc8c3d 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -156,6 +156,22 @@ impl serialize::Encoder for Encoder { fn emit_option(&self, f: &fn()) { f(); } fn emit_option_none(&self) { self.emit_nil(); } fn emit_option_some(&self, f: &fn()) { f(); } + + fn emit_map(&self, _len: uint, f: &fn()) { + self.wr.write_char('{'); + f(); + self.wr.write_char('}'); + } + + fn emit_map_elt_key(&self, idx: uint, f: &fn()) { + if idx != 0 { self.wr.write_char(','); } + f() + } + + fn emit_map_elt_val(&self, _idx: uint, f: &fn()) { + self.wr.write_char(':'); + f() + } } pub struct PrettyEncoder { @@ -276,6 +292,34 @@ impl serialize::Encoder for PrettyEncoder { fn emit_option(&self, f: &fn()) { f(); } fn emit_option_none(&self) { self.emit_nil(); } fn emit_option_some(&self, f: &fn()) { f(); } + + fn emit_map(&self, len: uint, f: &fn()) { + if len == 0 { + self.wr.write_str("{}"); + } else { + self.wr.write_char('{'); + self.indent += 2; + f(); + self.wr.write_char('\n'); + self.indent -= 2; + self.wr.write_str(spaces(self.indent)); + self.wr.write_char('}'); + } + } + fn emit_map_elt_key(&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(); + } + + fn emit_map_elt_val(&self, _idx: uint, f: &fn()) { + self.wr.write_str(": "); + f(); + } } impl serialize::Encodable for Json { @@ -285,17 +329,7 @@ impl serialize::Encodable for Json { String(ref v) => v.encode(e), Boolean(v) => v.encode(e), List(ref v) => v.encode(e), - Object(ref v) => { - do e.emit_struct("Object", v.len())|| { - let mut idx = 0; - for v.each |&(key, value)| { - do e.emit_field(*key, idx) { - value.encode(e); - } - idx += 1; - } - } - }, + Object(ref v) => v.encode(e), Null => e.emit_nil(), } } @@ -702,37 +736,20 @@ pub fn from_str(s: &str) -> Result { } } -pub struct Decoder<'self> { - priv json: Json, - priv mut stack: ~[&'self Json], +pub struct Decoder { + priv mut stack: ~[Json], } pub fn Decoder(json: Json) -> Decoder { - Decoder { json: json, stack: ~[] } -} - -priv impl<'self> Decoder<'self> { - fn peek(&self) -> &'self Json { - if vec::uniq_len(&const self.stack) == 0 { - self.stack.push(&self.json); - } - self.stack[vec::uniq_len(&const self.stack) - 1] - } - - fn pop(&self) -> &'self Json { - if vec::uniq_len(&const self.stack) == 0 { - self.stack.push(&self.json); - } - self.stack.pop() - } + Decoder { stack: ~[json] } } -impl<'self> serialize::Decoder for Decoder<'self> { +impl serialize::Decoder for Decoder { fn read_nil(&self) -> () { debug!("read_nil"); - match *self.pop() { + match self.stack.pop() { Null => (), - _ => fail!(~"not a null") + value => fail!(fmt!("not a null: %?", value)) } } @@ -750,9 +767,9 @@ impl<'self> serialize::Decoder for Decoder<'self> { fn read_bool(&self) -> bool { debug!("read_bool"); - match *self.pop() { + match self.stack.pop() { Boolean(b) => b, - _ => fail!(~"not a boolean") + value => fail!(fmt!("not a boolean: %?", value)) } } @@ -760,9 +777,9 @@ impl<'self> serialize::Decoder for Decoder<'self> { fn read_f32(&self) -> f32 { self.read_float() as f32 } fn read_float(&self) -> float { debug!("read_float"); - match *self.pop() { + match self.stack.pop() { Number(f) => f, - _ => fail!(~"not a number") + value => fail!(fmt!("not a number: %?", value)) } } @@ -775,13 +792,12 @@ impl<'self> serialize::Decoder for Decoder<'self> { fn read_str(&self) -> ~str { debug!("read_str"); - match *self.pop() { - String(ref s) => copy *s, - ref json => fail!(fmt!("not a string: %?", *json)) + match self.stack.pop() { + String(s) => s, + json => fail!(fmt!("not a string: %?", json)) } } - fn read_enum(&self, name: &str, f: &fn() -> T) -> T { debug!("read_enum(%s)", name); f() @@ -790,9 +806,9 @@ impl<'self> serialize::Decoder for Decoder<'self> { #[cfg(stage0)] fn read_enum_variant(&self, f: &fn(uint) -> T) -> T { debug!("read_enum_variant()"); - let idx = match *self.peek() { - Null => 0, - _ => 1, + let idx = match self.stack.pop() { + Null => { self.stack.push(Null); 0 }, + value => { self.stack.push(value); 1 }, }; f(idx) } @@ -802,12 +818,20 @@ impl<'self> serialize::Decoder for Decoder<'self> { #[cfg(stage3)] fn read_enum_variant(&self, names: &[&str], f: &fn(uint) -> T) -> T { debug!("read_enum_variant(names=%?)", names); - let name = match *self.peek() { - String(ref s) => s, - List([String(ref s), .. _]) => s, + let name = match self.stack.pop() { + String(s) => s, + List(list) => { + do vec::consume_reverse(list) |_i, v| { + self.stack.push(v); + } + match self.stack.pop() { + String(s) => s, + value => fail!(fmt!("invalid variant name: %?", value)), + } + } ref json => fail!(fmt!("invalid variant: %?", *json)), }; - let idx = match vec::position(names, |n| str::eq_slice(*n, *name)) { + let idx = match vec::position(names, |n| str::eq_slice(*n, name)) { Some(idx) => idx, None => fail!(fmt!("Unknown variant name: %?", name)), }; @@ -816,73 +840,90 @@ impl<'self> serialize::Decoder for Decoder<'self> { fn read_enum_variant_arg(&self, idx: uint, f: &fn() -> T) -> T { debug!("read_enum_variant_arg(idx=%u)", idx); - match *self.peek() { - List(ref list) => { - self.stack.push(&list[idx + 1]); - f() - } - ref json => fail!(fmt!("not a list: %?", json)), - } + f() } fn read_seq(&self, f: &fn(uint) -> T) -> T { debug!("read_seq()"); - let len = match *self.peek() { - List(ref list) => list.len(), + let len = match self.stack.pop() { + List(list) => { + let len = list.len(); + do vec::consume_reverse(list) |_i, v| { + self.stack.push(v); + } + len + } _ => fail!(~"not a list"), }; let res = f(len); - self.pop(); + self.stack.pop(); res } fn read_seq_elt(&self, idx: uint, f: &fn() -> T) -> T { debug!("read_seq_elt(idx=%u)", idx); - match *self.peek() { - List(ref list) => { - self.stack.push(&list[idx]); - f() - } - _ => fail!(~"not a list"), - } + f() } - fn read_struct(&self, _name: &str, _len: uint, f: &fn() -> T) -> T { - debug!("read_struct()"); + fn read_struct(&self, name: &str, len: uint, f: &fn() -> T) -> T { + debug!("read_struct(name=%s, len=%u)", name, len); let value = f(); - self.pop(); + self.stack.pop(); value } fn read_field(&self, name: &str, idx: uint, f: &fn() -> T) -> T { debug!("read_field(%s, idx=%u)", name, idx); - let top = self.peek(); - match *top { - Object(ref obj) => { - match obj.find(&name.to_owned()) { + match self.stack.pop() { + Object(obj) => { + let mut obj = obj; + let value = match obj.pop(&name.to_owned()) { None => fail!(fmt!("no such field: %s", name)), Some(json) => { self.stack.push(json); f() } - } + }; + self.stack.push(Object(obj)); + value } - Number(_) => fail!(~"num"), - String(_) => fail!(~"str"), - Boolean(_) => fail!(~"bool"), - List(_) => fail!(fmt!("list: %?", top)), - Null => fail!(~"null"), - - //_ => fail!(fmt!("not an object: %?", *top)) + value => fail!(fmt!("not an object: %?", value)) } } fn read_option(&self, f: &fn(bool) -> T) -> T { - match *self.peek() { - Null => { self.pop(); f(false) } - _ => f(true), + match self.stack.pop() { + Null => f(false), + value => { self.stack.push(value); f(true) } } } + + fn read_map(&self, f: &fn(uint) -> T) -> T { + debug!("read_map()"); + let len = match self.stack.pop() { + Object(obj) => { + let mut obj = obj; + let len = obj.len(); + do obj.consume |key, value| { + self.stack.push(value); + self.stack.push(String(key)); + } + len + } + json => fail!(fmt!("not an object: %?", json)), + }; + f(len) + } + + fn read_map_elt_key(&self, idx: uint, f: &fn() -> T) -> T { + debug!("read_map_elt_key(idx=%u)", idx); + f() + } + + fn read_map_elt_val(&self, idx: uint, f: &fn() -> T) -> T { + debug!("read_map_elt_val(idx=%u)", idx); + f() + } } impl Eq for Json { @@ -1251,7 +1292,7 @@ mod tests { #[test] fn test_write_object_pretty() { - assert_eq!(to_pretty_str(&mk_object(~[])), ~"{\n}"); + assert_eq!(to_pretty_str(&mk_object(~[])), ~"{}"); assert_eq!( to_pretty_str(&mk_object(~[(~"a", Boolean(true))])), ~"\ @@ -1630,6 +1671,16 @@ mod tests { assert_eq!(value, Frog(~"Henry", 349)); } + #[test] + fn test_read_map() { + let s = ~"{\"a\": \"Dog\", \"b\": [\"Frog\", \"Henry\", 349]}"; + let decoder = Decoder(from_str(s).unwrap()); + let map: LinearMap<~str, Animal> = Decodable::decode(&decoder); + + assert_eq!(map.find(&~"a"), Some(Dog)); + assert_eq!(map.find(&~"b"), Some(Frog(~"Henry", 349))); + } + #[test] fn test_multiline_errors() { assert_eq!(from_str(~"{\n \"foo\":\n \"bar\""), diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs index 8320165347401..dd487218fe550 100644 --- a/src/libstd/serialize.rs +++ b/src/libstd/serialize.rs @@ -16,9 +16,8 @@ Core encoding and decoding interfaces. #[forbid(non_camel_case_types)]; -use core::at_vec; use core::prelude::*; -use core::vec; +use core::hashmap::linear::LinearMap; pub trait Encoder { // Primitive types: @@ -56,6 +55,10 @@ pub trait Encoder { fn emit_option(&self, f: &fn()); fn emit_option_none(&self); fn emit_option_some(&self, f: &fn()); + + fn emit_map(&self, len: uint, f: &fn()); + fn emit_map_elt_key(&self, idx: uint, f: &fn()); + fn emit_map_elt_val(&self, idx: uint, f: &fn()); } pub trait Decoder { @@ -96,6 +99,10 @@ pub trait Decoder { // Specialized types: fn read_option(&self, f: &fn(bool) -> T) -> T; + + fn read_map(&self, f: &fn(uint) -> T) -> T; + fn read_map_elt_key(&self, idx: uint, f: &fn() -> T) -> T; + fn read_map_elt_val(&self, idx: uint, f: &fn() -> T) -> T; } pub trait Encodable { @@ -529,6 +536,58 @@ impl< } } +impl< + E: Encoder, + K: Encodable + Hash + IterBytes + Eq, + V: Encodable +> Encodable for LinearMap { + fn encode(&self, e: &E) { + do e.emit_map(self.len()) { + let mut i = 0; + for self.each |&(key, val)| { + e.emit_map_elt_key(i, || key.encode(e)); + e.emit_map_elt_val(i, || val.encode(e)); + i += 1; + } + } + } +} + +impl< + D: Decoder, + K: Decodable + Hash + IterBytes + Eq, + V: Decodable +> Decodable for LinearMap { + #[cfg(stage0)] + fn decode(d: &D) -> LinearMap { + do d.read_map |len| { + let mut map = LinearMap::new(); + map.reserve_at_least(len); + for uint::range(0, len) |i| { + let key = d.read_map_elt_key(i, || Decodable::decode(d)); + let val = d.read_map_elt_val(i, || Decodable::decode(d)); + map.insert(key, val); + } + map + } + } + + #[cfg(stage1)] + #[cfg(stage2)] + #[cfg(stage3)] + fn decode(d: &D) -> LinearMap { + do d.read_map |len| { + let mut map = LinearMap::with_capacity(len); + for uint::range(0, len) |i| { + let key = d.read_map_elt_key(i, || Decodable::decode(d)); + let val = d.read_map_elt_val(i, || Decodable::decode(d)); + map.insert(key, val); + } + map + } + } +} + // ___________________________________________________________________________ // Helper routines // diff --git a/src/libstd/workcache.rs b/src/libstd/workcache.rs index f477a8c9f910b..90f10ea50541d 100644 --- a/src/libstd/workcache.rs +++ b/src/libstd/workcache.rs @@ -137,7 +137,11 @@ pub impl WorkKey { } } -type WorkMap = LinearMap; +struct WorkMap(LinearMap); + +impl WorkMap { + fn new() -> WorkMap { WorkMap(LinearMap::new()) } +} impl Encodable for WorkMap { fn encode(&self, s: &S) { @@ -153,7 +157,7 @@ impl Encodable for WorkMap { impl Decodable for WorkMap { fn decode(d: &D) -> WorkMap { let v : ~[(WorkKey,~str)] = Decodable::decode(d); - let mut w = LinearMap::new(); + let mut w = WorkMap::new(); for v.each |&(k, v)| { w.insert(copy k, copy v); } @@ -235,7 +239,7 @@ fn json_encode>(t: &T) -> ~str { } // FIXME(#5121) -fn json_decode>>(s: &str) -> T { +fn json_decode>(s: &str) -> T { do io::with_str_reader(s) |rdr| { let j = result::unwrap(json::from_reader(rdr)); Decodable::decode(&json::Decoder(j)) @@ -260,18 +264,25 @@ pub impl Context { fn new(db: @Mut, lg: @Mut, cfg: @json::Object) -> Context { - Context{db: db, logger: lg, cfg: cfg, freshness: LinearMap::new()} + Context { + db: db, + logger: lg, + cfg: cfg, + freshness: LinearMap::new() + } } fn prep + - Decodable>>( // FIXME(#5121) + Decodable>( // FIXME(#5121) @self, fn_name:&str, blk: &fn(@Mut)->Work) -> Work { - let p = @Mut(Prep {ctxt: self, - fn_name: fn_name.to_owned(), - declared_inputs: LinearMap::new()}); + let p = @Mut(Prep { + ctxt: self, + fn_name: fn_name.to_owned(), + declared_inputs: WorkMap::new() + }); blk(p) } } @@ -283,7 +294,7 @@ trait TPrep { fn all_fresh(&self, cat:&str, map:&WorkMap) -> bool; fn exec + - Decodable>>( // FIXME(#5121) + Decodable>( // FIXME(#5121) &self, blk: ~fn(&Exec) -> T) -> Work; } @@ -324,7 +335,7 @@ impl TPrep for @Mut { fn exec + - Decodable>>( // FIXME(#5121) + Decodable>( // FIXME(#5121) &self, blk: ~fn(&Exec) -> T) -> Work { let mut bo = Some(blk); @@ -349,8 +360,10 @@ impl TPrep for @Mut { let blk = blk.unwrap(); let chan = Cell(chan); do task::spawn || { - let exe = Exec{discovered_inputs: LinearMap::new(), - discovered_outputs: LinearMap::new()}; + let exe = Exec { + discovered_inputs: WorkMap::new(), + discovered_outputs: WorkMap::new(), + }; let chan = chan.take(); let v = blk(&exe); send_one(chan, (exe, v)); @@ -365,7 +378,7 @@ impl TPrep for @Mut { pub impl + - Decodable>> Work { // FIXME(#5121) + Decodable> Work { // FIXME(#5121) fn new(p: @Mut, e: Either>) -> Work { Work { prep: p, res: Some(e) } } @@ -374,7 +387,7 @@ pub impl + - Decodable>>( // FIXME(#5121) + Decodable>( // FIXME(#5121) w: Work) -> T { let mut ww = w; let mut s = None; diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs index 3aceef9c73ada..de01d25844924 100644 --- a/src/libsyntax/ext/auto_encode.rs +++ b/src/libsyntax/ext/auto_encode.rs @@ -1280,6 +1280,16 @@ mod test { self.add_to_log(CallToEmitOptionSome); f(); } + + fn read_map(&self, f: &fn(uint) -> T) -> T { + self.add_unknown_to_log(); f(0); + } + fn read_map_elt_key(&self, idx: uint, f: &fn() -> T) -> T { + self.add_unknown_to_log(); f(); + } + fn read_map_elt_val(&self, idx: uint, f: &fn() -> T) -> T { + self.add_unknown_to_log(); f(); + } } From bdef3f193052de51dbdc948d1c141a6615dcfd28 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Fri, 29 Mar 2013 09:10:31 -0700 Subject: [PATCH 12/18] std: fix json deserializing vectors and a test --- src/libstd/json.rs | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/src/libstd/json.rs b/src/libstd/json.rs index f069547bc8c3d..d26c1606a5e5c 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -855,9 +855,7 @@ impl serialize::Decoder for Decoder { } _ => fail!(~"not a list"), }; - let res = f(len); - self.stack.pop(); - res + f(len) } fn read_seq_elt(&self, idx: uint, f: &fn() -> T) -> T { @@ -1675,10 +1673,10 @@ mod tests { fn test_read_map() { let s = ~"{\"a\": \"Dog\", \"b\": [\"Frog\", \"Henry\", 349]}"; let decoder = Decoder(from_str(s).unwrap()); - let map: LinearMap<~str, Animal> = Decodable::decode(&decoder); + let mut map: LinearMap<~str, Animal> = Decodable::decode(&decoder); - assert_eq!(map.find(&~"a"), Some(Dog)); - assert_eq!(map.find(&~"b"), Some(Frog(~"Henry", 349))); + assert_eq!(map.pop(&~"a"), Some(Dog)); + assert_eq!(map.pop(&~"b"), Some(Frog(~"Henry", 349))); } #[test] From e5c7a9e3423c91c120cc4e69436dc7ee2dd1a1ab Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Fri, 29 Mar 2013 17:44:28 -0700 Subject: [PATCH 13/18] std: add serialization support for dlist, linearset, triemap, trieset, treemap, and treeset --- src/libstd/serialize.rs | 184 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 183 insertions(+), 1 deletion(-) diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs index 9e21d1f980d96..fb56abc1b643e 100644 --- a/src/libstd/serialize.rs +++ b/src/libstd/serialize.rs @@ -17,7 +17,10 @@ Core encoding and decoding interfaces. #[forbid(non_camel_case_types)]; use core::prelude::*; -use core::hashmap::linear::LinearMap; +use core::dlist::DList; +use core::hashmap::linear::{LinearMap, LinearSet}; +use core::trie::{TrieMap, TrieSet}; +use treemap::{TreeMap, TreeSet}; pub trait Encoder { // Primitive types: @@ -531,6 +534,33 @@ impl< } } +impl< + S: Encoder, + T: Encodable + Copy +> Encodable for @mut DList { + fn encode(&self, s: &S) { + do s.emit_seq(self.size) { + let mut i = 0; + for self.each |e| { + s.emit_seq_elt(i, || e.encode(s)); + i += 1; + } + } + } +} + +impl> Decodable for @mut DList { + fn decode(d: &D) -> @mut DList { + let list = DList(); + do d.read_seq |len| { + for uint::range(0, len) |i| { + list.push(d.read_seq_elt(i, || Decodable::decode(d))); + } + } + list + } +} + impl< E: Encoder, K: Encodable + Hash + IterBytes + Eq, @@ -566,6 +596,158 @@ impl< } } +impl< + S: Encoder, + T: Encodable + Hash + IterBytes + Eq +> Encodable for LinearSet { + fn encode(&self, s: &S) { + do s.emit_seq(self.len()) { + let mut i = 0; + for self.each |e| { + s.emit_seq_elt(i, || e.encode(s)); + i += 1; + } + } + } +} + +impl< + D: Decoder, + T: Decodable + Hash + IterBytes + Eq +> Decodable for LinearSet { + fn decode(d: &D) -> LinearSet { + do d.read_seq |len| { + let mut set = LinearSet::with_capacity(len); + for uint::range(0, len) |i| { + set.insert(d.read_seq_elt(i, || Decodable::decode(d))); + } + set + } + } +} + +impl< + E: Encoder, + V: Encodable +> Encodable for TrieMap { + fn encode(&self, e: &E) { + do e.emit_map(self.len()) { + let mut i = 0; + for self.each |&(key, val)| { + e.emit_map_elt_key(i, || key.encode(e)); + e.emit_map_elt_val(i, || val.encode(e)); + i += 1; + } + } + } +} + +impl< + D: Decoder, + V: Decodable +> Decodable for TrieMap { + fn decode(d: &D) -> TrieMap { + do d.read_map |len| { + let mut map = TrieMap::new(); + for uint::range(0, len) |i| { + let key = d.read_map_elt_key(i, || Decodable::decode(d)); + let val = d.read_map_elt_val(i, || Decodable::decode(d)); + map.insert(key, val); + } + map + } + } +} + +impl Encodable for TrieSet { + fn encode(&self, s: &S) { + do s.emit_seq(self.len()) { + let mut i = 0; + for self.each |e| { + s.emit_seq_elt(i, || e.encode(s)); + i += 1; + } + } + } +} + +impl Decodable for TrieSet { + fn decode(d: &D) -> TrieSet { + do d.read_seq |len| { + let mut set = TrieSet::new(); + for uint::range(0, len) |i| { + set.insert(d.read_seq_elt(i, || Decodable::decode(d))); + } + set + } + } +} + +impl< + E: Encoder, + K: Encodable + Eq + TotalOrd, + V: Encodable + Eq +> Encodable for TreeMap { + fn encode(&self, e: &E) { + do e.emit_map(self.len()) { + let mut i = 0; + for self.each |&(key, val)| { + e.emit_map_elt_key(i, || key.encode(e)); + e.emit_map_elt_val(i, || val.encode(e)); + i += 1; + } + } + } +} + +impl< + D: Decoder, + K: Decodable + Eq + TotalOrd, + V: Decodable + Eq +> Decodable for TreeMap { + fn decode(d: &D) -> TreeMap { + do d.read_map |len| { + let mut map = TreeMap::new(); + for uint::range(0, len) |i| { + let key = d.read_map_elt_key(i, || Decodable::decode(d)); + let val = d.read_map_elt_val(i, || Decodable::decode(d)); + map.insert(key, val); + } + map + } + } +} + +impl< + S: Encoder, + T: Encodable + Eq + TotalOrd +> Encodable for TreeSet { + fn encode(&self, s: &S) { + do s.emit_seq(self.len()) { + let mut i = 0; + for self.each |e| { + s.emit_seq_elt(i, || e.encode(s)); + i += 1; + } + } + } +} + +impl< + D: Decoder, + T: Decodable + Eq + TotalOrd +> Decodable for TreeSet { + fn decode(d: &D) -> TreeSet { + do d.read_seq |len| { + let mut set = TreeSet::new(); + for uint::range(0, len) |i| { + set.insert(d.read_seq_elt(i, || Decodable::decode(d))); + } + set + } + } +} + // ___________________________________________________________________________ // Helper routines // From 909d8f0eacf38ce11949365c75fae6e5a159a4e1 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Fri, 29 Mar 2013 18:02:44 -0700 Subject: [PATCH 14/18] std: Add Deque::eachi and a Deque serializer support --- src/libstd/deque.rs | 32 ++++++++++++++++++++++++++++++++ src/libstd/serialize.rs | 26 ++++++++++++++++++++++++++ 2 files changed, 58 insertions(+) diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs index e029b882472f0..e7ec86963eeb5 100644 --- a/src/libstd/deque.rs +++ b/src/libstd/deque.rs @@ -66,6 +66,18 @@ pub impl Deque { get(self.elts, idx) } + /// Iterate over the elements in the deque + fn each(&self, f: &fn(&T) -> bool) { + self.eachi(|_i, e| f(e)) + } + + /// Iterate over the elements in the deque by index + fn eachi(&self, f: &fn(uint, &T) -> bool) { + for uint::range(0, self.nelts) |i| { + if !f(i, self.get(i as int)) { return; } + } + } + /// Remove and return the first element in the deque /// /// Fails if the deque is empty @@ -223,6 +235,7 @@ mod tests { assert!(*deq.get(3) == d); } + #[test] fn test_parameterized(a: T, b: T, c: T, d: T) { let mut deq = Deque::new(); assert!(deq.len() == 0); @@ -300,4 +313,23 @@ mod tests { let reccy4 = RecCy { x: 19, y: 252, t: Two(17, 42) }; test_parameterized::(reccy1, reccy2, reccy3, reccy4); } + + #[test] + fn test_eachi() { + let mut deq = Deque::new(); + deq.add_back(1); + deq.add_back(2); + deq.add_back(3); + + for deq.eachi |i, e| { + assert_eq!(*e, i + 1); + } + + deq.pop_front(); + + for deq.eachi |i, e| { + assert_eq!(*e, i + 2); + } + + } } diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs index 360ec8afe512c..72c81d6d6b40c 100644 --- a/src/libstd/serialize.rs +++ b/src/libstd/serialize.rs @@ -20,6 +20,7 @@ use core::prelude::*; use core::dlist::DList; use core::hashmap::linear::{LinearMap, LinearSet}; use core::trie::{TrieMap, TrieSet}; +use deque::Deque; use treemap::{TreeMap, TreeSet}; pub trait Encoder { @@ -561,6 +562,31 @@ impl> Decodable for @mut DList { } } +impl< + S: Encoder, + T: Encodable +> Encodable for Deque { + fn encode(&self, s: &S) { + do s.emit_seq(self.len()) { + for self.eachi |i, e| { + s.emit_seq_elt(i, || e.encode(s)); + } + } + } +} + +impl> Decodable for Deque { + fn decode(d: &D) -> Deque { + let mut deque = Deque::new(); + do d.read_seq |len| { + for uint::range(0, len) |i| { + deque.add_back(d.read_seq_elt(i, || Decodable::decode(d))); + } + } + deque + } +} + impl< E: Encoder, K: Encodable + Hash + IterBytes + Eq, From 9bbf384058f93f2a36889bb11fd5332e5e02eb61 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Sat, 30 Mar 2013 11:08:57 -0700 Subject: [PATCH 15/18] std: clean up the json pretty printer tests --- src/libstd/json.rs | 159 ++++++++++++++++++++------------------------- 1 file changed, 71 insertions(+), 88 deletions(-) diff --git a/src/libstd/json.rs b/src/libstd/json.rs index d12488ed01fa7..d6606981b1b6a 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -1165,6 +1165,14 @@ mod tests { use std::serialize::Decodable; + #[auto_encode] + #[auto_decode] + #[deriving(Eq)] + enum Animal { + Dog, + Frog(~str, int) + } + fn mk_object(items: &[(~str, Json)]) -> Json { let mut d = ~LinearMap::new(); @@ -1180,42 +1188,49 @@ mod tests { #[test] fn test_write_null() { assert_eq!(to_str(&Null), ~"null"); + assert_eq!(to_pretty_str(&Null), ~"null"); } + #[test] fn test_write_number() { assert_eq!(to_str(&Number(3f)), ~"3"); + assert_eq!(to_pretty_str(&Number(3f)), ~"3"); + assert_eq!(to_str(&Number(3.1f)), ~"3.1"); + assert_eq!(to_pretty_str(&Number(3.1f)), ~"3.1"); + assert_eq!(to_str(&Number(-1.5f)), ~"-1.5"); + assert_eq!(to_pretty_str(&Number(-1.5f)), ~"-1.5"); + assert_eq!(to_str(&Number(0.5f)), ~"0.5"); + assert_eq!(to_pretty_str(&Number(0.5f)), ~"0.5"); } #[test] fn test_write_str() { assert_eq!(to_str(&String(~"")), ~"\"\""); + assert_eq!(to_pretty_str(&String(~"")), ~"\"\""); + assert_eq!(to_str(&String(~"foo")), ~"\"foo\""); + assert_eq!(to_pretty_str(&String(~"foo")), ~"\"foo\""); } #[test] fn test_write_bool() { assert_eq!(to_str(&Boolean(true)), ~"true"); + assert_eq!(to_pretty_str(&Boolean(true)), ~"true"); + assert_eq!(to_str(&Boolean(false)), ~"false"); + assert_eq!(to_pretty_str(&Boolean(false)), ~"false"); } #[test] fn test_write_list() { assert_eq!(to_str(&List(~[])), ~"[]"); - assert_eq!(to_str(&List(~[Boolean(true)])), ~"[true]"); - assert_eq!(to_str(&List(~[ - Boolean(false), - Null, - List(~[String(~"foo\nbar"), Number(3.5f)]) - ])), ~"[false,null,[\"foo\\nbar\",3.5]]"); - } - - #[test] - fn test_write_list_pretty() { assert_eq!(to_pretty_str(&List(~[])), ~"[]"); + + assert_eq!(to_str(&List(~[Boolean(true)])), ~"[true]"); assert_eq!( to_pretty_str(&List(~[Boolean(true)])), ~"\ @@ -1223,6 +1238,12 @@ mod tests { true\n\ ]" ); + + assert_eq!(to_str(&List(~[ + Boolean(false), + Null, + List(~[String(~"foo\nbar"), Number(3.5f)]) + ])), ~"[false,null,[\"foo\\nbar\",3.5]]"); assert_eq!( to_pretty_str(&List(~[ Boolean(false), @@ -1244,10 +1265,20 @@ mod tests { #[test] fn test_write_object() { assert_eq!(to_str(&mk_object(~[])), ~"{}"); + assert_eq!(to_pretty_str(&mk_object(~[])), ~"{}"); + assert_eq!( to_str(&mk_object(~[(~"a", Boolean(true))])), ~"{\"a\":true}" ); + assert_eq!( + to_pretty_str(&mk_object(~[(~"a", Boolean(true))])), + ~"\ + {\n \ + \"a\": true\n\ + }" + ); + assert_eq!( to_str(&mk_object(~[ (~"b", List(~[ @@ -1262,29 +1293,6 @@ mod tests { ]\ }" ); - let a = mk_object(~[ - (~"a", Boolean(true)), - (~"b", List(~[ - mk_object(~[(~"c", String(~"\x0c\r"))]), - mk_object(~[(~"d", String(~""))]) - ])) - ]); - // We can't compare the strings directly because the object fields be - // printed in a different order. - let b = from_str(to_str(&a)).unwrap(); - assert_eq!(a, b); - } - - #[test] - fn test_write_object_pretty() { - assert_eq!(to_pretty_str(&mk_object(~[])), ~"{}"); - assert_eq!( - to_pretty_str(&mk_object(~[(~"a", Boolean(true))])), - ~"\ - {\n \ - \"a\": true\n\ - }" - ); assert_eq!( to_pretty_str(&mk_object(~[ (~"b", List(~[ @@ -1304,6 +1312,7 @@ mod tests { ]\n\ }" ); + let a = mk_object(~[ (~"a", Boolean(true)), (~"b", List(~[ @@ -1311,63 +1320,44 @@ mod tests { mk_object(~[(~"d", String(~""))]) ])) ]); + // We can't compare the strings directly because the object fields be // printed in a different order. - let b = from_str(to_str(&a)).unwrap(); - assert_eq!(a, b); - } - - #[auto_encode] - #[auto_decode] - #[deriving(Eq)] - enum Animal { - Dog, - Frog(~str, int) - } - - #[test] - fn test_write_enum_no_args() { - let animal = Dog; - - let s = do io::with_str_writer |wr| { - let encoder = Encoder(wr); - animal.encode(&encoder); - }; - assert_eq!(s, ~"\"Dog\""); + assert_eq!(copy a, from_str(to_str(&a)).unwrap()); + assert_eq!(copy a, from_str(to_pretty_str(&a)).unwrap()); } #[test] - fn test_write_enum_no_args_pretty() { + fn test_write_enum() { let animal = Dog; + assert_eq!( + do io::with_str_writer |wr| { + let encoder = Encoder(wr); + animal.encode(&encoder); + }, + ~"\"Dog\"" + ); + assert_eq!( + do io::with_str_writer |wr| { + let encoder = PrettyEncoder(wr); + animal.encode(&encoder); + }, + ~"\"Dog\"" + ); - let s = do io::with_str_writer |wr| { - let encoder = PrettyEncoder(wr); - animal.encode(&encoder); - }; - assert_eq!(s, ~"\"Dog\""); - } - - #[test] - fn test_write_enum_multiple_args() { - let animal = Frog(~"Henry", 349); - - let s = do io::with_str_writer |wr| { - let encoder = Encoder(wr); - animal.encode(&encoder); - }; - assert_eq!(s, ~"[\"Frog\",\"Henry\",349]"); - } - - #[test] - fn test_write_enum_multiple_args_pretty() { let animal = Frog(~"Henry", 349); - - let s = do io::with_str_writer |wr| { - let encoder = PrettyEncoder(wr); - animal.encode(&encoder); - }; assert_eq!( - s, + do io::with_str_writer |wr| { + let encoder = Encoder(wr); + animal.encode(&encoder); + }, + ~"[\"Frog\",\"Henry\",349]" + ); + assert_eq!( + do io::with_str_writer |wr| { + let encoder = PrettyEncoder(wr); + animal.encode(&encoder); + }, ~"\ [\n \ \"Frog\",\n \ @@ -1385,10 +1375,7 @@ mod tests { value.encode(&encoder); }; assert_eq!(s, ~"\"jodhpurs\""); - } - #[test] - fn test_write_some_pretty() { let value = Some(~"jodhpurs"); let s = do io::with_str_writer |wr| { let encoder = PrettyEncoder(wr); @@ -1405,11 +1392,7 @@ mod tests { value.encode(&encoder); }; assert_eq!(s, ~"null"); - } - #[test] - fn test_write_none_pretty() { - let value: Option<~str> = None; let s = do io::with_str_writer |wr| { let encoder = Encoder(wr); value.encode(&encoder); From f364cf54631fc22860d0f00fb60f6a1dea3d7fd2 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Sat, 30 Mar 2013 13:24:52 -0700 Subject: [PATCH 16/18] syntax: fix auto_encode test. --- src/libsyntax/ext/auto_encode.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs index 52bb4110082a3..d25792355a718 100644 --- a/src/libsyntax/ext/auto_encode.rs +++ b/src/libsyntax/ext/auto_encode.rs @@ -1281,13 +1281,13 @@ mod test { f(); } - fn emit_map(&self, f: &fn(uint) -> T) -> T { - self.add_unknown_to_log(); f(0); + fn emit_map(&self, _len: uint, f: &fn()) { + self.add_unknown_to_log(); f(); } - fn emit_map_elt_key(&self, idx: uint, f: &fn() -> T) -> T { + fn emit_map_elt_key(&self, _idx: uint, f: &fn()) { self.add_unknown_to_log(); f(); } - fn emit_map_elt_val(&self, idx: uint, f: &fn() -> T) -> T { + fn emit_map_elt_val(&self, _idx: uint, f: &fn()) { self.add_unknown_to_log(); f(); } } From 5b7d608bf6456512b267dfbd558208271287739f Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Sat, 30 Mar 2013 13:31:03 -0700 Subject: [PATCH 17/18] std: add more json decoder tests. --- src/libstd/json.rs | 136 +++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 124 insertions(+), 12 deletions(-) diff --git a/src/libstd/json.rs b/src/libstd/json.rs index d6606981b1b6a..e090d6bc036d8 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -1173,6 +1173,22 @@ mod tests { Frog(~str, int) } + #[auto_encode] + #[auto_decode] + #[deriving(Eq)] + struct Inner { + a: (), + b: uint, + c: ~[~str], + } + + #[auto_encode] + #[auto_decode] + #[deriving(Eq)] + struct Outer { + inner: ~[Inner], + } + fn mk_object(items: &[(~str, Json)]) -> Json { let mut d = ~LinearMap::new(); @@ -1441,6 +1457,18 @@ mod tests { assert_eq!(from_str(~" false "), Ok(Boolean(false))); } + #[test] + fn test_decode_identifiers() { + let v: () = Decodable::decode(&Decoder(from_str(~"null").unwrap())); + assert_eq!(v, ()); + + let v: bool = Decodable::decode(&Decoder(from_str(~"true").unwrap())); + assert_eq!(v, true); + + let v: bool = Decodable::decode(&Decoder(from_str(~"false").unwrap())); + assert_eq!(v, false); + } + #[test] fn test_read_number() { assert_eq!(from_str(~"+"), @@ -1469,6 +1497,30 @@ mod tests { assert_eq!(from_str(~" 3 "), Ok(Number(3f))); } + #[test] + fn test_decode_numbers() { + let v: float = Decodable::decode(&Decoder(from_str(~"3").unwrap())); + assert_eq!(v, 3f); + + let v: float = Decodable::decode(&Decoder(from_str(~"3.1").unwrap())); + assert_eq!(v, 3.1f); + + let v: float = Decodable::decode(&Decoder(from_str(~"-1.2").unwrap())); + assert_eq!(v, -1.2f); + + let v: float = Decodable::decode(&Decoder(from_str(~"0.4").unwrap())); + assert_eq!(v, 0.4f); + + let v: float = Decodable::decode(&Decoder(from_str(~"0.4e5").unwrap())); + assert_eq!(v, 0.4e5f); + + let v: float = Decodable::decode(&Decoder(from_str(~"0.4e15").unwrap())); + assert_eq!(v, 0.4e15f); + + let v: float = Decodable::decode(&Decoder(from_str(~"0.4e-01").unwrap())); + assert_eq!(v, 0.4e-01f); + } + #[test] fn test_read_str() { assert_eq!(from_str(~"\""), @@ -1486,12 +1538,38 @@ mod tests { assert_eq!(from_str(~"\"\\r\""), Ok(String(~"\r"))); assert_eq!(from_str(~"\"\\t\""), Ok(String(~"\t"))); assert_eq!(from_str(~" \"foo\" "), Ok(String(~"foo"))); + assert_eq!(from_str(~"\"\\u12ab\""), Ok(String(~"\u12ab"))); + assert_eq!(from_str(~"\"\\uAB12\""), Ok(String(~"\uAB12"))); } #[test] - fn test_unicode_hex_escapes_in_str() { - assert_eq!(from_str(~"\"\\u12ab\""), Ok(String(~"\u12ab"))); - assert_eq!(from_str(~"\"\\uAB12\""), Ok(String(~"\uAB12"))); + fn test_decode_str() { + let v: ~str = Decodable::decode(&Decoder(from_str(~"\"\"").unwrap())); + assert_eq!(v, ~""); + + let v: ~str = Decodable::decode(&Decoder(from_str(~"\"foo\"").unwrap())); + assert_eq!(v, ~"foo"); + + let v: ~str = Decodable::decode(&Decoder(from_str(~"\"\\\"\"").unwrap())); + assert_eq!(v, ~"\""); + + let v: ~str = Decodable::decode(&Decoder(from_str(~"\"\\b\"").unwrap())); + assert_eq!(v, ~"\x08"); + + let v: ~str = Decodable::decode(&Decoder(from_str(~"\"\\n\"").unwrap())); + assert_eq!(v, ~"\n"); + + let v: ~str = Decodable::decode(&Decoder(from_str(~"\"\\r\"").unwrap())); + assert_eq!(v, ~"\r"); + + let v: ~str = Decodable::decode(&Decoder(from_str(~"\"\\t\"").unwrap())); + assert_eq!(v, ~"\t"); + + let v: ~str = Decodable::decode(&Decoder(from_str(~"\"\\u12ab\"").unwrap())); + assert_eq!(v, ~"\u12ab"); + + let v: ~str = Decodable::decode(&Decoder(from_str(~"\"\\uAB12\"").unwrap())); + assert_eq!(v, ~"\uAB12"); } #[test] @@ -1520,6 +1598,28 @@ mod tests { Ok(List(~[Number(2f), List(~[Number(4f), Number(1f)])]))); } + #[test] + fn test_decode_list() { + let v: ~[()] = Decodable::decode(&Decoder(from_str(~"[]").unwrap())); + assert_eq!(v, ~[]); + + let v: ~[()] = Decodable::decode(&Decoder(from_str(~"[null]").unwrap())); + assert_eq!(v, ~[()]); + + + let v: ~[bool] = Decodable::decode(&Decoder(from_str(~"[true]").unwrap())); + assert_eq!(v, ~[true]); + + let v: ~[bool] = Decodable::decode(&Decoder(from_str(~"[true]").unwrap())); + assert_eq!(v, ~[true]); + + let v: ~[int] = Decodable::decode(&Decoder(from_str(~"[3, 1]").unwrap())); + assert_eq!(v, ~[3, 1]); + + let v: ~[~[uint]] = Decodable::decode(&Decoder(from_str(~"[[3], [1, 2]]").unwrap())); + assert_eq!(v, ~[~[3], ~[1, 2]]); + } + #[test] fn test_read_object() { assert_eq!(from_str(~"{"), @@ -1612,35 +1712,47 @@ mod tests { } #[test] - fn test_read_none() { + fn test_decode_struct() { + let s = ~"{ + \"inner\": [ + { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] } + ] + }"; + let v: Outer = Decodable::decode(&Decoder(from_str(s).unwrap())); + assert_eq!( + v, + Outer { + inner: ~[ + Inner { a: (), b: 2, c: ~[~"abc", ~"xyz"] } + ] + } + ); + } + + #[test] + fn test_decode_option() { let decoder = Decoder(from_str(~"null").unwrap()); let value: Option<~str> = Decodable::decode(&decoder); assert_eq!(value, None); - } - #[test] - fn test_read_some() { let decoder = Decoder(from_str(~"\"jodhpurs\"").unwrap()); let value: Option<~str> = Decodable::decode(&decoder); assert_eq!(value, Some(~"jodhpurs")); } #[test] - fn test_read_enum_no_args() { + fn test_decode_enum() { let decoder = Decoder(from_str(~"\"Dog\"").unwrap()); let value: Animal = Decodable::decode(&decoder); assert_eq!(value, Dog); - } - #[test] - fn test_read_enum_multiple_args() { let decoder = Decoder(from_str(~"[\"Frog\",\"Henry\",349]").unwrap()); let value: Animal = Decodable::decode(&decoder); assert_eq!(value, Frog(~"Henry", 349)); } #[test] - fn test_read_map() { + fn test_decode_map() { let s = ~"{\"a\": \"Dog\", \"b\": [\"Frog\", \"Henry\", 349]}"; let decoder = Decoder(from_str(s).unwrap()); let mut map: LinearMap<~str, Animal> = Decodable::decode(&decoder); From 810c4d8a1e0bdae3c2aba86a8b93e20faecba283 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Sat, 30 Mar 2013 15:04:24 -0700 Subject: [PATCH 18/18] rustc: fix astencode test --- src/librustc/middle/astencode.rs | 13 +------------ 1 file changed, 1 insertion(+), 12 deletions(-) diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 8d34a7c69f583..b6b6730620e9e 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -1212,7 +1212,6 @@ fn mk_ctxt() -> @fake_ext_ctxt { #[cfg(test)] fn roundtrip(in_item: Option<@ast::item>) { use core::io; - use std::prettyprint; let in_item = in_item.get(); let bytes = do io::with_bytes_writer |wr| { @@ -1222,17 +1221,7 @@ fn roundtrip(in_item: Option<@ast::item>) { let ebml_doc = reader::Doc(@bytes); let out_item = decode_item_ast(ebml_doc); - let exp_str = do io::with_str_writer |w| { - in_item.encode(&prettyprint::Serializer(w)) - }; - let out_str = do io::with_str_writer |w| { - out_item.encode(&prettyprint::Serializer(w)) - }; - - debug!("expected string: %s", exp_str); - debug!("actual string : %s", out_str); - - assert!(exp_str == out_str); + assert_eq!(in_item, out_item); } #[test]