---

yaml
---
r: 95989
b: refs/heads/dist-snap
c: 6690bcb
h: refs/heads/master
i:
  95987: c1f9beb
v: v3

Author: alexcrichton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 18ce014e9d99a66690e9db02e799f57ab969f36d
+refs/heads/dist-snap: 6690bcb10178b08c56ad56b111e4dcb7e0e06b36
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/librustuv/async.rs

@@ -35,7 +35,7 @@ impl AsyncWatcher {
     pub fn new(loop_: &mut Loop, cb: ~Callback) -> AsyncWatcher {
         let handle = UvHandle::alloc(None::<AsyncWatcher>, uvll::UV_ASYNC);
         assert_eq!(unsafe {
-            uvll::async_init(loop_.native_handle(), handle, async_cb)
+            uvll::uv_async_init(loop_.native_handle(), handle, async_cb)
         }, 0);
         let flag = Exclusive::new(false);
         let payload = ~Payload { callback: cb, exit_flag: flag.clone() };
@@ -49,7 +49,7 @@ impl AsyncWatcher {
 
 impl UvHandle<uvll::uv_async_t> for AsyncWatcher {
     fn uv_handle(&self) -> *uvll::uv_async_t { self.handle }
-    unsafe fn from_uv_handle<'a>(h: &'a *T) -> &'a mut AsyncWatcher {
+    unsafe fn from_uv_handle<'a>(_: &'a *uvll::uv_async_t) -> &'a mut AsyncWatcher {
         fail!("async watchers can't be built from their handles");
     }
 }
@@ -89,7 +89,7 @@ extern fn async_cb(handle: *uvll::uv_async_t, status: c_int) {
     payload.callback.call();
 
     if should_exit {
-        unsafe { uvll::close(handle, close_cb) }
+        unsafe { uvll::uv_close(handle, close_cb) }
     }
 }
 
@@ -104,7 +104,7 @@ extern fn close_cb(handle: *uvll::uv_handle_t) {
 
 impl RemoteCallback for AsyncWatcher {
     fn fire(&mut self) {
-        unsafe { uvll::async_send(self.handle) }
+        unsafe { uvll::uv_async_send(self.handle) }
     }
 }
 
@@ -117,7 +117,7 @@ impl Drop for AsyncWatcher {
                 // signal and see the exit flag, destroying the handle
                 // before the final send.
                 *should_exit = true;
-                uvll::async_send(self.handle)
+                uvll::uv_async_send(self.handle)
             }
         }
     }

branches/dist-snap/src/librustuv/file.rs

@@ -13,7 +13,7 @@ use std::c_str;
 use std::c_str::CString;
 use std::cast::transmute;
 use std::libc;
-use std::libc::{c_int, c_char, c_void};
+use std::libc::{c_int, c_char, c_void, c_uint};
 
 use super::{Request, NativeHandle, Loop, FsCallback, Buf,
             status_to_maybe_uv_error, UvError};
@@ -147,25 +147,12 @@ impl FsRequest {
         self.sync_cleanup(result)
     }
 
-<<<<<<< HEAD
     pub fn close(mut self, loop_: &Loop, fd: c_int, cb: FsCallback) {
         let complete_cb_ptr = self.req_boilerplate(Some(cb));
         assert_eq!(unsafe {
-            uvll::fs_close(loop_.native_handle(), self.native_handle(),
-                           fd, complete_cb_ptr)
-        }, 0);
-=======
-    pub fn close(self, loop_: &Loop, fd: c_int, cb: FsCallback) {
-        let complete_cb_ptr = {
-            let mut me = self;
-            me.req_boilerplate(Some(cb))
-        };
-        let ret = unsafe {
             uvll::uv_fs_close(loop_.native_handle(), self.native_handle(),
                               fd, complete_cb_ptr)
-        };
-        assert_eq!(ret, 0);
->>>>>>> 1850d26... Remove lots of uv/C++ wrappers
+        }, 0);
     }
     pub fn close_sync(mut self, loop_: &Loop,
                       fd: c_int) -> Result<c_int, UvError> {
@@ -177,77 +164,50 @@ impl FsRequest {
         self.sync_cleanup(result)
     }
 
-<<<<<<< HEAD
     pub fn mkdir(mut self, loop_: &Loop, path: &CString, mode: c_int,
                  cb: FsCallback) {
         let complete_cb_ptr = self.req_boilerplate(Some(cb));
         assert_eq!(path.with_ref(|p| unsafe {
-            uvll::fs_mkdir(loop_.native_handle(),
-                           self.native_handle(), p, mode, complete_cb_ptr)
+            uvll::uv_fs_mkdir(loop_.native_handle(),
+                              self.native_handle(), p, mode, complete_cb_ptr)
         }), 0);
     }
 
     pub fn rmdir(mut self, loop_: &Loop, path: &CString, cb: FsCallback) {
         let complete_cb_ptr = self.req_boilerplate(Some(cb));
         assert_eq!(path.with_ref(|p| unsafe {
-            uvll::fs_rmdir(loop_.native_handle(),
-                           self.native_handle(), p, complete_cb_ptr)
+            uvll::uv_fs_rmdir(loop_.native_handle(),
+                              self.native_handle(), p, complete_cb_ptr)
         }), 0);
     }
 
     pub fn rename(mut self, loop_: &Loop, path: &CString, to: &CString,
                   cb: FsCallback) {
         let complete_cb_ptr = self.req_boilerplate(Some(cb));
         assert_eq!(unsafe {
-            uvll::fs_rename(loop_.native_handle(),
-                            self.native_handle(),
-                            path.with_ref(|p| p),
-                            to.with_ref(|p| p),
-                            complete_cb_ptr)
+            uvll::uv_fs_rename(loop_.native_handle(),
+                               self.native_handle(),
+                               path.with_ref(|p| p),
+                               to.with_ref(|p| p),
+                               complete_cb_ptr)
         }, 0);
     }
 
     pub fn chmod(mut self, loop_: &Loop, path: &CString, mode: c_int,
                  cb: FsCallback) {
         let complete_cb_ptr = self.req_boilerplate(Some(cb));
         assert_eq!(path.with_ref(|p| unsafe {
-            uvll::fs_chmod(loop_.native_handle(), self.native_handle(), p, mode,
-                           complete_cb_ptr)
+            uvll::uv_fs_chmod(loop_.native_handle(), self.native_handle(), p,
+                              mode, complete_cb_ptr)
         }), 0);
-=======
-    pub fn mkdir(self, loop_: &Loop, path: &CString, mode: int, cb: FsCallback) {
-        let complete_cb_ptr = {
-            let mut me = self;
-            me.req_boilerplate(Some(cb))
-        };
-        let ret = path.with_ref(|p| unsafe {
-            uvll::uv_fs_mkdir(loop_.native_handle(),
-                              self.native_handle(), p,
-                              mode as c_int, complete_cb_ptr)
-        });
-        assert_eq!(ret, 0);
-    }
-
-    pub fn rmdir(self, loop_: &Loop, path: &CString, cb: FsCallback) {
-        let complete_cb_ptr = {
-            let mut me = self;
-            me.req_boilerplate(Some(cb))
-        };
-        let ret = path.with_ref(|p| unsafe {
-            uvll::uv_fs_rmdir(loop_.native_handle(),
-                              self.native_handle(), p, complete_cb_ptr)
-        });
-        assert_eq!(ret, 0);
->>>>>>> 1850d26... Remove lots of uv/C++ wrappers
     }
 
     pub fn readdir(mut self, loop_: &Loop, path: &CString,
                    flags: c_int, cb: FsCallback) {
-<<<<<<< HEAD
         let complete_cb_ptr = self.req_boilerplate(Some(cb));
         assert_eq!(path.with_ref(|p| unsafe {
-            uvll::fs_readdir(loop_.native_handle(),
-                             self.native_handle(), p, flags, complete_cb_ptr)
+            uvll::uv_fs_readdir(loop_.native_handle(),
+                                self.native_handle(), p, flags, complete_cb_ptr)
         }), 0);
     }
 
@@ -318,17 +278,6 @@ impl FsRequest {
             uvll::uv_fs_fdatasync(loop_.native_handle(), self.native_handle(), fd,
                                   complete_cb_ptr)
         }, 0);
-=======
-        let complete_cb_ptr = {
-            let mut me = self;
-            me.req_boilerplate(Some(cb))
-        };
-        let ret = path.with_ref(|p| unsafe {
-            uvll::uv_fs_readdir(loop_.native_handle(),
-                                self.native_handle(), p, flags, complete_cb_ptr)
-        });
-        assert_eq!(ret, 0);
->>>>>>> 1850d26... Remove lots of uv/C++ wrappers
     }
 
     // accessors/utility funcs

branches/dist-snap/src/librustuv/idle.rs

@@ -26,7 +26,7 @@ impl IdleWatcher {
     pub fn new(loop_: &mut Loop) -> ~IdleWatcher {
         let handle = UvHandle::alloc(None::<IdleWatcher>, uvll::UV_IDLE);
         assert_eq!(unsafe {
-            uvll::idle_init(loop_.native_handle(), handle)
+            uvll::uv_idle_init(loop_.native_handle(), handle)
         }, 0);
         let me = ~IdleWatcher {
             handle: handle,
@@ -40,10 +40,10 @@ impl IdleWatcher {
     pub fn onetime(loop_: &mut Loop, f: proc()) {
         let handle = UvHandle::alloc(None::<IdleWatcher>, uvll::UV_IDLE);
         unsafe {
-            assert_eq!(uvll::idle_init(loop_.native_handle(), handle), 0);
+            assert_eq!(uvll::uv_idle_init(loop_.native_handle(), handle), 0);
             let data: *c_void = cast::transmute(~f);
             uvll::set_data_for_uv_handle(handle, data);
-            assert_eq!(uvll::idle_start(handle, onetime_cb), 0)
+            assert_eq!(uvll::uv_idle_start(handle, onetime_cb), 0)
         }
 
         extern fn onetime_cb(handle: *uvll::uv_idle_t, status: c_int) {
@@ -52,8 +52,8 @@ impl IdleWatcher {
                 let data = uvll::get_data_for_uv_handle(handle);
                 let f: ~proc() = cast::transmute(data);
                 (*f)();
-                uvll::idle_stop(handle);
-                uvll::close(handle, close_cb);
+                uvll::uv_idle_stop(handle);
+                uvll::uv_close(handle, close_cb);
             }
         }
 
@@ -67,18 +67,18 @@ impl PausibleIdleCallback for IdleWatcher {
     fn start(&mut self, cb: ~Callback) {
         assert!(self.callback.is_none());
         self.callback = Some(cb);
-        assert_eq!(unsafe { uvll::idle_start(self.handle, idle_cb) }, 0)
+        assert_eq!(unsafe { uvll::uv_idle_start(self.handle, idle_cb) }, 0)
         self.idle_flag = true;
     }
     fn pause(&mut self) {
         if self.idle_flag == true {
-            assert_eq!(unsafe {uvll::idle_stop(self.handle) }, 0);
+            assert_eq!(unsafe {uvll::uv_idle_stop(self.handle) }, 0);
             self.idle_flag = false;
         }
     }
     fn resume(&mut self) {
         if self.idle_flag == false {
-            assert_eq!(unsafe { uvll::idle_start(self.handle, idle_cb) }, 0)
+            assert_eq!(unsafe { uvll::uv_idle_start(self.handle, idle_cb) }, 0)
             self.idle_flag = true;
         }
     }

branches/dist-snap/src/librustuv/lib.rs

@@ -50,7 +50,7 @@ use std::str::raw::from_c_str;
 use std::vec;
 use std::ptr;
 use std::str;
-use std::libc::{c_void, c_int, size_t, malloc, free, c_char, c_uint};
+use std::libc::{c_void, c_int, size_t, malloc, free};
 use std::cast::transmute;
 use std::ptr::null;
 use std::unstable::finally::Finally;
@@ -153,7 +153,7 @@ pub trait UvHandle<T> {
 
         unsafe {
             uvll::set_data_for_uv_handle(self.uv_handle(), null::<()>());
-            uvll::close(self.uv_handle(), close_cb)
+            uvll::uv_close(self.uv_handle() as *uvll::uv_handle_t, close_cb)
         }
     }
 }

branches/dist-snap/src/librustuv/process.rs

@@ -201,32 +201,30 @@ impl RtioProcess for Process {
     }
 
     fn kill(&mut self, signal: int) -> Result<(), IoError> {
-        do self.home_for_io |self_| {
-            match unsafe {
-                uvll::process_kill(self_.handle, signal as libc::c_int)
-            } {
-                0 => Ok(()),
-                err => Err(uv_error_to_io_error(UvError(err)))
-            }
+        let _m = self.fire_missiles();
+        match unsafe {
+            uvll::uv_process_kill(self.handle, signal as libc::c_int)
+        } {
+            0 => Ok(()),
+            err => Err(uv_error_to_io_error(UvError(err)))
         }
     }
 
     fn wait(&mut self) -> int {
         // Make sure (on the home scheduler) that we have an exit status listed
-        do self.home_for_io |self_| {
-            match self_.exit_status {
-                Some(*) => {}
-                None => {
-                    // If there's no exit code previously listed, then the
-                    // process's exit callback has yet to be invoked. We just
-                    // need to deschedule ourselves and wait to be reawoken.
-                    let scheduler: ~Scheduler = Local::take();
-                    do scheduler.deschedule_running_task_and_then |_, task| {
-                        assert!(self_.to_wake.is_none());
-                        self_.to_wake = Some(task);
-                    }
-                    assert!(self_.exit_status.is_some());
+        let _m = self.fire_missiles();
+        match self.exit_status {
+            Some(*) => {}
+            None => {
+                // If there's no exit code previously listed, then the
+                // process's exit callback has yet to be invoked. We just
+                // need to deschedule ourselves and wait to be reawoken.
+                let scheduler: ~Scheduler = Local::take();
+                do scheduler.deschedule_running_task_and_then |_, task| {
+                    assert!(self.to_wake.is_none());
+                    self.to_wake = Some(task);
                 }
+                assert!(self.exit_status.is_some());
             }
         }
 
@@ -237,9 +235,8 @@ impl RtioProcess for Process {
 
 impl Drop for Process {
     fn drop(&mut self) {
-        do self.home_for_io |self_| {
-            assert!(self_.to_wake.is_none());
-            self_.close_async_();
-        }
+        let _m = self.fire_missiles();
+        assert!(self.to_wake.is_none());
+        self.close_async_();
     }
 }

branches/dist-snap/src/librustuv/signal.rs

@@ -32,10 +32,10 @@ impl SignalWatcher {
                channel: SharedChan<Signum>) -> Result<~SignalWatcher, UvError> {
         let handle = UvHandle::alloc(None::<SignalWatcher>, uvll::UV_SIGNAL);
         assert_eq!(unsafe {
-            uvll::signal_init(loop_.native_handle(), handle)
+            uvll::uv_signal_init(loop_.native_handle(), handle)
         }, 0);
 
-        match unsafe { uvll::signal_start(handle, signal_cb, signum as c_int) } {
+        match unsafe { uvll::uv_signal_start(handle, signal_cb, signum as c_int) } {
             0 => {
                 let s = ~SignalWatcher {
                     handle: handle,
@@ -72,8 +72,7 @@ impl RtioSignal for SignalWatcher {}
 
 impl Drop for SignalWatcher {
     fn drop(&mut self) {
-        do self.home_for_io |self_| {
-            self_.close_async_();
-        }
+        let _m = self.fire_missiles();
+        self.close_async_();
     }
 }