---

yaml
---
r: 23994
b: refs/heads/master
c: d0d68c6
h: refs/heads/master
v: v3

Author: erickt

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: eb35039fe83d6d13b5c7c08fe761ab85374c96d0
+refs/heads/master: d0d68c6036275c0a190ad100d6eb36a537b76d80
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be

trunk/src/fuzzer/fuzzer.rs

@@ -219,12 +219,8 @@ fn under(n: uint, it: fn(uint)) {
     while i < n { it(i); i += 1u; }
 }
 
-fn devnull() -> io::Writer { io::mem_buffer_writer(io::mem_buffer()) }
-
 fn as_str(f: fn@(io::Writer)) -> ~str {
-    let buf = io::mem_buffer();
-    f(io::mem_buffer_writer(buf));
-    io::mem_buffer_str(buf)
+    io::with_str_writer(f)
 }
 
 fn check_variants_of_ast(crate: ast::crate, codemap: codemap::codemap,

trunk/src/libcore/io.rs

@@ -670,9 +670,12 @@ fn stderr() -> Writer { fd_writer(libc::STDERR_FILENO as c_int, false) }
 fn print(s: &str) { stdout().write_str(s); }
 fn println(s: &str) { stdout().write_line(s); }
 
-type MemBuffer = @{buf: DVec<u8>, mut pos: uint};
+struct BytesWriter {
+    buf: DVec<u8>,
+    mut pos: uint,
+}
 
-impl MemBuffer: Writer {
+impl @BytesWriter: Writer {
     fn write(v: &[const u8]) {
         do self.buf.swap |buf| {
             let mut buf <- buf;
@@ -701,27 +704,24 @@ impl MemBuffer: Writer {
     fn get_type() -> WriterType { File }
 }
 
-fn mem_buffer() -> MemBuffer {
-    @{buf: DVec(), mut pos: 0u}
+fn BytesWriter() -> @BytesWriter {
+    @BytesWriter { buf: DVec(), mut pos: 0u }
 }
-fn mem_buffer_writer(b: MemBuffer) -> Writer { b as Writer }
-fn mem_buffer_buf(b: MemBuffer) -> ~[u8] { b.buf.get() }
-fn mem_buffer_str(b: MemBuffer) -> ~str {
-    str::from_bytes(b.buf.get())
+
+fn with_bytes_writer(f: fn(Writer)) -> ~[u8] {
+    let wr = BytesWriter();
+    f(wr as Writer);
+    wr.buf.check_out(|buf| buf)
 }
 
 fn with_str_writer(f: fn(Writer)) -> ~str {
-    let buf = mem_buffer();
-    let wr = mem_buffer_writer(buf);
-    f(wr);
-    io::mem_buffer_str(buf)
-}
+    let mut v = with_bytes_writer(f);
+
+    // Make sure the vector has a trailing null and is proper utf8.
+    vec::push(v, 0);
+    assert str::is_utf8(v);
 
-fn with_buf_writer(f: fn(Writer)) -> ~[u8] {
-    let buf = mem_buffer();
-    let wr = mem_buffer_writer(buf);
-    f(wr);
-    io::mem_buffer_buf(buf)
+    unsafe { move ::unsafe::transmute(v) }
 }
 
 // Utility functions
@@ -946,18 +946,18 @@ mod tests {
     }
 
     #[test]
-    fn mem_buffer_overwrite() {
-        let mbuf = mem_buffer();
-        mbuf.write(~[0u8, 1u8, 2u8, 3u8]);
-        assert mem_buffer_buf(mbuf) == ~[0u8, 1u8, 2u8, 3u8];
-        mbuf.seek(-2, SeekCur);
-        mbuf.write(~[4u8, 5u8, 6u8, 7u8]);
-        assert mem_buffer_buf(mbuf) == ~[0u8, 1u8, 4u8, 5u8, 6u8, 7u8];
-        mbuf.seek(-2, SeekEnd);
-        mbuf.write(~[8u8]);
-        mbuf.seek(1, SeekSet);
-        mbuf.write(~[9u8]);
-        assert mem_buffer_buf(mbuf) == ~[0u8, 9u8, 4u8, 5u8, 8u8, 7u8];
+    fn bytes_buffer_overwrite() {
+        let wr = BytesWriter();
+        wr.write(~[0u8, 1u8, 2u8, 3u8]);
+        assert wr.buf.borrow(|buf| buf == ~[0u8, 1u8, 2u8, 3u8]);
+        wr.seek(-2, SeekCur);
+        wr.write(~[4u8, 5u8, 6u8, 7u8]);
+        assert wr.buf.borrow(|buf| buf == ~[0u8, 1u8, 4u8, 5u8, 6u8, 7u8]);
+        wr.seek(-2, SeekEnd);
+        wr.write(~[8u8]);
+        wr.seek(1, SeekSet);
+        wr.write(~[9u8]);
+        assert wr.buf.borrow(|buf| buf == ~[0u8, 9u8, 4u8, 5u8, 8u8, 7u8]);
     }
 }
 

trunk/src/libcore/sys.rs

@@ -99,10 +99,9 @@ pure fn refcount<T>(+t: @T) -> uint {
 
 pure fn log_str<T>(t: T) -> ~str {
     unsafe {
-        let buffer = io::mem_buffer();
-        let writer = io::mem_buffer_writer(buffer);
-        repr::write_repr(writer, &t);
-        return io::mem_buffer_str(buffer);  // XXX: Extra malloc and copy.
+        do io::with_str_writer |wr| {
+            repr::write_repr(wr, &t)
+        }
     }
 }
 

trunk/src/libcore/to_bytes.rs

@@ -373,10 +373,10 @@ trait ToBytes {
 
 impl<A: IterBytes> A: ToBytes {
     fn to_bytes(lsb0: bool) -> ~[u8] {
-        let buf = io::mem_buffer();
-        for self.iter_bytes(lsb0) |bytes| {
-            buf.write(bytes)
+        do io::with_bytes_writer |wr| {
+            for self.iter_bytes(lsb0) |bytes| {
+                wr.write(bytes)
+            }
         }
-        io::mem_buffer_buf(buf)
     }
 }

trunk/src/libstd/ebml.rs

@@ -631,10 +631,11 @@ fn test_option_int() {
 
     fn test_v(v: Option<int>) {
         debug!("v == %?", v);
-        let mbuf = io::mem_buffer();
-        let ebml_w = ebml::Writer(io::mem_buffer_writer(mbuf));
-        serialize_0(ebml_w, v);
-        let ebml_doc = ebml::Doc(@io::mem_buffer_buf(mbuf));
+        let bytes = do io::with_bytes_writer |wr| {
+            let ebml_w = ebml::Writer(wr);
+            serialize_0(ebml_w, v);
+        };
+        let ebml_doc = ebml::Doc(@bytes);
         let deser = ebml_deserializer(ebml_doc);
         let v1 = deserialize_0(deser);
         debug!("v1 == %?", v1);

trunk/src/libstd/test.rs

@@ -233,36 +233,33 @@ fn print_failures(st: ConsoleTestState) {
 
 #[test]
 fn should_sort_failures_before_printing_them() {
-    let buffer = io::mem_buffer();
-    let writer = io::mem_buffer_writer(buffer);
-
-    let test_a = {
-        name: ~"a",
-        testfn: fn~() { },
-        ignore: false,
-        should_fail: false
-    };
-
-    let test_b = {
-        name: ~"b",
-        testfn: fn~() { },
-        ignore: false,
-        should_fail: false
-    };
+    let s = do io::with_str_writer |wr| {
+        let test_a = {
+            name: ~"a",
+            testfn: fn~() { },
+            ignore: false,
+            should_fail: false
+        };
 
-    let st =
-        @{out: writer,
-          log_out: option::None,
-          use_color: false,
-          mut total: 0u,
-          mut passed: 0u,
-          mut failed: 0u,
-          mut ignored: 0u,
-          mut failures: ~[test_b, test_a]};
+        let test_b = {
+            name: ~"b",
+            testfn: fn~() { },
+            ignore: false,
+            should_fail: false
+        };
 
-    print_failures(st);
+        let st =
+            @{out: wr,
+              log_out: option::None,
+              use_color: false,
+              mut total: 0u,
+              mut passed: 0u,
+              mut failed: 0u,
+              mut ignored: 0u,
+              mut failures: ~[test_b, test_a]};
 
-    let s = io::mem_buffer_str(buffer);
+        print_failures(st);
+    };
 
     let apos = option::get(str::find_str(s, ~"a"));
     let bpos = option::get(str::find_str(s, ~"b"));

trunk/src/libsyntax/print/pprust.rs

@@ -125,13 +125,13 @@ fn path_to_str(&&p: @ast::path, intr: ident_interner) -> ~str {
 
 fn fun_to_str(decl: ast::fn_decl, name: ast::ident,
               params: ~[ast::ty_param], intr: ident_interner) -> ~str {
-    let buffer = io::mem_buffer();
-    let s = rust_printer(io::mem_buffer_writer(buffer), intr);
-    print_fn(s, decl, None, name, params, None);
-    end(s); // Close the head box
-    end(s); // Close the outer box
-    eof(s.s);
-    io::mem_buffer_str(buffer)
+    do io::with_str_writer |wr| {
+        let s = rust_printer(wr, intr);
+        print_fn(s, decl, None, name, params, None);
+        end(s); // Close the head box
+        end(s); // Close the outer box
+        eof(s.s);
+    }
 }
 
 #[test]
@@ -148,15 +148,15 @@ fn test_fun_to_str() {
 }
 
 fn block_to_str(blk: ast::blk, intr: ident_interner) -> ~str {
-    let buffer = io::mem_buffer();
-    let s = rust_printer(io::mem_buffer_writer(buffer), intr);
-    // containing cbox, will be closed by print-block at }
-    cbox(s, indent_unit);
-    // head-ibox, will be closed by print-block after {
-    ibox(s, 0u);
-    print_block(s, blk);
-    eof(s.s);
-    io::mem_buffer_str(buffer)
+    do io::with_str_writer |wr| {
+        let s = rust_printer(wr, intr);
+        // containing cbox, will be closed by print-block at }
+        cbox(s, indent_unit);
+        // head-ibox, will be closed by print-block after {
+        ibox(s, 0u);
+        print_block(s, blk);
+        eof(s.s);
+    }
 }
 
 fn meta_item_to_str(mi: @ast::meta_item, intr: ident_interner) -> ~str {
@@ -2026,11 +2026,11 @@ fn print_string(s: ps, st: ~str) {
 }
 
 fn to_str<T>(t: T, f: fn@(ps, T), intr: ident_interner) -> ~str {
-    let buffer = io::mem_buffer();
-    let s = rust_printer(io::mem_buffer_writer(buffer), intr);
-    f(s, t);
-    eof(s.s);
-    io::mem_buffer_str(buffer)
+    do io::with_str_writer |wr| {
+        let s = rust_printer(wr, intr);
+        f(s, t);
+        eof(s.s);
+    }
 }
 
 fn next_comment(s: ps) -> Option<comments::cmnt> {

trunk/src/rustc/metadata/encoder.rs

@@ -68,7 +68,6 @@ type stats = {
 enum encode_ctxt = {
     diag: span_handler,
     tcx: ty::ctxt,
-    buf: io::MemBuffer,
     stats: stats,
     reachable: HashMap<ast::node_id, ()>,
     reexports: ~[(~str, def_id)],
@@ -1089,7 +1088,7 @@ const metadata_encoding_version : &[u8] = &[0x72, //'r' as u8,
                                             0, 0, 0, 1 ];
 
 fn encode_metadata(parms: encode_parms, crate: @crate) -> ~[u8] {
-    let buf = io::mem_buffer();
+    let wr = io::BytesWriter();
     let stats =
         {mut inline_bytes: 0,
          mut attr_bytes: 0,
@@ -1102,7 +1101,6 @@ fn encode_metadata(parms: encode_parms, crate: @crate) -> ~[u8] {
     let ecx: @encode_ctxt = @encode_ctxt({
         diag: parms.diag,
         tcx: parms.tcx,
-        buf: buf,
         stats: move stats,
         reachable: parms.reachable,
         reexports: parms.reexports,
@@ -1115,37 +1113,36 @@ fn encode_metadata(parms: encode_parms, crate: @crate) -> ~[u8] {
         type_abbrevs: ty::new_ty_hash()
      });
 
-    let buf_w = io::mem_buffer_writer(buf);
-    let ebml_w = ebml::Writer(buf_w);
+    let ebml_w = ebml::Writer(wr as io::Writer);
 
     encode_hash(ebml_w, ecx.link_meta.extras_hash);
 
-    let mut i = buf.pos;
+    let mut i = wr.pos;
     let crate_attrs = synthesize_crate_attrs(ecx, crate);
     encode_attributes(ebml_w, crate_attrs);
-    ecx.stats.attr_bytes = buf.pos - i;
+    ecx.stats.attr_bytes = wr.pos - i;
 
-    i = buf.pos;
+    i = wr.pos;
     encode_crate_deps(ecx, ebml_w, ecx.cstore);
-    ecx.stats.dep_bytes = buf.pos - i;
+    ecx.stats.dep_bytes = wr.pos - i;
 
     // Encode and index the items.
     ebml_w.start_tag(tag_items);
-    i = buf.pos;
+    i = wr.pos;
     let items_index = encode_info_for_items(ecx, ebml_w, crate);
-    ecx.stats.item_bytes = buf.pos - i;
+    ecx.stats.item_bytes = wr.pos - i;
 
-    i = buf.pos;
+    i = wr.pos;
     let items_buckets = create_index(items_index, hash_node_id);
     encode_index(ebml_w, items_buckets, write_int);
-    ecx.stats.index_bytes = buf.pos - i;
+    ecx.stats.index_bytes = wr.pos - i;
     ebml_w.end_tag();
 
-    ecx.stats.total_bytes = buf.pos;
+    ecx.stats.total_bytes = wr.pos;
 
     if (parms.tcx.sess.meta_stats()) {
 
-        do buf.buf.borrow |v| {
+        do wr.buf.borrow |v| {
             do v.each |e| {
                 if e == 0 {
                     ecx.stats.zero_bytes += 1;
@@ -1166,7 +1163,7 @@ fn encode_metadata(parms: encode_parms, crate: @crate) -> ~[u8] {
 
     // Pad this, since something (LLVM, presumably) is cutting off the
     // remaining % 4 bytes.
-    buf_w.write(&[0u8, 0u8, 0u8, 0u8]);
+    wr.write(&[0u8, 0u8, 0u8, 0u8]);
 
     // FIXME #3396: weird bug here, for reasons unclear this emits random
     // looking bytes (mostly 0x1) if we use the version byte-array constant
@@ -1178,7 +1175,7 @@ fn encode_metadata(parms: encode_parms, crate: @crate) -> ~[u8] {
 
     (do str::as_bytes(~"rust\x00\x00\x00\x01") |bytes| {
         vec::slice(bytes, 0, 8)
-    }) + flate::deflate_bytes(io::mem_buffer_buf(buf))
+    }) + flate::deflate_bytes(wr.buf.check_out(|buf| buf))
 }
 
 // Get the encoded string for a type
@@ -1188,9 +1185,9 @@ fn encoded_ty(tcx: ty::ctxt, t: ty::t) -> ~str {
                tcx: tcx,
                reachable: |_id| false,
                abbrevs: tyencode::ac_no_abbrevs};
-    let buf = io::mem_buffer();
-    tyencode::enc_ty(io::mem_buffer_writer(buf), cx, t);
-    return io::mem_buffer_str(buf);
+    do io::with_str_writer |wr| {
+        tyencode::enc_ty(wr, cx, t);
+    }
 }