---

yaml
---
r: 146170
b: refs/heads/try2
c: c4907cf
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 620ab3853abf99ecea3a3d055f47cd6d06433c95
+refs/heads/try2: c4907cfd14f9afa1fc26e2fdddf128f834fe5ce5
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libextra/ebml.rs

@@ -96,17 +96,8 @@ pub mod reader {
 
     use std::cast::transmute;
     use std::int;
-    use std::io;
     use std::option::{None, Option, Some};
 
-    #[cfg(target_arch = "x86")]
-    #[cfg(target_arch = "x86_64")]
-    use std::ptr::offset;
-
-    #[cfg(target_arch = "x86")]
-    #[cfg(target_arch = "x86_64")]
-    use std::unstable::intrinsics::bswap32;
-
     // ebml reading
 
     struct Res {
@@ -144,6 +135,9 @@ pub mod reader {
     #[cfg(target_arch = "x86")]
     #[cfg(target_arch = "x86_64")]
     pub fn vuint_at(data: &[u8], start: uint) -> Res {
+        use std::ptr::offset;
+        use std::unstable::intrinsics::bswap32;
+
         if data.len() - start < 4 {
             return vuint_at_slow(data, start);
         }
@@ -178,8 +172,7 @@ pub mod reader {
         }
     }
 
-    #[cfg(target_arch = "arm")]
-    #[cfg(target_arch = "mips")]
+    #[cfg(not(target_arch = "x86"), not(target_arch = "x86_64"))]
     pub fn vuint_at(data: &[u8], start: uint) -> Res {
         vuint_at_slow(data, start)
     }
@@ -265,17 +258,17 @@ pub mod reader {
 
     pub fn doc_as_u16(d: Doc) -> u16 {
         assert_eq!(d.end, d.start + 2u);
-        io::u64_from_be_bytes(*d.data, d.start, 2u) as u16
+        ::std::io::u64_from_be_bytes(*d.data, d.start, 2u) as u16
     }
 
     pub fn doc_as_u32(d: Doc) -> u32 {
         assert_eq!(d.end, d.start + 4u);
-        io::u64_from_be_bytes(*d.data, d.start, 4u) as u32
+        ::std::io::u64_from_be_bytes(*d.data, d.start, 4u) as u32
     }
 
     pub fn doc_as_u64(d: Doc) -> u64 {
         assert_eq!(d.end, d.start + 8u);
-        io::u64_from_be_bytes(*d.data, d.start, 8u)
+        ::std::io::u64_from_be_bytes(*d.data, d.start, 8u)
     }
 
     pub fn doc_as_i8(d: Doc) -> i8 { doc_as_u8(d) as i8 }
@@ -614,11 +607,14 @@ pub mod writer {
 
     use std::cast;
     use std::clone::Clone;
-    use std::io;
+    use std::rt::io;
+    use std::rt::io::{Writer, Seek};
+    use std::rt::io::mem::MemWriter;
 
     // ebml writing
     pub struct Encoder {
-        writer: @io::Writer,
+        // FIXME(#5665): this should take a trait object
+        writer: @mut MemWriter,
         priv size_positions: ~[uint],
     }
 
@@ -631,7 +627,7 @@ pub mod writer {
         }
     }
 
-    fn write_sized_vuint(w: @io::Writer, n: uint, size: uint) {
+    fn write_sized_vuint(w: @mut MemWriter, n: uint, size: uint) {
         match size {
             1u => w.write(&[0x80u8 | (n as u8)]),
             2u => w.write(&[0x40u8 | ((n >> 8_u) as u8), n as u8]),
@@ -643,15 +639,15 @@ pub mod writer {
         };
     }
 
-    fn write_vuint(w: @io::Writer, n: uint) {
+    fn write_vuint(w: @mut MemWriter, n: uint) {
         if n < 0x7f_u { write_sized_vuint(w, n, 1u); return; }
         if n < 0x4000_u { write_sized_vuint(w, n, 2u); return; }
         if n < 0x200000_u { write_sized_vuint(w, n, 3u); return; }
         if n < 0x10000000_u { write_sized_vuint(w, n, 4u); return; }
         fail!("vint to write too big: {}", n);
     }
 
-    pub fn Encoder(w: @io::Writer) -> Encoder {
+    pub fn Encoder(w: @mut MemWriter) -> Encoder {
         let size_positions: ~[uint] = ~[];
         Encoder {
             writer: w,
@@ -668,18 +664,18 @@ pub mod writer {
             write_vuint(self.writer, tag_id);
 
             // Write a placeholder four-byte size.
-            self.size_positions.push(self.writer.tell());
+            self.size_positions.push(self.writer.tell() as uint);
             let zeroes: &[u8] = &[0u8, 0u8, 0u8, 0u8];
             self.writer.write(zeroes);
         }
 
         pub fn end_tag(&mut self) {
             let last_size_pos = self.size_positions.pop();
             let cur_pos = self.writer.tell();
-            self.writer.seek(last_size_pos as int, io::SeekSet);
-            let size = (cur_pos - last_size_pos - 4u);
-            write_sized_vuint(self.writer, size, 4u);
-            self.writer.seek(cur_pos as int, io::SeekSet);
+            self.writer.seek(last_size_pos as i64, io::SeekSet);
+            let size = (cur_pos as uint - last_size_pos - 4);
+            write_sized_vuint(self.writer, size as uint, 4u);
+            self.writer.seek(cur_pos as i64, io::SeekSet);
 
             debug!("End tag (size = {})", size);
         }
@@ -697,19 +693,19 @@ pub mod writer {
         }
 
         pub fn wr_tagged_u64(&mut self, tag_id: uint, v: u64) {
-            do io::u64_to_be_bytes(v, 8u) |v| {
+            do ::std::io::u64_to_be_bytes(v, 8u) |v| {
                 self.wr_tagged_bytes(tag_id, v);
             }
         }
 
         pub fn wr_tagged_u32(&mut self, tag_id: uint, v: u32) {
-            do io::u64_to_be_bytes(v as u64, 4u) |v| {
+            do ::std::io::u64_to_be_bytes(v as u64, 4u) |v| {
                 self.wr_tagged_bytes(tag_id, v);
             }
         }
 
         pub fn wr_tagged_u16(&mut self, tag_id: uint, v: u16) {
-            do io::u64_to_be_bytes(v as u64, 2u) |v| {
+            do ::std::io::u64_to_be_bytes(v as u64, 2u) |v| {
                 self.wr_tagged_bytes(tag_id, v);
             }
         }
@@ -719,19 +715,19 @@ pub mod writer {
         }
 
         pub fn wr_tagged_i64(&mut self, tag_id: uint, v: i64) {
-            do io::u64_to_be_bytes(v as u64, 8u) |v| {
+            do ::std::io::u64_to_be_bytes(v as u64, 8u) |v| {
                 self.wr_tagged_bytes(tag_id, v);
             }
         }
 
         pub fn wr_tagged_i32(&mut self, tag_id: uint, v: i32) {
-            do io::u64_to_be_bytes(v as u64, 4u) |v| {
+            do ::std::io::u64_to_be_bytes(v as u64, 4u) |v| {
                 self.wr_tagged_bytes(tag_id, v);
             }
         }
 
         pub fn wr_tagged_i16(&mut self, tag_id: uint, v: i16) {
-            do io::u64_to_be_bytes(v as u64, 2u) |v| {
+            do ::std::io::u64_to_be_bytes(v as u64, 2u) |v| {
                 self.wr_tagged_bytes(tag_id, v);
             }
         }
@@ -963,18 +959,18 @@ mod tests {
     use serialize::Encodable;
     use serialize;
 
-    use std::io;
+    use std::rt::io::Decorator;
+    use std::rt::io::mem::MemWriter;
     use std::option::{None, Option, Some};
 
     #[test]
     fn test_option_int() {
         fn test_v(v: Option<int>) {
             debug!("v == {:?}", v);
-            let bytes = do io::with_bytes_writer |wr| {
-                let mut ebml_w = writer::Encoder(wr);
-                v.encode(&mut ebml_w)
-            };
-            let ebml_doc = reader::Doc(@bytes);
+            let wr = @mut MemWriter::new();
+            let mut ebml_w = writer::Encoder(wr);
+            v.encode(&mut ebml_w);
+            let ebml_doc = reader::Doc(@wr.inner_ref().to_owned());
             let mut deser = reader::Decoder(ebml_doc);
             let v1 = serialize::Decodable::decode(&mut deser);
             debug!("v1 == {:?}", v1);

branches/try2/src/libextra/uuid.rs

@@ -522,6 +522,8 @@ mod test {
     use std::str;
     use std::rand;
     use std::num::Zero;
+    use std::rt::io::Decorator;
+    use std::rt::io::mem::MemWriter;
 
     #[test]
     fn test_new_nil() {
@@ -795,10 +797,10 @@ mod test {
         use serialize::{Encodable, Decodable};
 
         let u = Uuid::new_v4();
-        let bytes = do std::io::with_bytes_writer |wr| {
-            u.encode(&mut ebml::writer::Encoder(wr));
-        };
-        let u2 = Decodable::decode(&mut ebml::reader::Decoder(ebml::reader::Doc(@bytes)));
+        let wr = @mut MemWriter::new();
+        u.encode(&mut ebml::writer::Encoder(wr));
+        let doc = ebml::reader::Doc(@wr.inner_ref().to_owned());
+        let u2 = Decodable::decode(&mut ebml::reader::Decoder(doc));
         assert_eq!(u, u2);
     }
 }