---

yaml
---
r: 146158
b: refs/heads/try2
c: 35756fb
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 32b07c6a40bd7e1874244096f413096a6e059a29
+refs/heads/try2: 35756fbcf6572d588929fde64fb4027f47e9d0af
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libstd/rt/io/stdio.rs

@@ -13,7 +13,7 @@ use libc;
 use option::{Option, Some, None};
 use result::{Ok, Err};
 use rt::local::Local;
-use rt::rtio::{RtioFileStream, IoFactoryObject, IoFactory};
+use rt::rtio::{IoFactoryObject, IoFactory, RtioTTYObject, RtioTTY};
 use super::{Reader, Writer, io_error};
 
 /// Creates a new non-blocking handle to the stdin of the current process.
@@ -22,8 +22,8 @@ use super::{Reader, Writer, io_error};
 pub fn stdin() -> StdReader {
     let stream = unsafe {
         let io: *mut IoFactoryObject = Local::unsafe_borrow();
-        (*io).fs_from_raw_fd(libc::STDIN_FILENO, false)
-    };
+        (*io).tty_open(libc::STDIN_FILENO, true, false)
+    }.unwrap();
     StdReader { inner: stream }
 }
 
@@ -36,8 +36,8 @@ pub fn stdin() -> StdReader {
 pub fn stdout() -> StdWriter {
     let stream = unsafe {
         let io: *mut IoFactoryObject = Local::unsafe_borrow();
-        (*io).fs_from_raw_fd(libc::STDOUT_FILENO, false)
-    };
+        (*io).tty_open(libc::STDOUT_FILENO, false, false)
+    }.unwrap();
     StdWriter { inner: stream }
 }
 
@@ -47,8 +47,8 @@ pub fn stdout() -> StdWriter {
 pub fn stderr() -> StdWriter {
     let stream = unsafe {
         let io: *mut IoFactoryObject = Local::unsafe_borrow();
-        (*io).fs_from_raw_fd(libc::STDERR_FILENO, false)
-    };
+        (*io).tty_open(libc::STDERR_FILENO, false, false)
+    }.unwrap();
     StdWriter { inner: stream }
 }
 
@@ -87,7 +87,30 @@ pub fn println_args(fmt: &fmt::Arguments) {
 
 /// Representation of a reader of a standard input stream
 pub struct StdReader {
-    priv inner: ~RtioFileStream
+    priv inner: ~RtioTTYObject
+}
+
+impl StdReader {
+    /// Controls whether this output stream is a "raw stream" or simply a normal
+    /// stream.
+    ///
+    /// # Failure
+    ///
+    /// This function will raise on the `io_error` condition if an error
+    /// happens.
+    pub fn set_raw(&mut self, raw: bool) {
+        match self.inner.set_raw(raw) {
+            Ok(()) => {},
+            Err(e) => io_error::cond.raise(e),
+        }
+    }
+
+    /// Resets the mode of this stream back to its original state.
+    ///
+    /// # Failure
+    ///
+    /// This function cannot fail.
+    pub fn reset_mode(&mut self) { self.inner.reset_mode(); }
 }
 
 impl Reader for StdReader {
@@ -106,7 +129,50 @@ impl Reader for StdReader {
 
 /// Representation of a writer to a standard output stream
 pub struct StdWriter {
-    priv inner: ~RtioFileStream
+    priv inner: ~RtioTTYObject
+}
+
+impl StdWriter {
+    /// Gets the size of this output window, if possible. This is typically used
+    /// when the writer is attached to something like a terminal, this is used
+    /// to fetch the dimensions of the terminal.
+    ///
+    /// If successful, returns Some((width, height)).
+    ///
+    /// # Failure
+    ///
+    /// This function will raise on the `io_error` condition if an error
+    /// happens.
+    pub fn winsize(&mut self) -> Option<(int, int)> {
+        match self.inner.get_winsize() {
+            Ok(p) => Some(p),
+            Err(e) => {
+                io_error::cond.raise(e);
+                None
+            }
+        }
+    }
+
+    /// Controls whether this output stream is a "raw stream" or simply a normal
+    /// stream.
+    ///
+    /// # Failure
+    ///
+    /// This function will raise on the `io_error` condition if an error
+    /// happens.
+    pub fn set_raw(&mut self, raw: bool) {
+        match self.inner.set_raw(raw) {
+            Ok(()) => {},
+            Err(e) => io_error::cond.raise(e),
+        }
+    }
+
+    /// Resets the mode of this stream back to its original state.
+    ///
+    /// # Failure
+    ///
+    /// This function cannot fail.
+    pub fn reset_mode(&mut self) { self.inner.reset_mode(); }
 }
 
 impl Writer for StdWriter {
@@ -117,10 +183,18 @@ impl Writer for StdWriter {
         }
     }
 
-    fn flush(&mut self) {
-        match self.inner.flush() {
-            Ok(()) => {}
-            Err(e) => io_error::cond.raise(e)
-        }
+    fn flush(&mut self) { /* nothing to do */ }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn smoke() {
+        // Just make sure we can acquire handles
+        stdin();
+        stdout();
+        stderr();
     }
 }

branches/try2/src/libstd/rt/rtio.rs

@@ -38,6 +38,7 @@ pub type RtioPipeObject = uvio::UvPipeStream;
 pub type RtioProcessObject = uvio::UvProcess;
 pub type RtioUnixListenerObject = uvio::UvUnixListener;
 pub type RtioUnixAcceptorObject = uvio::UvUnixAcceptor;
+pub type RtioTTYObject = uvio::UvTTY;
 
 pub trait EventLoop {
     fn run(&mut self);
@@ -94,6 +95,8 @@ pub trait IoFactory {
         Result<~RtioUnixListenerObject, IoError>;
     fn unix_connect<P: PathLike>(&mut self, path: &P) ->
         Result<~RtioPipeObject, IoError>;
+    fn tty_open(&mut self, fd: c_int, readable: bool, close_on_drop: bool)
+            -> Result<~RtioTTYObject, IoError>;
 }
 
 pub trait RtioTcpListener : RtioSocket {
@@ -171,3 +174,11 @@ pub trait RtioUnixAcceptor {
     fn accept_simultaneously(&mut self) -> Result<(), IoError>;
     fn dont_accept_simultaneously(&mut self) -> Result<(), IoError>;
 }
+
+pub trait RtioTTY {
+    fn read(&mut self, buf: &mut [u8]) -> Result<uint, IoError>;
+    fn write(&mut self, buf: &[u8]) -> Result<(), IoError>;
+    fn set_raw(&mut self, raw: bool) -> Result<(), IoError>;
+    fn reset_mode(&mut self);
+    fn get_winsize(&mut self) -> Result<(int, int), IoError>;
+}

branches/try2/src/libstd/rt/uv/async.rs

@@ -8,11 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use libc::{c_int, c_void};
+use libc::c_int;
 use option::Some;
 use rt::uv::uvll;
 use rt::uv::uvll::UV_ASYNC;
-use rt::uv::{Watcher, Loop, NativeHandle, AsyncCallback, NullCallback};
+use rt::uv::{Watcher, Loop, NativeHandle, AsyncCallback};
 use rt::uv::WatcherInterop;
 use rt::uv::status_to_maybe_uv_error;
 
@@ -47,27 +47,6 @@ impl AsyncWatcher {
             uvll::async_send(handle);
         }
     }
-
-    pub fn close(self, cb: NullCallback) {
-        let mut this = self;
-        let data = this.get_watcher_data();
-        assert!(data.close_cb.is_none());
-        data.close_cb = Some(cb);
-
-        unsafe {
-            uvll::close(self.native_handle(), close_cb);
-        }
-
-        extern fn close_cb(handle: *uvll::uv_stream_t) {
-            let mut watcher: AsyncWatcher = NativeHandle::from_native_handle(handle);
-            {
-                let data = watcher.get_watcher_data();
-                data.close_cb.take_unwrap()();
-            }
-            watcher.drop_watcher_data();
-            unsafe { uvll::free_handle(handle as *c_void); }
-        }
-    }
 }
 
 impl NativeHandle<*uvll::uv_async_t> for AsyncWatcher {

branches/try2/src/libstd/rt/uv/idle.rs

@@ -11,7 +11,7 @@
 use libc::c_int;
 use option::Some;
 use rt::uv::uvll;
-use rt::uv::{Watcher, Loop, NativeHandle, IdleCallback, NullCallback};
+use rt::uv::{Watcher, Loop, NativeHandle, IdleCallback};
 use rt::uv::status_to_maybe_uv_error;
 
 pub struct IdleWatcher(*uvll::uv_idle_t);
@@ -71,29 +71,6 @@ impl IdleWatcher {
             assert!(0 == uvll::idle_stop(self.native_handle()));
         }
     }
-
-    pub fn close(self, cb: NullCallback) {
-        {
-            let mut this = self;
-            let data = this.get_watcher_data();
-            assert!(data.close_cb.is_none());
-            data.close_cb = Some(cb);
-        }
-
-        unsafe { uvll::close(self.native_handle(), close_cb) };
-
-        extern fn close_cb(handle: *uvll::uv_idle_t) {
-            unsafe {
-                let mut idle_watcher: IdleWatcher = NativeHandle::from_native_handle(handle);
-                {
-                    let data = idle_watcher.get_watcher_data();
-                    data.close_cb.take_unwrap()();
-                }
-                idle_watcher.drop_watcher_data();
-                uvll::idle_delete(handle);
-            }
-        }
-    }
 }
 
 impl NativeHandle<*uvll::uv_idle_t> for IdleWatcher {

branches/try2/src/libstd/rt/uv/mod.rs

@@ -75,6 +75,7 @@ pub mod async;
 pub mod addrinfo;
 pub mod process;
 pub mod pipe;
+pub mod tty;
 
 /// XXX: Loop(*handle) is buggy with destructors. Normal structs
 /// with dtors may not be destructured, but tuple structs can,
@@ -83,6 +84,14 @@ pub struct Loop {
     priv handle: *uvll::uv_loop_t
 }
 
+pub struct Handle(*uvll::uv_handle_t);
+
+impl Watcher for Handle {}
+impl NativeHandle<*uvll::uv_handle_t> for Handle {
+    fn from_native_handle(h: *uvll::uv_handle_t) -> Handle { Handle(h) }
+    fn native_handle(&self) -> *uvll::uv_handle_t { **self }
+}
+
 /// The trait implemented by uv 'watchers' (handles). Watchers are
 /// non-owning wrappers around the uv handles and are not completely
 /// safe - there may be multiple instances for a single underlying
@@ -160,6 +169,7 @@ pub trait WatcherInterop {
     fn install_watcher_data(&mut self);
     fn get_watcher_data<'r>(&'r mut self) -> &'r mut WatcherData;
     fn drop_watcher_data(&mut self);
+    fn close(self, cb: NullCallback);
 }
 
 impl<H, W: Watcher + NativeHandle<*H>> WatcherInterop for W {
@@ -207,6 +217,24 @@ impl<H, W: Watcher + NativeHandle<*H>> WatcherInterop for W {
             uvll::set_data_for_uv_handle(self.native_handle(), null::<()>());
         }
     }
+
+    fn close(self, cb: NullCallback) {
+        let mut this = self;
+        {
+            let data = this.get_watcher_data();
+            assert!(data.close_cb.is_none());
+            data.close_cb = Some(cb);
+        }
+
+        unsafe { uvll::close(this.native_handle(), close_cb); }
+
+        extern fn close_cb(handle: *uvll::uv_handle_t) {
+            let mut h: Handle = NativeHandle::from_native_handle(handle);
+            h.get_watcher_data().close_cb.take_unwrap()();
+            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

branches/try2/src/libstd/rt/uv/net.rs

@@ -13,7 +13,7 @@ use libc::{size_t, ssize_t, c_int, c_void, c_uint};
 use rt::uv::uvll;
 use rt::uv::uvll::*;
 use rt::uv::{AllocCallback, ConnectionCallback, ReadCallback, UdpReceiveCallback, UdpSendCallback};
-use rt::uv::{Loop, Watcher, Request, UvError, Buf, NativeHandle, NullCallback,
+use rt::uv::{Loop, Watcher, Request, UvError, Buf, NativeHandle,
              status_to_maybe_uv_error, vec_to_uv_buf};
 use rt::io::net::ip::{SocketAddr, Ipv4Addr, Ipv6Addr};
 use vec;
@@ -184,24 +184,6 @@ impl StreamWatcher {
         }
     }
 
-    pub fn close(self, cb: NullCallback) {
-        {
-            let mut this = self;
-            let data = this.get_watcher_data();
-            assert!(data.close_cb.is_none());
-            data.close_cb = Some(cb);
-        }
-
-        unsafe { uvll::close(self.native_handle(), close_cb); }
-
-        extern fn close_cb(handle: *uvll::uv_stream_t) {
-            let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(handle);
-            let cb = stream_watcher.get_watcher_data().close_cb.take_unwrap();
-            stream_watcher.drop_watcher_data();
-            unsafe { free_handle(handle as *c_void) }
-            cb();
-        }
-    }
 
     pub fn listen(&mut self, cb: ConnectionCallback) -> Result<(), UvError> {
         {
@@ -413,25 +395,6 @@ impl UdpWatcher {
             cb(udp_watcher, status);
         }
     }
-
-    pub fn close(self, cb: NullCallback) {
-        {
-            let mut this = self;
-            let data = this.get_watcher_data();
-            assert!(data.close_cb.is_none());
-            data.close_cb = Some(cb);
-        }
-
-        unsafe { uvll::close(self.native_handle(), close_cb); }
-
-        extern fn close_cb(handle: *uvll::uv_udp_t) {
-            let mut udp_watcher: UdpWatcher = NativeHandle::from_native_handle(handle);
-            let cb = udp_watcher.get_watcher_data().close_cb.take_unwrap();
-            udp_watcher.drop_watcher_data();
-            unsafe { free_handle(handle as *c_void) }
-            cb();
-        }
-    }
 }
 
 impl NativeHandle<*uvll::uv_udp_t> for UdpWatcher {