---

yaml
---
r: 109439
b: refs/heads/dist-snap
c: 2e6607a
h: refs/heads/master
i:
  109437: b077661
  109435: 65dce3e
  109431: 777bee1
  109423: 8198514
  109407: 6402ec2
  109375: 22f5a4e
  109311: c0dbbea
v: v3

Author: flaper87

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: f64fdf524a434f0e5cd0bc91d09c144723f3c90d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 42e1003e4a2dd4d3a7e800c2f5b99bf77a4b635e
+refs/heads/dist-snap: 2e6607a1dd44aab097d0a3f9d7b1a418f6698602
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/etc/vim/syntax/rust.vim

@@ -52,7 +52,7 @@ syn keyword   rustType        f64 i8 i16 i32 i64 str Self
 " to make it easy to update.
 
 " Core operators {{{3
-syn keyword   rustTrait       Freeze Copy Send Sized
+syn keyword   rustTrait       Share Copy Send Sized
 syn keyword   rustTrait       Add Sub Mul Div Rem Neg Not
 syn keyword   rustTrait       BitAnd BitOr BitXor
 syn keyword   rustTrait       Drop

branches/dist-snap/src/libnative/io/process.rs

@@ -134,18 +134,6 @@ impl rtio::RtioProcess for Process {
     }
 
     fn kill(&mut self, signum: int) -> Result<(), io::IoError> {
-        // On linux (and possibly other unices), a process that has exited will
-        // continue to accept signals because it is "defunct". The delivery of
-        // signals will only fail once the child has been reaped. For this
-        // reason, if the process hasn't exited yet, then we attempt to collect
-        // their status with WNOHANG.
-        if self.exit_code.is_none() {
-            match waitpid_nowait(self.pid) {
-                Some(code) => { self.exit_code = Some(code); }
-                None => {}
-            }
-        }
-
         // if the process has finished, and therefore had waitpid called,
         // and we kill it, then on unix we might ending up killing a
         // newer process that happens to have the same (re-used) id
@@ -674,31 +662,6 @@ fn free_handle(_handle: *()) {
     // unix has no process handle object, just a pid
 }
 
-#[cfg(unix)]
-fn translate_status(status: c_int) -> p::ProcessExit {
-    #[cfg(target_os = "linux")]
-    #[cfg(target_os = "android")]
-    mod imp {
-        pub fn WIFEXITED(status: i32) -> bool { (status & 0xff) == 0 }
-        pub fn WEXITSTATUS(status: i32) -> i32 { (status >> 8) & 0xff }
-        pub fn WTERMSIG(status: i32) -> i32 { status & 0x7f }
-    }
-
-    #[cfg(target_os = "macos")]
-    #[cfg(target_os = "freebsd")]
-    mod imp {
-        pub fn WIFEXITED(status: i32) -> bool { (status & 0x7f) == 0 }
-        pub fn WEXITSTATUS(status: i32) -> i32 { status >> 8 }
-        pub fn WTERMSIG(status: i32) -> i32 { status & 0o177 }
-    }
-
-    if imp::WIFEXITED(status) {
-        p::ExitStatus(imp::WEXITSTATUS(status) as int)
-    } else {
-        p::ExitSignal(imp::WTERMSIG(status) as int)
-    }
-}
-
 /**
  * Waits for a process to exit and returns the exit code, failing
  * if there is no process with the specified id.
@@ -760,31 +723,33 @@ fn waitpid(pid: pid_t) -> p::ProcessExit {
     #[cfg(unix)]
     fn waitpid_os(pid: pid_t) -> p::ProcessExit {
         use std::libc::funcs::posix01::wait;
-        let mut status = 0 as c_int;
-        match retry(|| unsafe { wait::waitpid(pid, &mut status, 0) }) {
-            -1 => fail!("unknown waitpid error: {}", super::last_error()),
-            _ => translate_status(status),
-        }
-    }
-}
 
-fn waitpid_nowait(pid: pid_t) -> Option<p::ProcessExit> {
-    return waitpid_os(pid);
+        #[cfg(target_os = "linux")]
+        #[cfg(target_os = "android")]
+        mod imp {
+            pub fn WIFEXITED(status: i32) -> bool { (status & 0xff) == 0 }
+            pub fn WEXITSTATUS(status: i32) -> i32 { (status >> 8) & 0xff }
+            pub fn WTERMSIG(status: i32) -> i32 { status & 0x7f }
+        }
 
-    // This code path isn't necessary on windows
-    #[cfg(windows)]
-    fn waitpid_os(_pid: pid_t) -> Option<p::ProcessExit> { None }
+        #[cfg(target_os = "macos")]
+        #[cfg(target_os = "freebsd")]
+        mod imp {
+            pub fn WIFEXITED(status: i32) -> bool { (status & 0x7f) == 0 }
+            pub fn WEXITSTATUS(status: i32) -> i32 { status >> 8 }
+            pub fn WTERMSIG(status: i32) -> i32 { status & 0o177 }
+        }
 
-    #[cfg(unix)]
-    fn waitpid_os(pid: pid_t) -> Option<p::ProcessExit> {
-        use std::libc::funcs::posix01::wait;
         let mut status = 0 as c_int;
-        match retry(|| unsafe {
-            wait::waitpid(pid, &mut status, libc::WNOHANG)
-        }) {
-            n if n == pid => Some(translate_status(status)),
-            0 => None,
-            n => fail!("unknown waitpid error `{}`: {}", n, super::last_error()),
+        match retry(|| unsafe { wait::waitpid(pid, &mut status, 0) }) {
+            -1 => fail!("unknown waitpid error: {}", super::last_error()),
+            _ => {
+                if imp::WIFEXITED(status) {
+                    p::ExitStatus(imp::WEXITSTATUS(status) as int)
+                } else {
+                    p::ExitSignal(imp::WTERMSIG(status) as int)
+                }
+            }
         }
     }
 }

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

@@ -97,24 +97,6 @@ pub fn start(argc: int, argv: **u8, main: proc()) -> int {
     // frames above our current position.
     let my_stack_bottom = my_stack_top + 20000 - OS_DEFAULT_STACK_ESTIMATE;
 
-    // When using libgreen, one of the first things that we do is to turn off
-    // the SIGPIPE signal (set it to ignore). By default, some platforms will
-    // send a *signal* when a EPIPE error would otherwise be delivered. This
-    // runtime doesn't install a SIGPIPE handler, causing it to kill the
-    // program, which isn't exactly what we want!
-    //
-    // Hence, we set SIGPIPE to ignore when the program starts up in order to
-    // prevent this problem.
-    #[cfg(windows)] fn ignore_sigpipe() {}
-    #[cfg(unix)] fn ignore_sigpipe() {
-        use std::libc;
-        use std::libc::funcs::posix01::signal::signal;
-        unsafe {
-            assert!(signal(libc::SIGPIPE, libc::SIG_IGN) != -1);
-        }
-    }
-    ignore_sigpipe();
-
     rt::init(argc, argv);
     let mut exit_code = None;
     let mut main = Some(main);

branches/dist-snap/src/libstd/io/process.rs

@@ -331,9 +331,7 @@ impl Process {
     /// signals (SIGTERM/SIGKILL/SIGINT) are translated to `TerminateProcess`.
     ///
     /// Additionally, a signal number of 0 can check for existence of the target
-    /// process. Note, though, that on some platforms signals will continue to
-    /// be successfully delivered if the child has exited, but not yet been
-    /// reaped.
+    /// process.
     pub fn kill(id: libc::pid_t, signal: int) -> IoResult<()> {
         LocalIo::maybe_raise(|io| io.kill(id, signal))
     }
@@ -344,16 +342,8 @@ impl Process {
     /// Sends the specified signal to the child process, returning whether the
     /// signal could be delivered or not.
     ///
-    /// Note that signal 0 is interpreted as a poll to check whether the child
-    /// process is still alive or not. If an error is returned, then the child
-    /// process has exited.
-    ///
-    /// On some unix platforms signals will continue to be received after a
-    /// child has exited but not yet been reaped. In order to report the status
-    /// of signal delivery correctly, unix implementations may invoke
-    /// `waitpid()` with `WNOHANG` in order to reap the child as necessary.
-    ///
-    /// # Errors
+    /// Note that this is purely a wrapper around libuv's `uv_process_kill`
+    /// function.
     ///
     /// If the signal delivery fails, the corresponding error is returned.
     pub fn signal(&mut self, signal: int) -> IoResult<()> {
@@ -843,17 +833,4 @@ mod tests {
         p.signal_kill().unwrap();
         assert!(!p.wait().success());
     })
-
-    iotest!(fn test_zero() {
-        let mut p = sleeper();
-        p.signal_kill().unwrap();
-        for _ in range(0, 20) {
-            if p.signal(0).is_err() {
-                assert!(!p.wait().success());
-                return
-            }
-            timer::sleep(100);
-        }
-        fail!("never saw the child go away");
-    })
 }

branches/dist-snap/src/libstd/libc.rs

@@ -266,8 +266,6 @@ pub mod types {
                 }
 
                 pub enum timezone {}
-
-                pub type sighandler_t = size_t;
             }
             pub mod bsd44 {
                 use libc::types::os::arch::c95::{c_char, c_int, c_uint};
@@ -639,8 +637,6 @@ pub mod types {
                 }
 
                 pub enum timezone {}
-
-                pub type sighandler_t = size_t;
             }
             pub mod bsd44 {
                 use libc::types::os::arch::c95::{c_char, c_int, c_uint};
@@ -1210,8 +1206,6 @@ pub mod types {
                 }
 
                 pub enum timezone {}
-
-                pub type sighandler_t = size_t;
             }
 
             pub mod bsd44 {
@@ -2298,8 +2292,6 @@ pub mod consts {
             use libc::types::os::arch::c95::{c_int, size_t};
 
             pub static SIGTRAP : c_int = 5;
-            pub static SIGPIPE: c_int = 13;
-            pub static SIG_IGN: size_t = 1;
 
             pub static GLOB_ERR      : c_int = 1 << 0;
             pub static GLOB_MARK     : c_int = 1 << 1;
@@ -2364,8 +2356,6 @@ pub mod consts {
 
             pub static CLOCK_REALTIME: c_int = 0;
             pub static CLOCK_MONOTONIC: c_int = 1;
-
-            pub static WNOHANG: c_int = 1;
         }
         pub mod posix08 {
         }
@@ -2751,8 +2741,6 @@ pub mod consts {
             use libc::types::os::arch::c95::{c_int, size_t};
 
             pub static SIGTRAP : c_int = 5;
-            pub static SIGPIPE: c_int = 13;
-            pub static SIG_IGN: size_t = 1;
 
             pub static GLOB_APPEND   : c_int = 0x0001;
             pub static GLOB_DOOFFS   : c_int = 0x0002;
@@ -2814,8 +2802,6 @@ pub mod consts {
 
             pub static CLOCK_REALTIME: c_int = 0;
             pub static CLOCK_MONOTONIC: c_int = 4;
-
-            pub static WNOHANG: c_int = 1;
         }
         pub mod posix08 {
         }
@@ -3150,8 +3136,6 @@ pub mod consts {
             use libc::types::os::arch::c95::{c_int, size_t};
 
             pub static SIGTRAP : c_int = 5;
-            pub static SIGPIPE: c_int = 13;
-            pub static SIG_IGN: size_t = 1;
 
             pub static GLOB_APPEND   : c_int = 0x0001;
             pub static GLOB_DOOFFS   : c_int = 0x0002;
@@ -3203,8 +3187,6 @@ pub mod consts {
             pub static PTHREAD_CREATE_JOINABLE: c_int = 1;
             pub static PTHREAD_CREATE_DETACHED: c_int = 2;
             pub static PTHREAD_STACK_MIN: size_t = 8192;
-
-            pub static WNOHANG: c_int = 1;
         }
         pub mod posix08 {
         }
@@ -3856,24 +3838,6 @@ pub mod funcs {
             }
         }
 
-        pub mod signal {
-            use libc::types::os::arch::c95::c_int;
-            use libc::types::os::common::posix01::sighandler_t;
-
-            #[cfg(not(target_os = "android"))]
-            extern {
-                pub fn signal(signum: c_int,
-                              handler: sighandler_t) -> sighandler_t;
-            }
-
-            #[cfg(target_os = "android")]
-            extern {
-                #[link_name = "bsd_signal"]
-                pub fn signal(signum: c_int,
-                              handler: sighandler_t) -> sighandler_t;
-            }
-        }
-
         pub mod wait {
             use libc::types::os::arch::c95::{c_int};
             use libc::types::os::arch::posix88::{pid_t};

branches/dist-snap/src/test/run-pass/core-run-destroy.rs

@@ -22,12 +22,6 @@ extern crate native;
 extern crate green;
 extern crate rustuv;
 
-use std::io::Process;
-
-macro_rules! succeed( ($e:expr) => (
-    match $e { Ok(..) => {}, Err(e) => fail!("failure: {}", e) }
-) )
-
 macro_rules! iotest (
     { fn $name:ident() $b:block $($a:attr)* } => (
         mod $name {
@@ -59,29 +53,28 @@ fn start(argc: int, argv: **u8) -> int {
 }
 
 iotest!(fn test_destroy_once() {
-    let mut p = sleeper();
-    match p.signal_exit() {
-        Ok(()) => {}
-        Err(e) => fail!("error: {}", e),
-    }
-})
+    #[cfg(not(target_os="android"))]
+    static mut PROG: &'static str = "echo";
 
-#[cfg(unix)]
-pub fn sleeper() -> Process {
-    Process::new("sleep", [~"1000"]).unwrap()
-}
-#[cfg(windows)]
-pub fn sleeper() -> Process {
-    // There's a `timeout` command on windows, but it doesn't like having
-    // its output piped, so instead just ping ourselves a few times with
-    // gaps inbetweeen so we're sure this process is alive for awhile
-    Process::new("ping", [~"127.0.0.1", ~"-n", ~"1000"]).unwrap()
-}
+    #[cfg(target_os="android")]
+    static mut PROG: &'static str = "ls"; // android don't have echo binary
+
+    let mut p = unsafe {Process::new(PROG, []).unwrap()};
+    p.signal_exit().unwrap(); // this shouldn't crash (and nor should the destructor)
+})
 
 iotest!(fn test_destroy_twice() {
-    let mut p = sleeper();
-    succeed!(p.signal_exit()); // this shouldnt crash...
-    let _ = p.signal_exit(); // ...and nor should this (and nor should the destructor)
+    #[cfg(not(target_os="android"))]
+    static mut PROG: &'static str = "echo";
+    #[cfg(target_os="android")]
+    static mut PROG: &'static str = "ls"; // android don't have echo binary
+
+    let mut p = match unsafe{Process::new(PROG, [])} {
+        Ok(p) => p,
+        Err(e) => fail!("wut: {}", e),
+    };
+    p.signal_exit().unwrap(); // this shouldnt crash...
+    p.signal_exit().unwrap(); // ...and nor should this (and nor should the destructor)
 })
 
 pub fn test_destroy_actually_kills(force: bool) {