---

yaml
---
r: 95624
b: refs/heads/dist-snap
c: 4eb5336
h: refs/heads/master
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: 4ce71eaca34526d0e3ee1ebf0658d2a20d388ef2
+refs/heads/dist-snap: 4eb53360541baf3e6df36dc0f0766bc7c1c9f8be
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

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

@@ -112,7 +112,7 @@ pub fn log(_level: u32, args: &fmt::Arguments) {
             }
             None => {
                 // There is no logger anywhere, just write to stderr
-                let mut logger = StdErrLogger;
+                let mut logger = StdErrLogger::new();
                 logger.log(args);
             }
         }

branches/dist-snap/src/libstd/rt/io/mod.rs

@@ -370,6 +370,7 @@ pub enum IoErrorKind {
     PathAlreadyExists,
     PathDoesntExist,
     MismatchedFileTypeForOperation,
+    ResourceUnavailable,
     IoUnavailable,
 }
 
@@ -392,6 +393,7 @@ impl ToStr for IoErrorKind {
             PathDoesntExist => ~"PathDoesntExist",
             MismatchedFileTypeForOperation => ~"MismatchedFileTypeForOperation",
             IoUnavailable => ~"IoUnavailable",
+            ResourceUnavailable => ~"ResourceUnavailable",
         }
     }
 }

branches/dist-snap/src/libstd/rt/io/native/file.rs

@@ -21,6 +21,12 @@ fn raise_error() {
     // XXX: this should probably be a bit more descriptive...
     let (kind, desc) = match os::errno() as i32 {
         libc::EOF => (EndOfFile, "end of file"),
+
+        // These two constants can have the same value on some systems, but
+        // different values on others, so we can't use a match clause
+        x if x == libc::EAGAIN || x == libc::EWOULDBLOCK =>
+            (ResourceUnavailable, "resource temporarily unavailable"),
+
         _ => (OtherIoError, "unknown error"),
     };
 

branches/dist-snap/src/libstd/rt/io/stdio.rs

@@ -8,20 +8,39 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+/*!
+
+This modules provides bindings to the local event loop's TTY interface, using it
+to have synchronous, but non-blocking versions of stdio. These handles can be
+inspected for information about terminal dimensions or related information
+about the stream or terminal that it is attached to.
+
+# Example
+
+```rust
+use std::rt::io;
+
+let mut out = io::stdout();
+out.write(bytes!("Hello, world!"));
+```
+
+*/
+
 use fmt;
 use libc;
 use option::{Option, Some, None};
 use result::{Ok, Err};
 use rt::rtio::{IoFactory, RtioTTY, with_local_io};
 use super::{Reader, Writer, io_error};
 
-/// Creates a new non-blocking handle to the stdin of the current process.
-///
-/// See `stdout()` for notes about this function.
-pub fn stdin() -> StdReader {
+#[fixed_stack_segment] #[inline(never)]
+fn tty<T>(fd: libc::c_int, f: &fn(~RtioTTY) -> T) -> T {
     do with_local_io |io| {
-        match io.tty_open(libc::STDIN_FILENO, true, false) {
-            Ok(tty) => Some(StdReader { inner: tty }),
+        // Always pass in readable as true, otherwise libuv turns our writes
+        // into blocking writes. We also need to dup the file descriptor because
+        // the tty will be closed when it's dropped.
+        match io.tty_open(unsafe { libc::dup(fd) }, true) {
+            Ok(tty) => Some(f(tty)),
             Err(e) => {
                 io_error::cond.raise(e);
                 None
@@ -30,37 +49,28 @@ pub fn stdin() -> StdReader {
     }.unwrap()
 }
 
+/// Creates a new non-blocking handle to the stdin of the current process.
+///
+/// See `stdout()` for notes about this function.
+pub fn stdin() -> StdReader {
+    do tty(libc::STDIN_FILENO) |tty| { StdReader { inner: tty } }
+}
+
 /// Creates a new non-blocking handle to the stdout of the current process.
 ///
 /// Note that this is a fairly expensive operation in that at least one memory
 /// allocation is performed. Additionally, this must be called from a runtime
 /// task context because the stream returned will be a non-blocking object using
 /// the local scheduler to perform the I/O.
 pub fn stdout() -> StdWriter {
-    do with_local_io |io| {
-        match io.tty_open(libc::STDOUT_FILENO, false, false) {
-            Ok(tty) => Some(StdWriter { inner: tty }),
-            Err(e) => {
-                io_error::cond.raise(e);
-                None
-            }
-        }
-    }.unwrap()
+    do tty(libc::STDOUT_FILENO) |tty| { StdWriter { inner: tty } }
 }
 
 /// Creates a new non-blocking handle to the stderr of the current process.
 ///
 /// See `stdout()` for notes about this function.
 pub fn stderr() -> StdWriter {
-    do with_local_io |io| {
-        match io.tty_open(libc::STDERR_FILENO, false, false) {
-            Ok(tty) => Some(StdWriter { inner: tty }),
-            Err(e) => {
-                io_error::cond.raise(e);
-                None
-            }
-        }
-    }.unwrap()
+    do tty(libc::STDERR_FILENO) |tty| { StdWriter { inner: tty } }
 }
 
 /// Prints a string to the stdout of the current process. No newline is emitted
@@ -115,6 +125,11 @@ impl StdReader {
             Err(e) => io_error::cond.raise(e),
         }
     }
+
+    /// Returns whether this tream is attached to a TTY instance or not.
+    ///
+    /// This is similar to libc's isatty() function
+    pub fn isatty(&self) -> bool { self.inner.isatty() }
 }
 
 impl Reader for StdReader {
@@ -170,6 +185,11 @@ impl StdWriter {
             Err(e) => io_error::cond.raise(e),
         }
     }
+
+    /// Returns whether this tream is attached to a TTY instance or not.
+    ///
+    /// This is similar to libc's isatty() function
+    pub fn isatty(&self) -> bool { self.inner.isatty() }
 }
 
 impl Writer for StdWriter {

branches/dist-snap/src/libstd/rt/logging.rs

@@ -12,6 +12,7 @@ use fmt;
 use from_str::from_str;
 use libc::exit;
 use option::{Some, None, Option};
+use rt::io;
 use rt::crate_map::{ModEntry, CrateMap, iter_crate_map, get_crate_map};
 use str::StrSlice;
 use u32;
@@ -166,14 +167,23 @@ pub trait Logger {
     fn log(&mut self, args: &fmt::Arguments);
 }
 
-pub struct StdErrLogger;
+/// This logger emits output to the stderr of the process, and contains a lazily
+/// initialized event-loop driven handle to the stream.
+pub struct StdErrLogger {
+    priv handle: Option<io::stdio::StdWriter>,
+}
+
+impl StdErrLogger {
+    pub fn new() -> StdErrLogger { StdErrLogger { handle: None } }
+}
 
 impl Logger for StdErrLogger {
     fn log(&mut self, args: &fmt::Arguments) {
-        // FIXME(#6846): this should not call the blocking version of println,
-        //               or at least the default loggers for tasks shouldn't do
-        //               that
-        ::rt::util::dumb_println(args);
+        // First time logging? Get a handle to the stderr of this process.
+        if self.handle.is_none() {
+            self.handle = Some(io::stderr());
+        }
+        fmt::writeln(self.handle.get_mut_ref() as &mut io::Writer, args);
     }
 }
 

branches/dist-snap/src/libstd/rt/rtio.rs

@@ -97,7 +97,7 @@ pub trait IoFactory {
     fn unix_bind(&mut self, path: &CString) ->
         Result<~RtioUnixListener, IoError>;
     fn unix_connect(&mut self, path: &CString) -> Result<~RtioPipe, IoError>;
-    fn tty_open(&mut self, fd: c_int, readable: bool, close_on_drop: bool)
+    fn tty_open(&mut self, fd: c_int, readable: bool)
             -> Result<~RtioTTY, IoError>;
 }
 
@@ -182,6 +182,7 @@ pub trait RtioTTY {
     fn write(&mut self, buf: &[u8]) -> Result<(), IoError>;
     fn set_raw(&mut self, raw: bool) -> Result<(), IoError>;
     fn get_winsize(&mut self) -> Result<(int, int), IoError>;
+    fn isatty(&self) -> bool;
 }
 
 pub trait PausibleIdleCallback {

branches/dist-snap/src/libstd/rt/task.rs

@@ -132,7 +132,7 @@ impl Task {
             heap: LocalHeap::new(),
             gc: GarbageCollector,
             storage: LocalStorage(None),
-            logger: StdErrLogger,
+            logger: StdErrLogger::new(),
             unwinder: Unwinder { unwinding: false },
             taskgroup: None,
             death: Death::new(),
@@ -166,7 +166,7 @@ impl Task {
             heap: LocalHeap::new(),
             gc: GarbageCollector,
             storage: LocalStorage(None),
-            logger: StdErrLogger,
+            logger: StdErrLogger::new(),
             unwinder: Unwinder { unwinding: false },
             taskgroup: None,
             death: Death::new(),
@@ -188,7 +188,7 @@ impl Task {
             heap: LocalHeap::new(),
             gc: GarbageCollector,
             storage: LocalStorage(None),
-            logger: StdErrLogger,
+            logger: StdErrLogger::new(),
             unwinder: Unwinder { unwinding: false },
             taskgroup: None,
             // FIXME(#7544) make watching optional
@@ -549,6 +549,7 @@ pub fn begin_unwind(msg: *c_char, file: *c_char, line: size_t) -> ! {
     use rt::logging::Logger;
     use str::Str;
     use c_str::CString;
+    use unstable::intrinsics;
 
     unsafe {
         let msg = CString::new(msg, false);
@@ -557,35 +558,32 @@ pub fn begin_unwind(msg: *c_char, file: *c_char, line: size_t) -> ! {
             Some(s) => s, None => rtabort!("message wasn't utf8?")
         };
 
-        if in_green_task_context() {
-            // Be careful not to allocate in this block, if we're failing we may
-            // have been failing due to a lack of memory in the first place...
-            do Local::borrow |task: &mut Task| {
-                let n = task.name.as_ref().map(|n| n.as_slice()).unwrap_or("<unnamed>");
-
-                match file.as_str() {
-                    Some(file) => {
-                        format_args!(|args| { task.logger.log(args) },
-                                     "task '{}' failed at '{}', {}:{}",
-                                     n, msg, file, line);
-                    }
-                    None => {
-                        format_args!(|args| { task.logger.log(args) },
-                                     "task '{}' failed at '{}'", n, msg);
-                    }
-                }
-            }
-        } else {
+        if !in_green_task_context() {
             match file.as_str() {
                 Some(file) => {
                     rterrln!("failed in non-task context at '{}', {}:{}",
                              msg, file, line as int);
                 }
-                None => rterrln!("failed in non-task context at '{}'", msg),
+                None => rterrln!("failed in non-task context at '{}'", msg)
             }
+            intrinsics::abort();
         }
 
+        // Be careful not to allocate in this block, if we're failing we may
+        // have been failing due to a lack of memory in the first place...
         let task: *mut Task = Local::unsafe_borrow();
+        let n = (*task).name.as_ref().map(|n| n.as_slice()).unwrap_or("<unnamed>");
+        match file.as_str() {
+            Some(file) => {
+                format_args!(|args| { (*task).logger.log(args) },
+                             "task '{}' failed at '{}', {}:{}",
+                             n, msg, file, line);
+            }
+            None => {
+                format_args!(|args| { (*task).logger.log(args) },
+                             "task '{}' failed at '{}'", n, msg);
+            }
+        }
         if (*task).unwinder.unwinding {
             rtabort!("unwinding again");
         }

branches/dist-snap/src/libstd/rt/util.rs

@@ -71,9 +71,18 @@ pub fn default_sched_threads() -> uint {
 
 pub fn dumb_println(args: &fmt::Arguments) {
     use rt::io::native::stdio::stderr;
-    use rt::io::Writer;
+    use rt::io::{Writer, io_error, ResourceUnavailable};
     let mut out = stderr();
-    fmt::writeln(&mut out as &mut Writer, args);
+
+    let mut again = true;
+    do io_error::cond.trap(|e| {
+        again = e.kind == ResourceUnavailable;
+    }).inside {
+        while again {
+            again = false;
+            fmt::writeln(&mut out as &mut Writer, args);
+        }
+    }
 }
 
 pub fn abort(msg: &str) -> ! {

branches/dist-snap/src/libstd/rt/uv/mod.rs

@@ -170,6 +170,7 @@ pub trait WatcherInterop {
     fn get_watcher_data<'r>(&'r mut self) -> &'r mut WatcherData;
     fn drop_watcher_data(&mut self);
     fn close(self, cb: NullCallback);
+    fn close_async(self);
 }
 
 impl<H, W: Watcher + NativeHandle<*H>> WatcherInterop for W {
@@ -235,6 +236,16 @@ impl<H, W: Watcher + NativeHandle<*H>> WatcherInterop for W {
             unsafe { uvll::free_handle(handle as *c_void) }
         }
     }
+
+    fn close_async(self) {
+        unsafe { uvll::close(self.native_handle(), close_cb); }
+
+        extern fn close_cb(handle: *uvll::uv_handle_t) {
+            let mut h: Handle = NativeHandle::from_native_handle(handle);
+            h.drop_watcher_data();
+            unsafe { uvll::free_handle(handle as *c_void) }
+        }
+    }
 }
 
 // XXX: Need to define the error constants like EOF so they can be