---

yaml
---
r: 28574
b: refs/heads/try
c: 5d925b2
h: refs/heads/master
v: v3

Author: Dretch

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
-refs/heads/try: e3f5403052e53b557998315fae780b5431a8ce0b
+refs/heads/try: 5d925b212e0dcfa3d754f86ba61d8e85d23e54ee
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df

branches/try/src/fuzzer/fuzzer.rs

@@ -219,8 +219,12 @@ 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 {
-    io::with_str_writer(f)
+    let buf = io::mem_buffer();
+    f(io::mem_buffer_writer(buf));
+    io::mem_buffer_str(buf)
 }
 
 fn check_variants_of_ast(crate: ast::crate, codemap: codemap::codemap,

branches/try/src/libcore/io.rs

@@ -670,12 +670,9 @@ 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); }
 
-struct BytesWriter {
-    buf: DVec<u8>,
-    mut pos: uint,
-}
+type MemBuffer = @{buf: DVec<u8>, mut pos: uint};
 
-impl @BytesWriter: Writer {
+impl MemBuffer: Writer {
     fn write(v: &[const u8]) {
         do self.buf.swap |buf| {
             let mut buf <- buf;
@@ -704,24 +701,27 @@ impl @BytesWriter: Writer {
     fn get_type() -> WriterType { File }
 }
 
-fn BytesWriter() -> @BytesWriter {
-    @BytesWriter { buf: DVec(), mut pos: 0u }
+fn mem_buffer() -> MemBuffer {
+    @{buf: DVec(), mut pos: 0u}
 }
-
-fn with_bytes_writer(f: fn(Writer)) -> ~[u8] {
-    let wr = BytesWriter();
-    f(wr as Writer);
-    wr.buf.check_out(|buf| buf)
+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_str_writer(f: fn(Writer)) -> ~str {
-    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);
+    let buf = mem_buffer();
+    let wr = mem_buffer_writer(buf);
+    f(wr);
+    io::mem_buffer_str(buf)
+}
 
-    unsafe { move ::unsafe::transmute(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)
 }
 
 // Utility functions
@@ -946,18 +946,18 @@ mod tests {
     }
 
     #[test]
-    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]);
+    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];
     }
 }
 

branches/try/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,6 +2003,14 @@ 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))
@@ -2023,13 +2031,6 @@ 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.
      *

branches/try/src/libcore/sys.rs

@@ -99,9 +99,10 @@ pure fn refcount<T>(+t: @T) -> uint {
 
 pure fn log_str<T>(t: T) -> ~str {
     unsafe {
-        do io::with_str_writer |wr| {
-            repr::write_repr(wr, &t)
-        }
+        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.
     }
 }
 

branches/try/src/libcore/to_bytes.rs

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

branches/try/src/libcore/vec.rs

@@ -1625,6 +1625,7 @@ 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));
@@ -1647,6 +1648,10 @@ 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) }
@@ -2909,17 +2914,14 @@ 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 = view(v, 1u, 3u);
+        let v = v.view(1u, 3u);
         assert(len(v) == 2u);
         assert(v[0] == 2);
         assert(v[1] == 3);
     }
-*/
 }
 
 // Local Variables:

branches/try/src/libstd/ebml.rs

@@ -631,11 +631,10 @@ fn test_option_int() {
 
     fn test_v(v: Option<int>) {
         debug!("v == %?", v);
-        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 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 deser = ebml_deserializer(ebml_doc);
         let v1 = deserialize_0(deser);
         debug!("v1 == %?", v1);

branches/try/src/libstd/test.rs

@@ -233,33 +233,36 @@ fn print_failures(st: ConsoleTestState) {
 
 #[test]
 fn should_sort_failures_before_printing_them() {
-    let s = do io::with_str_writer |wr| {
-        let test_a = {
-            name: ~"a",
-            testfn: fn~() { },
-            ignore: false,
-            should_fail: false
-        };
+    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 test_b = {
+        name: ~"b",
+        testfn: fn~() { },
+        ignore: false,
+        should_fail: false
+    };
 
-        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 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]};
 
-        print_failures(st);
-    };
+    print_failures(st);
+
+    let s = io::mem_buffer_str(buffer);
 
     let apos = option::get(str::find_str(s, ~"a"));
     let bpos = option::get(str::find_str(s, ~"b"));

branches/try/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 {
-    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);
-    }
+    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)
 }
 
 #[test]
@@ -148,15 +148,15 @@ fn test_fun_to_str() {
 }
 
 fn block_to_str(blk: ast::blk, intr: ident_interner) -> ~str {
-    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);
-    }
+    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)
 }
 
 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 {
-    do io::with_str_writer |wr| {
-        let s = rust_printer(wr, intr);
-        f(s, t);
-        eof(s.s);
-    }
+    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)
 }
 
 fn next_comment(s: ps) -> Option<comments::cmnt> {