From 94d71f8836b3bfac3370e4d324ca1987d843552f Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Tue, 24 Feb 2015 23:27:20 -0800 Subject: std: Implement stdio for `std::io` This is an implementation of RFC 899 and adds stdio functionality to the new `std::io` module. Details of the API can be found on the RFC, but from a high level: * `io::{stdin, stdout, stderr}` constructors are now available. There are also `*_raw` variants for unbuffered and unlocked access. * All handles are globally shared (excluding raw variants). * The stderr handle is no longer buffered. * All handles can be explicitly locked (excluding the raw variants). The `print!` and `println!` machinery has not yet been hooked up to these streams just yet. The `std::fmt::output` module has also not yet been implemented as part of this commit. --- src/libstd/sys/unix/mod.rs | 1 + src/libstd/sys/unix/stdio.rs | 52 +++++++++++++ src/libstd/sys/windows/c.rs | 6 ++ src/libstd/sys/windows/handle.rs | 11 ++- src/libstd/sys/windows/mod.rs | 1 + src/libstd/sys/windows/stdio.rs | 155 +++++++++++++++++++++++++++++++++++++++ 6 files changed, 224 insertions(+), 2 deletions(-) create mode 100644 src/libstd/sys/unix/stdio.rs create mode 100644 src/libstd/sys/windows/stdio.rs (limited to 'src/libstd/sys') diff --git a/src/libstd/sys/unix/mod.rs b/src/libstd/sys/unix/mod.rs index 632270bc5cc..80bfd57e933 100644 --- a/src/libstd/sys/unix/mod.rs +++ b/src/libstd/sys/unix/mod.rs @@ -63,6 +63,7 @@ pub mod time; pub mod timer; pub mod tty; pub mod udp; +pub mod stdio; pub mod addrinfo { pub use sys_common::net::get_host_addresses; diff --git a/src/libstd/sys/unix/stdio.rs b/src/libstd/sys/unix/stdio.rs new file mode 100644 index 00000000000..2f9610fa5b5 --- /dev/null +++ b/src/libstd/sys/unix/stdio.rs @@ -0,0 +1,52 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use prelude::v1::*; + +use io; +use libc; +use sys::fd::FileDesc; + +pub struct Stdin(()); +pub struct Stdout(()); +pub struct Stderr(()); + +impl Stdin { + pub fn new() -> Stdin { Stdin(()) } + + pub fn read(&self, data: &mut [u8]) -> io::Result { + let fd = FileDesc::new(libc::STDIN_FILENO); + let ret = fd.read(data); + fd.into_raw(); + return ret; + } +} + +impl Stdout { + pub fn new() -> Stdout { Stdout(()) } + + pub fn write(&self, data: &[u8]) -> io::Result { + let fd = FileDesc::new(libc::STDOUT_FILENO); + let ret = fd.write(data); + fd.into_raw(); + return ret; + } +} + +impl Stderr { + pub fn new() -> Stderr { Stderr(()) } + + pub fn write(&self, data: &[u8]) -> io::Result { + let fd = FileDesc::new(libc::STDERR_FILENO); + let ret = fd.write(data); + fd.into_raw(); + return ret; + } +} diff --git a/src/libstd/sys/windows/c.rs b/src/libstd/sys/windows/c.rs index 2d1a5e10bd6..8ed7302b665 100644 --- a/src/libstd/sys/windows/c.rs +++ b/src/libstd/sys/windows/c.rs @@ -48,6 +48,11 @@ pub const WSAESHUTDOWN: libc::c_int = 10058; pub const ERROR_NO_MORE_FILES: libc::DWORD = 18; pub const TOKEN_READ: libc::DWORD = 0x20008; +// Note that these are not actually HANDLEs, just values to pass to GetStdHandle +pub const STD_INPUT_HANDLE: libc::DWORD = -10; +pub const STD_OUTPUT_HANDLE: libc::DWORD = -11; +pub const STD_ERROR_HANDLE: libc::DWORD = -12; + #[repr(C)] #[cfg(target_arch = "x86")] pub struct WSADATA { @@ -427,6 +432,7 @@ extern "system" { DesiredAccess: libc::DWORD, TokenHandle: *mut libc::HANDLE) -> libc::BOOL; pub fn GetCurrentProcess() -> libc::HANDLE; + pub fn GetStdHandle(which: libc::DWORD) -> libc::HANDLE; } #[link(name = "userenv")] diff --git a/src/libstd/sys/windows/handle.rs b/src/libstd/sys/windows/handle.rs index 99de659be41..0089dcad455 100644 --- a/src/libstd/sys/windows/handle.rs +++ b/src/libstd/sys/windows/handle.rs @@ -10,9 +10,10 @@ use prelude::v1::*; -use libc::{self, HANDLE}; -use io; use io::ErrorKind; +use io; +use libc::{self, HANDLE}; +use mem; use ptr; use sys::cvt; @@ -28,6 +29,12 @@ impl Handle { pub fn raw(&self) -> HANDLE { self.0 } + pub fn into_raw(self) -> HANDLE { + let ret = self.0; + unsafe { mem::forget(self) } + return ret; + } + pub fn read(&self, buf: &mut [u8]) -> io::Result { read(self.0, buf) } diff --git a/src/libstd/sys/windows/mod.rs b/src/libstd/sys/windows/mod.rs index 5bb2a134533..3bdadbb9012 100644 --- a/src/libstd/sys/windows/mod.rs +++ b/src/libstd/sys/windows/mod.rs @@ -61,6 +61,7 @@ pub mod time; pub mod timer; pub mod tty; pub mod udp; +pub mod stdio; pub mod addrinfo { pub use sys_common::net::get_host_addresses; diff --git a/src/libstd/sys/windows/stdio.rs b/src/libstd/sys/windows/stdio.rs new file mode 100644 index 00000000000..72ce8b7c6e3 --- /dev/null +++ b/src/libstd/sys/windows/stdio.rs @@ -0,0 +1,155 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use prelude::v1::*; +use io::prelude::*; + +use io::{self, Cursor}; +use iter::repeat; +use libc; +use ptr; +use str; +use sync::Mutex; +use sys::c; +use sys::cvt; +use sys::handle::Handle; + +struct NoClose(Option); + +enum Output { + Console(NoClose), + Pipe(NoClose), +} + +pub struct Stdin { + handle: Output, + utf8: Mutex>>, +} +pub struct Stdout(Output); +pub struct Stderr(Output); + +fn get(handle: libc::DWORD) -> io::Result { + let handle = unsafe { c::GetStdHandle(handle) }; + if handle == libc::INVALID_HANDLE_VALUE { + Err(io::Error::last_os_error()) + } else if handle.is_null() { + Err(io::Error::new(io::ErrorKind::Other, + "no stdio handle available for this process", None)) + } else { + let ret = NoClose::new(handle); + let mut out = 0; + match unsafe { c::GetConsoleMode(handle, &mut out) } { + 0 => Ok(Output::Pipe(ret)), + _ => Ok(Output::Console(ret)), + } + } +} + +fn write(out: &Output, data: &[u8]) -> io::Result { + let handle = match *out { + Output::Console(ref c) => c.get().raw(), + Output::Pipe(ref p) => return p.get().write(data), + }; + let utf16 = match str::from_utf8(data).ok() { + Some(utf8) => utf8.utf16_units().collect::>(), + None => return Err(invalid_encoding()), + }; + let mut written = 0; + try!(cvt(unsafe { + c::WriteConsoleW(handle, + utf16.as_ptr() as libc::LPCVOID, + utf16.len() as u32, + &mut written, + ptr::null_mut()) + })); + + // FIXME if this only partially writes the utf16 buffer then we need to + // figure out how many bytes of `data` were actually written + assert_eq!(written as usize, utf16.len()); + Ok(data.len()) +} + +impl Stdin { + pub fn new() -> Stdin { + Stdin { + handle: get(c::STD_INPUT_HANDLE).unwrap(), + utf8: Mutex::new(Cursor::new(Vec::new())), + } + } + + pub fn read(&self, buf: &mut [u8]) -> io::Result { + let handle = match self.handle { + Output::Console(ref c) => c.get().raw(), + Output::Pipe(ref p) => return p.get().read(buf), + }; + let mut utf8 = self.utf8.lock().unwrap(); + // Read more if the buffer is empty + if utf8.position() as usize == utf8.get_ref().len() { + let mut utf16: Vec = repeat(0u16).take(0x1000).collect(); + let mut num = 0; + try!(cvt(unsafe { + c::ReadConsoleW(handle, + utf16.as_mut_ptr() as libc::LPVOID, + utf16.len() as u32, + &mut num, + ptr::null_mut()) + })); + utf16.truncate(num as usize); + // FIXME: what to do about this data that has already been read? + let data = match String::from_utf16(&utf16) { + Ok(utf8) => utf8.into_bytes(), + Err(..) => return Err(invalid_encoding()), + }; + *utf8 = Cursor::new(data); + } + + // MemReader shouldn't error here since we just filled it + utf8.read(buf) + } +} + +impl Stdout { + pub fn new() -> Stdout { + Stdout(get(c::STD_OUTPUT_HANDLE).unwrap()) + } + + pub fn write(&self, data: &[u8]) -> io::Result { + write(&self.0, data) + } +} + +impl Stderr { + pub fn new() -> Stderr { + Stderr(get(c::STD_ERROR_HANDLE).unwrap()) + } + + pub fn write(&self, data: &[u8]) -> io::Result { + write(&self.0, data) + } +} + +impl NoClose { + fn new(handle: libc::HANDLE) -> NoClose { + NoClose(Some(Handle::new(handle))) + } + + fn get(&self) -> &Handle { self.0.as_ref().unwrap() } +} + +impl Drop for NoClose { + fn drop(&mut self) { + self.0.take().unwrap().into_raw(); + } +} + +fn invalid_encoding() -> io::Error { + io::Error::new(io::ErrorKind::InvalidInput, "text was not valid unicode", + None) +} -- cgit 1.4.1-3-g733a5