---

yaml
---
r: 111595
b: refs/heads/master
c: b536d2b
h: refs/heads/master
i:
  111593: 5c0c2e3
  111591: 3f4b165
v: v3

Author: aturon

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 3485d90728fe8dc076c6362211bf1f62830c97d8
+refs/heads/master: b536d2bb763d478dbf96c035dbd5b68b5ff639b9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b5dd3f05fe95168b5569d0f519636149479eb6ac
 refs/heads/try: 38201d7c6bf0c32b0e5bdc8ecd63976ebc1b3a4c

trunk/src/compiletest/compiletest.rs

@@ -267,8 +267,7 @@ pub fn test_opts(config: &config) -> test::TestOpts {
         ratchet_metrics: config.ratchet_metrics.clone(),
         ratchet_noise_percent: config.ratchet_noise_percent.clone(),
         save_metrics: config.save_metrics.clone(),
-        test_shard: config.test_shard.clone(),
-        nocapture: false,
+        test_shard: config.test_shard.clone()
     }
 }
 

trunk/src/compiletest/runtest.rs

@@ -955,7 +955,6 @@ fn fatal(err: ~str) -> ! { error(err); fail!(); }
 fn fatal_ProcRes(err: ~str, proc_res: &ProcRes) -> ! {
     print!("\n\
 error: {}\n\
-status: {}\n\
 command: {}\n\
 stdout:\n\
 ------------------------------------------\n\
@@ -966,8 +965,7 @@ stderr:\n\
 {}\n\
 ------------------------------------------\n\
 \n",
-             err, proc_res.status, proc_res.cmdline, proc_res.stdout,
-             proc_res.stderr);
+             err, proc_res.cmdline, proc_res.stdout, proc_res.stderr);
     fail!();
 }
 

trunk/src/librustuv/async.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 use std::cast;
+use libc::c_int;
 use std::rt::rtio::{Callback, RemoteCallback};
 use std::unstable::sync::Exclusive;
 
@@ -53,7 +54,8 @@ impl UvHandle<uvll::uv_async_t> for AsyncWatcher {
     }
 }
 
-extern fn async_cb(handle: *uvll::uv_async_t) {
+extern fn async_cb(handle: *uvll::uv_async_t, status: c_int) {
+    assert!(status == 0);
     let payload: &mut Payload = unsafe {
         cast::transmute(uvll::get_data_for_uv_handle(handle))
     };

trunk/src/librustuv/file.rs

@@ -12,7 +12,7 @@ use std::c_str::CString;
 use std::c_str;
 use std::cast::transmute;
 use std::cast;
-use libc::{c_int, c_char, c_void, ssize_t};
+use libc::{c_int, c_char, c_void, size_t, ssize_t};
 use libc;
 use std::rt::task::BlockedTask;
 use std::io::{FileStat, IoError};
@@ -86,12 +86,14 @@ impl FsRequest {
             } else {
                 offset + written as i64
             };
-            let uvbuf = uvll::uv_buf_t {
-                base: buf.slice_from(written as uint).as_ptr(),
-                len: (buf.len() - written) as uvll::uv_buf_len_t,
-            };
             match execute(|req, cb| unsafe {
-                uvll::uv_fs_write(loop_.handle, req, fd, &uvbuf, 1, offset, cb)
+                uvll::uv_fs_write(loop_.handle,
+                                  req,
+                                  fd,
+                                  buf.as_ptr().offset(written as int) as *c_void,
+                                  (buf.len() - written) as size_t,
+                                  offset,
+                                  cb)
             }).map(|req| req.get_result()) {
                 Err(e) => return Err(e),
                 Ok(n) => { written += n as uint; }
@@ -104,11 +106,9 @@ impl FsRequest {
         -> Result<int, UvError>
     {
         execute(|req, cb| unsafe {
-            let uvbuf = uvll::uv_buf_t {
-                base: buf.as_ptr(),
-                len: buf.len() as uvll::uv_buf_len_t,
-            };
-            uvll::uv_fs_read(loop_.handle, req, fd, &uvbuf, 1, offset, cb)
+            uvll::uv_fs_read(loop_.handle, req,
+                             fd, buf.as_ptr() as *c_void,
+                             buf.len() as size_t, offset, cb)
         }).map(|req| {
             req.get_result() as int
         })

trunk/src/librustuv/idle.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use std::cast;
-use libc::c_void;
+use libc::{c_int, c_void};
 
 use uvll;
 use super::{Loop, UvHandle};
@@ -46,7 +46,8 @@ impl IdleWatcher {
             assert_eq!(uvll::uv_idle_start(handle, onetime_cb), 0)
         }
 
-        extern fn onetime_cb(handle: *uvll::uv_idle_t) {
+        extern fn onetime_cb(handle: *uvll::uv_idle_t, status: c_int) {
+            assert_eq!(status, 0);
             unsafe {
                 let data = uvll::get_data_for_uv_handle(handle);
                 let f: ~proc() = cast::transmute(data);
@@ -81,7 +82,8 @@ impl UvHandle<uvll::uv_idle_t> for IdleWatcher {
     fn uv_handle(&self) -> *uvll::uv_idle_t { self.handle }
 }
 
-extern fn idle_cb(handle: *uvll::uv_idle_t) {
+extern fn idle_cb(handle: *uvll::uv_idle_t, status: c_int) {
+    assert_eq!(status, 0);
     let idle: &mut IdleWatcher = unsafe { UvHandle::from_uv_handle(&handle) };
     idle.callback.call();
 }

trunk/src/librustuv/net.rs

@@ -255,9 +255,10 @@ impl TcpWatcher {
             n => Err(UvError(n))
         };
 
-        extern fn timer_cb(handle: *uvll::uv_timer_t) {
+        extern fn timer_cb(handle: *uvll::uv_timer_t, status: c_int) {
             // Don't close the corresponding tcp request, just wake up the task
             // and let RAII take care of the pending watcher.
+            assert_eq!(status, 0);
             let cx: &mut Ctx = unsafe {
                 &mut *(uvll::get_data_for_uv_handle(handle) as *mut Ctx)
             };
@@ -598,7 +599,8 @@ impl rtio::RtioTcpAcceptor for TcpAcceptor {
         self.timeout_tx = Some(tx);
         self.timeout_rx = Some(rx);
 
-        extern fn timer_cb(timer: *uvll::uv_timer_t) {
+        extern fn timer_cb(timer: *uvll::uv_timer_t, status: c_int) {
+            assert_eq!(status, 0);
             let acceptor: &mut TcpAcceptor = unsafe {
                 &mut *(uvll::get_data_for_uv_handle(timer) as *mut TcpAcceptor)
             };

trunk/src/librustuv/queue.rs

@@ -21,7 +21,7 @@
 #![allow(dead_code)]
 
 use std::cast;
-use libc::c_void;
+use libc::{c_void, c_int};
 use std::rt::task::BlockedTask;
 use std::unstable::mutex::NativeMutex;
 use std::sync::arc::UnsafeArc;
@@ -55,7 +55,8 @@ pub struct Queue {
     queue: UnsafeArc<State>,
 }
 
-extern fn async_cb(handle: *uvll::uv_async_t) {
+extern fn async_cb(handle: *uvll::uv_async_t, status: c_int) {
+    assert_eq!(status, 0);
     let pool: &mut QueuePool = unsafe {
         cast::transmute(uvll::get_data_for_uv_handle(handle))
     };

trunk/src/librustuv/timer.rs

@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use libc::c_int;
 use std::mem;
 use std::rt::rtio::RtioTimer;
 use std::rt::task::BlockedTask;
@@ -136,8 +137,9 @@ impl RtioTimer for TimerWatcher {
     }
 }
 
-extern fn timer_cb(handle: *uvll::uv_timer_t) {
+extern fn timer_cb(handle: *uvll::uv_timer_t, status: c_int) {
     let _f = ForbidSwitch::new("timer callback can't switch");
+    assert_eq!(status, 0);
     let timer: &mut TimerWatcher = unsafe { UvHandle::from_uv_handle(&handle) };
 
     match timer.action.take_unwrap() {

trunk/src/librustuv/tty.rs

@@ -40,7 +40,7 @@ impl TtyWatcher {
         // - https://github.com/joyent/libuv/issues/982
         // - https://github.com/joyent/libuv/issues/988
         let guess = unsafe { uvll::guess_handle(fd) };
-        if guess != uvll::UV_TTY as libc::c_int {
+        if readable && guess != uvll::UV_TTY as libc::c_int {
             return Err(UvError(uvll::EBADF));
         }
 

trunk/src/librustuv/uvio.rs

@@ -23,7 +23,7 @@ use libc::{O_CREAT, O_APPEND, O_TRUNC, O_RDWR, O_RDONLY, O_WRONLY, S_IRUSR,
 use libc;
 use std::path::Path;
 use std::rt::rtio;
-use std::rt::rtio::{IoFactory, EventLoop};
+use std::rt::rtio::IoFactory;
 use ai = std::io::net::addrinfo;
 
 #[cfg(test)] use std::unstable::run_in_bare_thread;
@@ -69,20 +69,14 @@ impl Drop for UvEventLoop {
         // the loop is free'd (use-after-free). We also must free the uv handle
         // after the loop has been closed because during the closing of the loop
         // the handle is required to be used apparently.
-        //
-        // Lastly, after we've closed the pool of handles we pump the event loop
-        // one last time to run any closing callbacks to make sure the loop
-        // shuts down cleanly.
         let handle = self.uvio.handle_pool.get_ref().handle();
         drop(self.uvio.handle_pool.take());
-        self.run();
-
         self.uvio.loop_.close();
         unsafe { uvll::free_handle(handle) }
     }
 }
 
-impl EventLoop for UvEventLoop {
+impl rtio::EventLoop for UvEventLoop {
     fn run(&mut self) {
         self.uvio.loop_.run();
     }
@@ -116,6 +110,7 @@ impl EventLoop for UvEventLoop {
 
 #[test]
 fn test_callback_run_once() {
+    use std::rt::rtio::EventLoop;
     run_in_bare_thread(proc() {
         let mut event_loop = UvEventLoop::new();
         let mut count = 0;

trunk/src/librustuv/uvll.rs

@@ -212,7 +212,8 @@ impl uv_stat_t {
     }
 }
 
-pub type uv_idle_cb = extern "C" fn(handle: *uv_idle_t);
+pub type uv_idle_cb = extern "C" fn(handle: *uv_idle_t,
+                                    status: c_int);
 pub type uv_alloc_cb = extern "C" fn(stream: *uv_stream_t,
                                      suggested_size: size_t,
                                      buf: *mut uv_buf_t);
@@ -229,12 +230,14 @@ pub type uv_udp_recv_cb = extern "C" fn(handle: *uv_udp_t,
 pub type uv_close_cb = extern "C" fn(handle: *uv_handle_t);
 pub type uv_walk_cb = extern "C" fn(handle: *uv_handle_t,
                                     arg: *c_void);
-pub type uv_async_cb = extern "C" fn(handle: *uv_async_t);
+pub type uv_async_cb = extern "C" fn(handle: *uv_async_t,
+                                     status: c_int);
 pub type uv_connect_cb = extern "C" fn(handle: *uv_connect_t,
                                        status: c_int);
 pub type uv_connection_cb = extern "C" fn(handle: *uv_connection_t,
                                           status: c_int);
-pub type uv_timer_cb = extern "C" fn(handle: *uv_timer_t);
+pub type uv_timer_cb = extern "C" fn(handle: *uv_timer_t,
+                                     status: c_int);
 pub type uv_write_cb = extern "C" fn(handle: *uv_write_t,
                                      status: c_int);
 pub type uv_getaddrinfo_cb = extern "C" fn(req: *uv_getaddrinfo_t,
@@ -594,12 +597,10 @@ extern {
                       flags: c_int, mode: c_int, cb: uv_fs_cb) -> c_int;
     pub fn uv_fs_unlink(loop_ptr: *uv_loop_t, req: *uv_fs_t, path: *c_char,
                         cb: uv_fs_cb) -> c_int;
-    pub fn uv_fs_write(l: *uv_loop_t, req: *uv_fs_t, fd: c_int,
-                       bufs: *uv_buf_t, nbufs: c_uint,
-                       offset: i64, cb: uv_fs_cb) -> c_int;
-    pub fn uv_fs_read(l: *uv_loop_t, req: *uv_fs_t, fd: c_int,
-                      bufs: *uv_buf_t, nbufs: c_uint,
-                      offset: i64, cb: uv_fs_cb) -> c_int;
+    pub fn uv_fs_write(l: *uv_loop_t, req: *uv_fs_t, fd: c_int, buf: *c_void,
+                       len: size_t, offset: i64, cb: uv_fs_cb) -> c_int;
+    pub fn uv_fs_read(l: *uv_loop_t, req: *uv_fs_t, fd: c_int, buf: *c_void,
+                      len: size_t, offset: i64, cb: uv_fs_cb) -> c_int;
     pub fn uv_fs_close(l: *uv_loop_t, req: *uv_fs_t, fd: c_int,
                        cb: uv_fs_cb) -> c_int;
     pub fn uv_fs_stat(l: *uv_loop_t, req: *uv_fs_t, path: *c_char,

trunk/src/libstd/hash/sip.rs

@@ -364,7 +364,7 @@ mod tests {
     use option::{Some, None};
     use str::{Str,StrSlice};
     use strbuf::StrBuf;
-    use slice::{Vector, ImmutableVector};
+    use slice::{Vector, ImmutableVector, OwnedVector};
     use self::test::Bencher;
 
     use super::super::Hash;

trunk/src/libstd/io/fs.rs

@@ -491,7 +491,8 @@ pub fn readdir(path: &Path) -> IoResult<Vec<Path>> {
 
 /// Returns an iterator which will recursively walk the directory structure
 /// rooted at `path`. The path given will not be iterated over, and this will
-/// perform iteration in a top-down order.
+/// perform iteration in some top-down order.  The contents of unreadable
+/// subdirectories are ignored.
 pub fn walk_dir(path: &Path) -> IoResult<Directories> {
     Ok(Directories { stack: try!(readdir(path)) })
 }
@@ -503,7 +504,7 @@ pub struct Directories {
 
 impl Iterator<Path> for Directories {
     fn next(&mut self) -> Option<Path> {
-        match self.stack.shift() {
+        match self.stack.pop() {
             Some(path) => {
                 if path.is_dir() {
                     match readdir(&path) {
@@ -970,6 +971,32 @@ mod test {
         check!(rmdir(dir));
     })
 
+    iotest!(fn file_test_walk_dir() {
+        let tmpdir = tmpdir();
+        let dir = &tmpdir.join("walk_dir");
+        check!(mkdir(dir, io::UserRWX));
+
+        let dir1 = &dir.join("01/02/03");
+        check!(mkdir_recursive(dir1, io::UserRWX));
+        check!(File::create(&dir1.join("04")));
+
+        let dir2 = &dir.join("11/12/13");
+        check!(mkdir_recursive(dir2, io::UserRWX));
+        check!(File::create(&dir2.join("14")));
+
+        let mut files = check!(walk_dir(dir));
+        let mut cur = [0u8, .. 2];
+        for f in files {
+            let stem = f.filestem_str().unwrap();
+            let root = stem[0] - ('0' as u8);
+            let name = stem[1] - ('0' as u8);
+            assert!(cur[root as uint] < name);
+            cur[root as uint] = name;
+        }
+
+        check!(rmdir_recursive(dir));
+    })
+
     iotest!(fn recursive_mkdir() {
         let tmpdir = tmpdir();
         let dir = tmpdir.join("d1/d2");

trunk/src/libstd/rt/args.rs

@@ -67,9 +67,9 @@ mod imp {
     use clone::Clone;
     use option::{Option, Some, None};
     use iter::Iterator;
+    use str::StrSlice;
     use unstable::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
     use mem;
-    #[cfg(not(test))] use str::StrSlice;
     #[cfg(not(test))] use ptr::RawPtr;
 
     static mut global_args_ptr: uint = 0;