---

yaml
---
r: 23997
b: refs/heads/master
c: 2ac64d9
h: refs/heads/master
i:
  23995: e30c999
v: v3

Author: nikomatsakis

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 5d925b212e0dcfa3d754f86ba61d8e85d23e54ee
+refs/heads/master: 2ac64d91ac9df242c780d162863c8c0abce448b1
 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/str.rs

@@ -1967,10 +1967,10 @@ mod raw {
    export
       from_buf,
       from_buf_len,
-      from_buf_len_nocopy,
       from_c_str,
       from_c_str_len,
       from_bytes,
+      form_slice,
       slice_bytes,
       view_bytes,
       push_byte,
@@ -2003,14 +2003,6 @@ mod raw {
         return ::unsafe::transmute(move v);
     }
 
-    /// Create a Rust string from a *u8 buffer of the given length
-    /// without copying
-    unsafe fn from_buf_len_nocopy(buf: &a / *u8, len: uint) -> &a / str {
-        let v = (*buf, len + 1);
-        assert is_utf8(::unsafe::reinterpret_cast(&v));
-        return ::unsafe::transmute(move v);
-    }
-
     /// Create a Rust string from a null-terminated C string
     unsafe fn from_c_str(c_str: *libc::c_char) -> ~str {
         from_buf(::unsafe::reinterpret_cast(&c_str))
@@ -2031,6 +2023,13 @@ mod raw {
     /// Converts a byte to a string.
     unsafe fn from_byte(u: u8) -> ~str { raw::from_bytes([u]) }
 
+    /// Form a slice from a *u8 buffer of the given length without copying.
+    unsafe fn buf_as_slice<T>(buf: *u8, len: uint, f: fn(&& &str) -> T) -> T {
+        let v = (*buf, len + 1);
+        assert is_utf8(::unsafe::reinterpret_cast(&v));
+        f(::unsafe::transmute(move v))
+    }
+
     /**
      * Takes a bytewise (not UTF-8) slice from a string.
      *

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/libcore/vec.rs

@@ -1625,7 +1625,6 @@ impl<T: Copy> &[const T]: CopyableVector<T> {
 }
 
 trait ImmutableVector<T> {
-    pure fn view(start: uint, end: uint) -> &[T];
     pure fn foldr<U: Copy>(z: U, p: fn(T, U) -> U) -> U;
     pure fn iter(f: fn(T));
     pure fn iteri(f: fn(uint, T));
@@ -1648,10 +1647,6 @@ trait ImmutableEqVector<T: Eq> {
 
 /// Extension methods for vectors
 impl<T> &[T]: ImmutableVector<T> {
-    /// Return a slice that points into another slice.
-    pure fn view(start: uint, end: uint) -> &[T] {
-        view(self, start, end)
-    }
     /// Reduce a vector from right to left
     #[inline]
     pure fn foldr<U: Copy>(z: U, p: fn(T, U) -> U) -> U { foldr(self, z, p) }
@@ -2914,14 +2909,17 @@ mod tests {
         assert capacity(v) == 10u;
     }
 
+/*
     #[test]
+    #[ignore] // region inference doesn't work well enough for this yet.
     fn test_view() {
         let v = ~[1, 2, 3, 4, 5];
-        let v = v.view(1u, 3u);
+        let v = view(v, 1u, 3u);
         assert(len(v) == 2u);
         assert(v[0] == 2);
         assert(v[1] == 3);
     }
+*/
 }
 
 // Local Variables:

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> {