---

yaml
---
r: 228246
b: refs/heads/try
c: b83ec47
h: refs/heads/master
v: v3

Author: tbu-

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: aca2057ed5fb7af3f8905b2bc01f72fa001c35c8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: d99d4fbf70acce44c14448a572f7dce4cb883ce8
+refs/heads/try: b83ec47808c219cb8e85eeebb370be6466b2d690
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/src/libstd/sys/unix/mod.rs

@@ -75,28 +75,6 @@ pub fn decode_error_kind(errno: i32) -> ErrorKind {
     }
 }
 
-// Some system functions expect the user to pass a appropiately-sized buffer
-// without specifying its size. They will only report back whether the buffer
-// was large enough or not.
-//
-// The callback is yielded an uninitialized vector which can be passed to a
-// syscall. The closure is expected to return `Err(v)` with the passed vector
-// if the space was insufficient and `Ok(r)` if the syscall did not fail due to
-// insufficient space.
-fn fill_bytes_buf<F, T>(mut f: F) -> io::Result<T>
-    where F: FnMut(Vec<u8>) -> Result<io::Result<T>,Vec<u8>>,
-{
-    let mut buf = Vec::new();
-    let mut n = os::BUF_BYTES;
-    loop {
-        buf.reserve(n);
-        match f(buf) {
-            Err(b) => { buf = b; n *= 2; }
-            Ok(r) => return r,
-        }
-    }
-}
-
 pub fn cvt<T: One + PartialEq + Neg<Output=T>>(t: T) -> io::Result<T> {
     let one: T = T::one();
     if t == -one {

branches/try/src/libstd/sys/unix/os.rs

@@ -30,7 +30,7 @@ use sys::c;
 use sys::fd;
 use vec;
 
-pub const BUF_BYTES: usize = 2048;
+const GETCWD_BUF_BYTES: usize = 2048;
 const TMPBUF_SZ: usize = 128;
 
 /// Returns the platform-specific value of errno
@@ -94,22 +94,26 @@ pub fn error_string(errno: i32) -> String {
 }
 
 pub fn getcwd() -> io::Result<PathBuf> {
-    super::fill_bytes_buf(|mut buf| {
+    let mut buf = Vec::new();
+    let mut n = GETCWD_BUF_BYTES;
+    loop {
         unsafe {
+            buf.reserve(n);
             let ptr = buf.as_mut_ptr() as *mut libc::c_char;
-            Ok(if !libc::getcwd(ptr, buf.capacity() as libc::size_t).is_null() {
+            if !libc::getcwd(ptr, buf.capacity() as libc::size_t).is_null() {
                 let len = CStr::from_ptr(buf.as_ptr() as *const libc::c_char).to_bytes().len();
                 buf.set_len(len);
-                Ok(PathBuf::from(OsString::from_bytes(buf).unwrap()))
+                buf.shrink_to_fit();
+                return Ok(PathBuf::from(OsString::from_vec(buf)));
             } else {
                 let error = io::Error::last_os_error();
-                if error.raw_os_error().unwrap() == libc::ERANGE {
-                    return Err(buf);
+                if error.raw_os_error() != Some(libc::ERANGE) {
+                    return Err(error);
                 }
-                Err(error)
-            })
+            }
+            n *= 2;
         }
-    })
+    }
 }
 
 pub fn chdir(p: &path::Path) -> io::Result<()> {