diff options
Diffstat (limited to 'src/libstd/sys')
| -rw-r--r-- | src/libstd/sys/common/net2.rs | 32 | ||||
| -rw-r--r-- | src/libstd/sys/common/wtf8.rs | 12 | ||||
| -rw-r--r-- | src/libstd/sys/unix/ext.rs | 375 | ||||
| -rw-r--r-- | src/libstd/sys/unix/net.rs | 8 | ||||
| -rw-r--r-- | src/libstd/sys/unix/os.rs | 8 | ||||
| -rw-r--r-- | src/libstd/sys/unix/os_str.rs | 1 | ||||
| -rw-r--r-- | src/libstd/sys/unix/process2.rs | 2 | ||||
| -rw-r--r-- | src/libstd/sys/windows/ext.rs | 320 | ||||
| -rw-r--r-- | src/libstd/sys/windows/mod.rs | 2 | ||||
| -rw-r--r-- | src/libstd/sys/windows/net.rs | 8 | ||||
| -rw-r--r-- | src/libstd/sys/windows/os.rs | 3 | ||||
| -rw-r--r-- | src/libstd/sys/windows/process2.rs | 3 |
12 files changed, 431 insertions, 343 deletions
diff --git a/src/libstd/sys/common/net2.rs b/src/libstd/sys/common/net2.rs index af5b49a4239..25aeab1b4ff 100644 --- a/src/libstd/sys/common/net2.rs +++ b/src/libstd/sys/common/net2.rs @@ -14,7 +14,7 @@ use ffi::CString; use io::{self, Error, ErrorKind}; use libc::{self, c_int, c_char, c_void, socklen_t}; use mem; -use net::{IpAddr, SocketAddr, Shutdown}; +use net::{SocketAddr, Shutdown}; use sys::c; use sys::net::{cvt, cvt_r, cvt_gai, Socket, init, wrlen_t}; use sys_common::{AsInner, FromInner, IntoInner}; @@ -63,15 +63,15 @@ fn sockaddr_to_addr(storage: &libc::sockaddr_storage, match storage.ss_family as libc::c_int { libc::AF_INET => { assert!(len as usize >= mem::size_of::<libc::sockaddr_in>()); - Ok(FromInner::from_inner(unsafe { + Ok(SocketAddr::V4(FromInner::from_inner(unsafe { *(storage as *const _ as *const libc::sockaddr_in) - })) + }))) } libc::AF_INET6 => { assert!(len as usize >= mem::size_of::<libc::sockaddr_in6>()); - Ok(FromInner::from_inner(unsafe { + Ok(SocketAddr::V6(FromInner::from_inner(unsafe { *(storage as *const _ as *const libc::sockaddr_in6) - })) + }))) } _ => { Err(Error::new(ErrorKind::InvalidInput, "invalid argument", None)) @@ -334,39 +334,39 @@ impl UdpSocket { libc::IP_MULTICAST_LOOP, on as c_int) } - pub fn join_multicast(&self, multi: &IpAddr) -> io::Result<()> { + pub fn join_multicast(&self, multi: &SocketAddr) -> io::Result<()> { match *multi { - IpAddr::V4(..) => { + SocketAddr::V4(..) => { self.set_membership(multi, libc::IP_ADD_MEMBERSHIP) } - IpAddr::V6(..) => { + SocketAddr::V6(..) => { self.set_membership(multi, libc::IPV6_ADD_MEMBERSHIP) } } } - pub fn leave_multicast(&self, multi: &IpAddr) -> io::Result<()> { + pub fn leave_multicast(&self, multi: &SocketAddr) -> io::Result<()> { match *multi { - IpAddr::V4(..) => { + SocketAddr::V4(..) => { self.set_membership(multi, libc::IP_DROP_MEMBERSHIP) } - IpAddr::V6(..) => { + SocketAddr::V6(..) => { self.set_membership(multi, libc::IPV6_DROP_MEMBERSHIP) } } } - fn set_membership(&self, addr: &IpAddr, opt: c_int) -> io::Result<()> { + fn set_membership(&self, addr: &SocketAddr, opt: c_int) -> io::Result<()> { match *addr { - IpAddr::V4(ref addr) => { + SocketAddr::V4(ref addr) => { let mreq = libc::ip_mreq { - imr_multiaddr: *addr.as_inner(), + imr_multiaddr: *addr.ip().as_inner(), // interface == INADDR_ANY imr_interface: libc::in_addr { s_addr: 0x0 }, }; setsockopt(&self.inner, libc::IPPROTO_IP, opt, mreq) } - IpAddr::V6(ref addr) => { + SocketAddr::V6(ref addr) => { let mreq = libc::ip6_mreq { - ipv6mr_multiaddr: *addr.as_inner(), + ipv6mr_multiaddr: *addr.ip().as_inner(), ipv6mr_interface: 0, }; setsockopt(&self.inner, libc::IPPROTO_IPV6, opt, mreq) diff --git a/src/libstd/sys/common/wtf8.rs b/src/libstd/sys/common/wtf8.rs index 4c0b26f8649..dfc88571a82 100644 --- a/src/libstd/sys/common/wtf8.rs +++ b/src/libstd/sys/common/wtf8.rs @@ -172,6 +172,7 @@ impl Wtf8Buf { Wtf8Buf { bytes: string.into_bytes() } } + #[cfg(stage0)] /// Create a WTF-8 string from an UTF-8 `&str` slice. /// /// This copies the content of the slice. @@ -182,6 +183,17 @@ impl Wtf8Buf { Wtf8Buf { bytes: slice::SliceExt::to_vec(str.as_bytes()) } } + #[cfg(not(stage0))] + /// Create a WTF-8 string from an UTF-8 `&str` slice. + /// + /// This copies the content of the slice. + /// + /// Since WTF-8 is a superset of UTF-8, this always succeeds. + #[inline] + pub fn from_str(str: &str) -> Wtf8Buf { + Wtf8Buf { bytes: <[_]>::to_vec(str.as_bytes()) } + } + /// Create a WTF-8 string from a potentially ill-formed UTF-16 slice of 16-bit code units. /// /// This is lossless: calling `.encode_wide()` on the resulting string diff --git a/src/libstd/sys/unix/ext.rs b/src/libstd/sys/unix/ext.rs index 3dd05319194..0805949d560 100644 --- a/src/libstd/sys/unix/ext.rs +++ b/src/libstd/sys/unix/ext.rs @@ -29,183 +29,206 @@ //! } //! ``` -#![unstable(feature = "std_misc")] - -use prelude::v1::*; - -use ffi::{CString, NulError, OsStr, OsString}; -use fs::{self, Permissions, OpenOptions}; -use net; -use mem; -use process; -use sys; -use sys::os_str::Buf; -use sys_common::{AsInner, AsInnerMut, IntoInner, FromInner}; -use libc::{self, gid_t, uid_t}; - -#[allow(deprecated)] use old_io; - -/// Raw file descriptors. -pub type Fd = libc::c_int; - -/// Extract raw file descriptor -pub trait AsRawFd { - /// Extract the raw file descriptor, without taking any ownership. - fn as_raw_fd(&self) -> Fd; -} +#![stable(feature = "rust1", since = "1.0.0")] + +/// Unix-specific extensions to general I/O primitives +#[unstable(feature = "io_ext", + reason = "may want a slightly different organization or a more \ + general file descriptor primitive")] +pub mod io { + #[allow(deprecated)] use old_io; + use fs; + use libc; + use net; + use sys_common::AsInner; + + /// Raw file descriptors. + pub type Fd = libc::c_int; + + /// Extract raw file descriptor + pub trait AsRawFd { + /// Extract the raw file descriptor, without taking any ownership. + fn as_raw_fd(&self) -> Fd; + } -#[allow(deprecated)] -impl AsRawFd for old_io::fs::File { - fn as_raw_fd(&self) -> Fd { - self.as_inner().fd() + #[allow(deprecated)] + impl AsRawFd for old_io::fs::File { + fn as_raw_fd(&self) -> Fd { + self.as_inner().fd() + } } -} -impl AsRawFd for fs::File { - fn as_raw_fd(&self) -> Fd { - self.as_inner().fd().raw() + impl AsRawFd for fs::File { + fn as_raw_fd(&self) -> Fd { + self.as_inner().fd().raw() + } } -} -#[allow(deprecated)] -impl AsRawFd for old_io::pipe::PipeStream { - fn as_raw_fd(&self) -> Fd { - self.as_inner().fd() + #[allow(deprecated)] + impl AsRawFd for old_io::pipe::PipeStream { + fn as_raw_fd(&self) -> Fd { + self.as_inner().fd() + } } -} -#[allow(deprecated)] -impl AsRawFd for old_io::net::pipe::UnixStream { - fn as_raw_fd(&self) -> Fd { - self.as_inner().fd() + #[allow(deprecated)] + impl AsRawFd for old_io::net::pipe::UnixStream { + fn as_raw_fd(&self) -> Fd { + self.as_inner().fd() + } } -} -#[allow(deprecated)] -impl AsRawFd for old_io::net::pipe::UnixListener { - fn as_raw_fd(&self) -> Fd { - self.as_inner().fd() + #[allow(deprecated)] + impl AsRawFd for old_io::net::pipe::UnixListener { + fn as_raw_fd(&self) -> Fd { + self.as_inner().fd() + } } -} -#[allow(deprecated)] -impl AsRawFd for old_io::net::pipe::UnixAcceptor { - fn as_raw_fd(&self) -> Fd { - self.as_inner().fd() + #[allow(deprecated)] + impl AsRawFd for old_io::net::pipe::UnixAcceptor { + fn as_raw_fd(&self) -> Fd { + self.as_inner().fd() + } } -} -#[allow(deprecated)] -impl AsRawFd for old_io::net::tcp::TcpStream { - fn as_raw_fd(&self) -> Fd { - self.as_inner().fd() + #[allow(deprecated)] + impl AsRawFd for old_io::net::tcp::TcpStream { + fn as_raw_fd(&self) -> Fd { + self.as_inner().fd() + } } -} -#[allow(deprecated)] -impl AsRawFd for old_io::net::tcp::TcpListener { - fn as_raw_fd(&self) -> Fd { - self.as_inner().fd() + #[allow(deprecated)] + impl AsRawFd for old_io::net::tcp::TcpListener { + fn as_raw_fd(&self) -> Fd { + self.as_inner().fd() + } } -} -#[allow(deprecated)] -impl AsRawFd for old_io::net::tcp::TcpAcceptor { - fn as_raw_fd(&self) -> Fd { - self.as_inner().fd() + #[allow(deprecated)] + impl AsRawFd for old_io::net::tcp::TcpAcceptor { + fn as_raw_fd(&self) -> Fd { + self.as_inner().fd() + } } -} -#[allow(deprecated)] -impl AsRawFd for old_io::net::udp::UdpSocket { - fn as_raw_fd(&self) -> Fd { - self.as_inner().fd() + #[allow(deprecated)] + impl AsRawFd for old_io::net::udp::UdpSocket { + fn as_raw_fd(&self) -> Fd { + self.as_inner().fd() + } } -} -impl AsRawFd for net::TcpStream { - fn as_raw_fd(&self) -> Fd { *self.as_inner().socket().as_inner() } -} -impl AsRawFd for net::TcpListener { - fn as_raw_fd(&self) -> Fd { *self.as_inner().socket().as_inner() } -} -impl AsRawFd for net::UdpSocket { - fn as_raw_fd(&self) -> Fd { *self.as_inner().socket().as_inner() } + impl AsRawFd for net::TcpStream { + fn as_raw_fd(&self) -> Fd { *self.as_inner().socket().as_inner() } + } + impl AsRawFd for net::TcpListener { + fn as_raw_fd(&self) -> Fd { *self.as_inner().socket().as_inner() } + } + impl AsRawFd for net::UdpSocket { + fn as_raw_fd(&self) -> Fd { *self.as_inner().socket().as_inner() } + } } //////////////////////////////////////////////////////////////////////////////// // OsString and OsStr //////////////////////////////////////////////////////////////////////////////// -/// Unix-specific extensions to `OsString`. -pub trait OsStringExt { - /// Create an `OsString` from a byte vector. - fn from_vec(vec: Vec<u8>) -> Self; - - /// Yield the underlying byte vector of this `OsString`. - fn into_vec(self) -> Vec<u8>; -} - -impl OsStringExt for OsString { - fn from_vec(vec: Vec<u8>) -> OsString { - FromInner::from_inner(Buf { inner: vec }) +/// Unix-specific extension to the primitives in the `std::ffi` module +#[stable(feature = "rust1", since = "1.0.0")] +pub mod ffi { + use ffi::{CString, NulError, OsStr, OsString}; + use mem; + use prelude::v1::*; + use sys::os_str::Buf; + use sys_common::{FromInner, IntoInner, AsInner}; + + /// Unix-specific extensions to `OsString`. + #[stable(feature = "rust1", since = "1.0.0")] + pub trait OsStringExt { + /// Create an `OsString` from a byte vector. + #[stable(feature = "rust1", since = "1.0.0")] + fn from_vec(vec: Vec<u8>) -> Self; + + /// Yield the underlying byte vector of this `OsString`. + #[stable(feature = "rust1", since = "1.0.0")] + fn into_vec(self) -> Vec<u8>; } - fn into_vec(self) -> Vec<u8> { - self.into_inner().inner + #[stable(feature = "rust1", since = "1.0.0")] + impl OsStringExt for OsString { + fn from_vec(vec: Vec<u8>) -> OsString { + FromInner::from_inner(Buf { inner: vec }) + } + fn into_vec(self) -> Vec<u8> { + self.into_inner().inner + } } -} - -/// Unix-specific extensions to `OsStr`. -pub trait OsStrExt { - fn from_bytes(slice: &[u8]) -> &OsStr; - /// Get the underlying byte view of the `OsStr` slice. - fn as_bytes(&self) -> &[u8]; + /// Unix-specific extensions to `OsStr`. + #[stable(feature = "rust1", since = "1.0.0")] + pub trait OsStrExt { + #[stable(feature = "rust1", since = "1.0.0")] + fn from_bytes(slice: &[u8]) -> &Self; - /// Convert the `OsStr` slice into a `CString`. - fn to_cstring(&self) -> Result<CString, NulError>; -} + /// Get the underlying byte view of the `OsStr` slice. + #[stable(feature = "rust1", since = "1.0.0")] + fn as_bytes(&self) -> &[u8]; -impl OsStrExt for OsStr { - fn from_bytes(slice: &[u8]) -> &OsStr { - unsafe { mem::transmute(slice) } - } - fn as_bytes(&self) -> &[u8] { - &self.as_inner().inner + /// Convert the `OsStr` slice into a `CString`. + #[stable(feature = "rust1", since = "1.0.0")] + fn to_cstring(&self) -> Result<CString, NulError>; } - fn to_cstring(&self) -> Result<CString, NulError> { - CString::new(self.as_bytes()) + #[stable(feature = "rust1", since = "1.0.0")] + impl OsStrExt for OsStr { + fn from_bytes(slice: &[u8]) -> &OsStr { + unsafe { mem::transmute(slice) } + } + fn as_bytes(&self) -> &[u8] { + &self.as_inner().inner + } + fn to_cstring(&self) -> Result<CString, NulError> { + CString::new(self.as_bytes()) + } } } -// Unix-specific extensions to `Permissions` -pub trait PermissionsExt { - fn mode(&self) -> i32; - fn set_mode(&mut self, mode: i32); -} +/// Unix-specific extensions to primitives in the `std::fs` module. +#[unstable(feature = "fs_ext", + reason = "may want a more useful mode abstraction")] +pub mod fs { + use sys_common::{FromInner, AsInner, AsInnerMut}; + use fs::{Permissions, OpenOptions}; + + /// Unix-specific extensions to `Permissions` + pub trait PermissionsExt { + fn mode(&self) -> i32; + fn set_mode(&mut self, mode: i32); + } -impl PermissionsExt for Permissions { - fn mode(&self) -> i32 { self.as_inner().mode() } + impl PermissionsExt for Permissions { + fn mode(&self) -> i32 { self.as_inner().mode() } - fn set_mode(&mut self, mode: i32) { - *self = FromInner::from_inner(FromInner::from_inner(mode)); + fn set_mode(&mut self, mode: i32) { + *self = FromInner::from_inner(FromInner::from_inner(mode)); + } } -} -// Unix-specific extensions to `OpenOptions` -pub trait OpenOptionsExt { - /// Set the mode bits that a new file will be created with. - /// - /// If a new file is created as part of a `File::open_opts` call then this - /// specified `mode` will be used as the permission bits for the new file. - fn mode(&mut self, mode: i32) -> &mut Self; -} + /// Unix-specific extensions to `OpenOptions` + pub trait OpenOptionsExt { + /// Set the mode bits that a new file will be created with. + /// + /// If a new file is created as part of a `File::open_opts` call then this + /// specified `mode` will be used as the permission bits for the new file. + fn mode(&mut self, mode: i32) -> &mut Self; + } -impl OpenOptionsExt for OpenOptions { - fn mode(&mut self, mode: i32) -> &mut OpenOptions { - self.as_inner_mut().mode(mode); self + impl OpenOptionsExt for OpenOptions { + fn mode(&mut self, mode: i32) -> &mut OpenOptions { + self.as_inner_mut().mode(mode); self + } } } @@ -213,41 +236,58 @@ impl OpenOptionsExt for OpenOptions { // Process and Command //////////////////////////////////////////////////////////////////////////////// -/// Unix-specific extensions to the `std::process::Command` builder -pub trait CommandExt { - /// Sets the child process's user id. This translates to a - /// `setuid` call in the child process. Failure in the `setuid` - /// call will cause the spawn to fail. - fn uid(&mut self, id: uid_t) -> &mut process::Command; +/// Unix-specific extensions to primitives in the `std::process` module. +#[stable(feature = "rust1", since = "1.0.0")] +pub mod process { + use prelude::v1::*; + use libc::{uid_t, gid_t}; + use process; + use sys; + use sys_common::{AsInnerMut, AsInner}; + + /// Unix-specific extensions to the `std::process::Command` builder + #[stable(feature = "rust1", since = "1.0.0")] + pub trait CommandExt { + /// Sets the child process's user id. This translates to a + /// `setuid` call in the child process. Failure in the `setuid` + /// call will cause the spawn to fail. + #[stable(feature = "rust1", since = "1.0.0")] + fn uid(&mut self, id: uid_t) -> &mut process::Command; + + /// Similar to `uid`, but sets the group id of the child process. This has + /// the same semantics as the `uid` field. + #[stable(feature = "rust1", since = "1.0.0")] + fn gid(&mut self, id: gid_t) -> &mut process::Command; + } - /// Similar to `uid`, but sets the group id of the child process. This has - /// the same semantics as the `uid` field. - fn gid(&mut self, id: gid_t) -> &mut process::Command; -} + #[stable(feature = "rust1", since = "1.0.0")] + impl CommandExt for process::Command { + fn uid(&mut self, id: uid_t) -> &mut process::Command { + self.as_inner_mut().uid = Some(id); + self + } -impl CommandExt for process::Command { - fn uid(&mut self, id: uid_t) -> &mut process::Command { - self.as_inner_mut().uid = Some(id); - self + fn gid(&mut self, id: gid_t) -> &mut process::Command { + self.as_inner_mut().gid = Some(id); + self + } } - fn gid(&mut self, id: gid_t) -> &mut process::Command { - self.as_inner_mut().gid = Some(id); - self + /// Unix-specific extensions to `std::process::ExitStatus` + #[stable(feature = "rust1", since = "1.0.0")] + pub trait ExitStatusExt { + /// If the process was terminated by a signal, returns that signal. + #[stable(feature = "rust1", since = "1.0.0")] + fn signal(&self) -> Option<i32>; } -} - -/// Unix-specific extensions to `std::process::ExitStatus` -pub trait ExitStatusExt { - /// If the process was terminated by a signal, returns that signal. - fn signal(&self) -> Option<i32>; -} -impl ExitStatusExt for process::ExitStatus { - fn signal(&self) -> Option<i32> { - match *self.as_inner() { - sys::process2::ExitStatus::Signal(s) => Some(s), - _ => None + #[stable(feature = "rust1", since = "1.0.0")] + impl ExitStatusExt for process::ExitStatus { + fn signal(&self) -> Option<i32> { + match *self.as_inner() { + sys::process2::ExitStatus::Signal(s) => Some(s), + _ => None + } } } } @@ -259,9 +299,14 @@ impl ExitStatusExt for process::ExitStatus { /// A prelude for conveniently writing platform-specific code. /// /// Includes all extension traits, and some important type definitions. +#[stable(feature = "rust1", since = "1.0.0")] pub mod prelude { #[doc(no_inline)] - pub use super::{Fd, AsRawFd, OsStrExt, OsStringExt, PermissionsExt}; + pub use super::io::{Fd, AsRawFd}; + #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")] + pub use super::ffi::{OsStrExt, OsStringExt}; #[doc(no_inline)] - pub use super::{CommandExt, ExitStatusExt}; + pub use super::fs::{PermissionsExt, OpenOptionsExt}; + #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")] + pub use super::process::{CommandExt, ExitStatusExt}; } diff --git a/src/libstd/sys/unix/net.rs b/src/libstd/sys/unix/net.rs index 83b6a14b78d..b22fa33e562 100644 --- a/src/libstd/sys/unix/net.rs +++ b/src/libstd/sys/unix/net.rs @@ -15,7 +15,7 @@ use io; use libc::{self, c_int, size_t}; use str; use sys::c; -use net::{SocketAddr, IpAddr}; +use net::SocketAddr; use sys::fd::FileDesc; use sys_common::AsInner; @@ -40,9 +40,9 @@ pub fn cvt_gai(err: c_int) -> io::Result<()> { impl Socket { pub fn new(addr: &SocketAddr, ty: c_int) -> io::Result<Socket> { - let fam = match addr.ip() { - IpAddr::V4(..) => libc::AF_INET, - IpAddr::V6(..) => libc::AF_INET6, + let fam = match *addr { + SocketAddr::V4(..) => libc::AF_INET, + SocketAddr::V6(..) => libc::AF_INET6, }; unsafe { let fd = try!(cvt(libc::socket(fam, ty, 0))); diff --git a/src/libstd/sys/unix/os.rs b/src/libstd/sys/unix/os.rs index b0ad9ab6937..75aeafe6e3c 100644 --- a/src/libstd/sys/unix/os.rs +++ b/src/libstd/sys/unix/os.rs @@ -13,7 +13,7 @@ #![allow(unused_imports)] // lots of cfg code here use prelude::v1::*; -use os::unix::*; +use os::unix::prelude::*; use error::Error as StdError; use ffi::{CString, CStr, OsString, OsStr, AsOsStr}; @@ -206,7 +206,7 @@ pub fn current_exe() -> io::Result<PathBuf> { if err != 0 { return Err(io::Error::last_os_error()); } if sz == 0 { return Err(io::Error::last_os_error()); } v.set_len(sz as uint - 1); // chop off trailing NUL - Ok(PathBuf::new::<OsString>(&OsStringExt::from_vec(v))) + Ok(PathBuf::new::<OsString>(OsStringExt::from_vec(v))) } } @@ -232,7 +232,7 @@ pub fn current_exe() -> io::Result<PathBuf> { Err(io::Error::last_os_error()) } else { let vec = CStr::from_ptr(v).to_bytes().to_vec(); - Ok(PathBuf::new::<OsString>(&OsStringExt::from_vec(vec))) + Ok(PathBuf::new::<OsString>(OsStringExt::from_vec(vec))) } } } @@ -286,7 +286,7 @@ pub fn args() -> Args { let vec = unsafe { let (argc, argv) = (*_NSGetArgc() as isize, *_NSGetArgv() as *const *const c_char); - range(0, argc as isize).map(|i| { + (0.. argc as isize).map(|i| { let bytes = CStr::from_ptr(*argv.offset(i)).to_bytes().to_vec(); OsStringExt::from_vec(bytes) }).collect::<Vec<_>>() diff --git a/src/libstd/sys/unix/os_str.rs b/src/libstd/sys/unix/os_str.rs index 89ab3e1981b..99591480752 100644 --- a/src/libstd/sys/unix/os_str.rs +++ b/src/libstd/sys/unix/os_str.rs @@ -16,6 +16,7 @@ use core::prelude::*; use borrow::Cow; use fmt::{self, Debug}; use vec::Vec; +#[cfg(stage0)] use slice::SliceExt as StdSliceExt; use str; use string::String; diff --git a/src/libstd/sys/unix/process2.rs b/src/libstd/sys/unix/process2.rs index 03b77eb75d7..20c409154b8 100644 --- a/src/libstd/sys/unix/process2.rs +++ b/src/libstd/sys/unix/process2.rs @@ -9,6 +9,7 @@ // except according to those terms. use prelude::v1::*; +use os::unix::prelude::*; use collections::HashMap; use env; @@ -17,7 +18,6 @@ use fmt; use io::{self, Error, ErrorKind}; use libc::{self, pid_t, c_void, c_int, gid_t, uid_t}; use mem; -use os::unix::OsStrExt; use ptr; use sys::pipe2::AnonPipe; use sys::{self, retry, c, cvt}; diff --git a/src/libstd/sys/windows/ext.rs b/src/libstd/sys/windows/ext.rs index dc820a4ce45..7955397892b 100644 --- a/src/libstd/sys/windows/ext.rs +++ b/src/libstd/sys/windows/ext.rs @@ -14,197 +14,225 @@ //! descriptors, and sockets, but its functionality will grow over //! time. -#![unstable(feature = "std_misc")] +#![stable(feature = "rust1", since = "1.0.0")] -pub use sys_common::wtf8::{Wtf8Buf, EncodeWide}; +#[unstable(feature = "io_ext", + reason = "organization may change slightly and the primitives \ + provided may be tweaked")] +pub mod io { + use fs; + use libc; + use net; + use sys_common::AsInner; -use ffi::{OsStr, OsString}; -use fs::{self, OpenOptions}; -use libc; -use net; -use sys::os_str::Buf; -use sys_common::{AsInner, FromInner, AsInnerMut}; + #[allow(deprecated)] + use old_io; -#[allow(deprecated)] -use old_io; + /// Raw HANDLEs. + pub type Handle = libc::HANDLE; -/// Raw HANDLEs. -pub type Handle = libc::HANDLE; + /// Raw SOCKETs. + pub type Socket = libc::SOCKET; -/// Raw SOCKETs. -pub type Socket = libc::SOCKET; + /// Extract raw handles. + pub trait AsRawHandle { + /// Extract the raw handle, without taking any ownership. + fn as_raw_handle(&self) -> Handle; + } -/// Extract raw handles. -pub trait AsRawHandle { - /// Extract the raw handle, without taking any ownership. - fn as_raw_handle(&self) -> Handle; -} + #[allow(deprecated)] + impl AsRawHandle for old_io::fs::File { + fn as_raw_handle(&self) -> Handle { + self.as_inner().handle() + } + } -#[allow(deprecated)] -impl AsRawHandle for old_io::fs::File { - fn as_raw_handle(&self) -> Handle { - self.as_inner().handle() + impl AsRawHandle for fs::File { + fn as_raw_handle(&self) -> Handle { + self.as_inner().handle().raw() + } } -} -impl AsRawHandle for fs::File { - fn as_raw_handle(&self) -> Handle { - self.as_inner().handle().raw() + #[allow(deprecated)] + impl AsRawHandle for old_io::pipe::PipeStream { + fn as_raw_handle(&self) -> Handle { + self.as_inner().handle() + } } -} -#[allow(deprecated)] -impl AsRawHandle for old_io::pipe::PipeStream { - fn as_raw_handle(&self) -> Handle { - self.as_inner().handle() + #[allow(deprecated)] + impl AsRawHandle for old_io::net::pipe::UnixStream { + fn as_raw_handle(&self) -> Handle { + self.as_inner().handle() + } } -} -#[allow(deprecated)] -impl AsRawHandle for old_io::net::pipe::UnixStream { - fn as_raw_handle(&self) -> Handle { - self.as_inner().handle() + #[allow(deprecated)] + impl AsRawHandle for old_io::net::pipe::UnixListener { + fn as_raw_handle(&self) -> Handle { + self.as_inner().handle() + } } -} -#[allow(deprecated)] -impl AsRawHandle for old_io::net::pipe::UnixListener { - fn as_raw_handle(&self) -> Handle { - self.as_inner().handle() + #[allow(deprecated)] + impl AsRawHandle for old_io::net::pipe::UnixAcceptor { + fn as_raw_handle(&self) -> Handle { + self.as_inner().handle() + } } -} -#[allow(deprecated)] -impl AsRawHandle for old_io::net::pipe::UnixAcceptor { - fn as_raw_handle(&self) -> Handle { - self.as_inner().handle() + /// Extract raw sockets. + pub trait AsRawSocket { + fn as_raw_socket(&self) -> Socket; } -} -/// Extract raw sockets. -pub trait AsRawSocket { - fn as_raw_socket(&self) -> Socket; -} + #[allow(deprecated)] + impl AsRawSocket for old_io::net::tcp::TcpStream { + fn as_raw_socket(&self) -> Socket { + self.as_inner().fd() + } + } -#[allow(deprecated)] -impl AsRawSocket for old_io::net::tcp::TcpStream { - fn as_raw_socket(&self) -> Socket { - self.as_inner().fd() + #[allow(deprecated)] + impl AsRawSocket for old_io::net::tcp::TcpListener { + fn as_raw_socket(&self) -> Socket { + self.as_inner().socket() + } } -} -#[allow(deprecated)] -impl AsRawSocket for old_io::net::tcp::TcpListener { - fn as_raw_socket(&self) -> Socket { - self.as_inner().socket() + #[allow(deprecated)] + impl AsRawSocket for old_io::net::tcp::TcpAcceptor { + fn as_raw_socket(&self) -> Socket { + self.as_inner().socket() + } } -} -#[allow(deprecated)] -impl AsRawSocket for old_io::net::tcp::TcpAcceptor { - fn as_raw_socket(&self) -> Socket { - self.as_inner().socket() + #[allow(deprecated)] + impl AsRawSocket for old_io::net::udp::UdpSocket { + fn as_raw_socket(&self) -> Socket { + self.as_inner().fd() + } } -} -#[allow(deprecated)] -impl AsRawSocket for old_io::net::udp::UdpSocket { - fn as_raw_socket(&self) -> Socket { - self.as_inner().fd() + impl AsRawSocket for net::TcpStream { + fn as_raw_socket(&self) -> Socket { *self.as_inner().socket().as_inner() } + } + impl AsRawSocket for net::TcpListener { + fn as_raw_socket(&self) -> Socket { *self.as_inner().socket().as_inner() } + } + impl AsRawSocket for net::UdpSocket { + fn as_raw_socket(&self) -> Socket { *self.as_inner().socket().as_inner() } } } -impl AsRawSocket for net::TcpStream { - fn as_raw_socket(&self) -> Socket { *self.as_inner().socket().as_inner() } -} -impl AsRawSocket for net::TcpListener { - fn as_raw_socket(&self) -> Socket { *self.as_inner().socket().as_inner() } -} -impl AsRawSocket for net::UdpSocket { - fn as_raw_socket(&self) -> Socket { *self.as_inner().socket().as_inner() } -} +/// Windows-specific extensions to the primitives in the `std::ffi` module. +#[stable(feature = "rust1", since = "1.0.0")] +pub mod ffi { + use ffi::{OsString, OsStr}; + use sys::os_str::Buf; + use sys_common::wtf8::Wtf8Buf; + use sys_common::{FromInner, AsInner}; -/// Windows-specific extensions to `OsString`. -pub trait OsStringExt { - /// Create an `OsString` from a potentially ill-formed UTF-16 slice of 16-bit code units. - /// - /// This is lossless: calling `.encode_wide()` on the resulting string - /// will always return the original code units. - fn from_wide(wide: &[u16]) -> Self; -} + pub use sys_common::wtf8::EncodeWide; -impl OsStringExt for OsString { - fn from_wide(wide: &[u16]) -> OsString { - FromInner::from_inner(Buf { inner: Wtf8Buf::from_wide(wide) }) + /// Windows-specific extensions to `OsString`. + #[stable(feature = "rust1", since = "1.0.0")] + pub trait OsStringExt { + /// Create an `OsString` from a potentially ill-formed UTF-16 slice of + /// 16-bit code units. + /// + /// This is lossless: calling `.encode_wide()` on the resulting string + /// will always return the original code units. + #[stable(feature = "rust1", since = "1.0.0")] + fn from_wide(wide: &[u16]) -> Self; } -} -/// Windows-specific extensions to `OsStr`. -pub trait OsStrExt { - /// Re-encode an `OsStr` as a wide character sequence, - /// i.e. potentially ill-formed UTF-16. - /// - /// This is lossless. Note that the encoding does not include a final null. - fn encode_wide(&self) -> EncodeWide; -} + #[stable(feature = "rust1", since = "1.0.0")] + impl OsStringExt for OsString { + fn from_wide(wide: &[u16]) -> OsString { + FromInner::from_inner(Buf { inner: Wtf8Buf::from_wide(wide) }) + } + } -impl OsStrExt for OsStr { - fn encode_wide(&self) -> EncodeWide { - self.as_inner().inner.encode_wide() + /// Windows-specific extensions to `OsStr`. + #[stable(feature = "rust1", since = "1.0.0")] + pub trait OsStrExt { + /// Re-encode an `OsStr` as a wide character sequence, + /// i.e. potentially ill-formed UTF-16. + /// + /// This is lossless. Note that the encoding does not include a final + /// null. + #[stable(feature = "rust1", since = "1.0.0")] + fn encode_wide(&self) -> EncodeWide; } -} -// Windows-specific extensions to `OpenOptions` -pub trait OpenOptionsExt { - /// Override the `dwDesiredAccess` argument to the call to `CreateFile` with - /// the specified value. - fn desired_access(&mut self, access: i32) -> &mut Self; - - /// Override the `dwCreationDisposition` argument to the call to - /// `CreateFile` with the specified value. - /// - /// This will override any values of the standard `create` flags, for - /// example. - fn creation_disposition(&mut self, val: i32) -> &mut Self; - - /// Override the `dwFlagsAndAttributes` argument to the call to - /// `CreateFile` with the specified value. - /// - /// This will override any values of the standard flags on the `OpenOptions` - /// structure. - fn flags_and_attributes(&mut self, val: i32) -> &mut Self; - - /// Override the `dwShareMode` argument to the call to `CreateFile` with the - /// specified value. - /// - /// This will override any values of the standard flags on the `OpenOptions` - /// structure. - fn share_mode(&mut self, val: i32) -> &mut Self; + #[stable(feature = "rust1", since = "1.0.0")] + impl OsStrExt for OsStr { + fn encode_wide(&self) -> EncodeWide { + self.as_inner().inner.encode_wide() + } + } } -impl OpenOptionsExt for OpenOptions { - fn desired_access(&mut self, access: i32) -> &mut OpenOptions { - self.as_inner_mut().desired_access(access); self - } - fn creation_disposition(&mut self, access: i32) -> &mut OpenOptions { - self.as_inner_mut().creation_disposition(access); self - } - fn flags_and_attributes(&mut self, access: i32) -> &mut OpenOptions { - self.as_inner_mut().flags_and_attributes(access); self - } - fn share_mode(&mut self, access: i32) -> &mut OpenOptions { - self.as_inner_mut().share_mode(access); self +/// Windows-specific extensions for the primitives in `std::fs` +#[unstable(feature = "fs_ext", reason = "may require more thought/methods")] +pub mod fs { + use fs::OpenOptions; + use sys_common::AsInnerMut; + + /// Windows-specific extensions to `OpenOptions` + pub trait OpenOptionsExt { + /// Override the `dwDesiredAccess` argument to the call to `CreateFile` + /// with the specified value. + fn desired_access(&mut self, access: i32) -> &mut Self; + + /// Override the `dwCreationDisposition` argument to the call to + /// `CreateFile` with the specified value. + /// + /// This will override any values of the standard `create` flags, for + /// example. + fn creation_disposition(&mut self, val: i32) -> &mut Self; + + /// Override the `dwFlagsAndAttributes` argument to the call to + /// `CreateFile` with the specified value. + /// + /// This will override any values of the standard flags on the + /// `OpenOptions` structure. + fn flags_and_attributes(&mut self, val: i32) -> &mut Self; + + /// Override the `dwShareMode` argument to the call to `CreateFile` with + /// the specified value. + /// + /// This will override any values of the standard flags on the + /// `OpenOptions` structure. + fn share_mode(&mut self, val: i32) -> &mut Self; + } + + impl OpenOptionsExt for OpenOptions { + fn desired_access(&mut self, access: i32) -> &mut OpenOptions { + self.as_inner_mut().desired_access(access); self + } + fn creation_disposition(&mut self, access: i32) -> &mut OpenOptions { + self.as_inner_mut().creation_disposition(access); self + } + fn flags_and_attributes(&mut self, access: i32) -> &mut OpenOptions { + self.as_inner_mut().flags_and_attributes(access); self + } + fn share_mode(&mut self, access: i32) -> &mut OpenOptions { + self.as_inner_mut().share_mode(access); self + } } } /// A prelude for conveniently writing platform-specific code. /// /// Includes all extension traits, and some important type definitions. +#[stable(feature = "rust1", since = "1.0.0")] pub mod prelude { #[doc(no_inline)] - pub use super::{Socket, Handle, AsRawSocket, AsRawHandle}; - #[doc(no_inline)] - pub use super::{OsStrExt, OsStringExt}; + pub use super::io::{Socket, Handle, AsRawSocket, AsRawHandle}; + #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")] + pub use super::ffi::{OsStrExt, OsStringExt}; #[doc(no_inline)] - pub use super::OpenOptionsExt; + pub use super::fs::OpenOptionsExt; } diff --git a/src/libstd/sys/windows/mod.rs b/src/libstd/sys/windows/mod.rs index 6b0f6a78c85..d02fe79fcdb 100644 --- a/src/libstd/sys/windows/mod.rs +++ b/src/libstd/sys/windows/mod.rs @@ -20,7 +20,7 @@ use libc; use mem; use num::Int; use old_io::{self, IoResult, IoError}; -use os::windows::{OsStrExt, OsStringExt}; +use os::windows::ffi::{OsStrExt, OsStringExt}; use path::PathBuf; use sync::{Once, ONCE_INIT}; diff --git a/src/libstd/sys/windows/net.rs b/src/libstd/sys/windows/net.rs index 6caa4df5dfe..e092faf4935 100644 --- a/src/libstd/sys/windows/net.rs +++ b/src/libstd/sys/windows/net.rs @@ -14,7 +14,7 @@ use io; use libc::consts::os::extra::INVALID_SOCKET; use libc::{self, c_int, c_void}; use mem; -use net::{SocketAddr, IpAddr}; +use net::SocketAddr; use num::{SignedInt, Int}; use rt; use sync::{Once, ONCE_INIT}; @@ -73,9 +73,9 @@ pub fn cvt_r<T: SignedInt, F>(mut f: F) -> io::Result<T> where F: FnMut() -> T { impl Socket { pub fn new(addr: &SocketAddr, ty: c_int) -> io::Result<Socket> { - let fam = match addr.ip() { - IpAddr::V4(..) => libc::AF_INET, - IpAddr::V6(..) => libc::AF_INET6, + let fam = match *addr { + SocketAddr::V4(..) => libc::AF_INET, + SocketAddr::V6(..) => libc::AF_INET6, }; match unsafe { libc::socket(fam, ty, 0) } { INVALID_SOCKET => Err(last_error()), diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs index ecd538abfb4..4f6c4c9aab3 100644 --- a/src/libstd/sys/windows/os.rs +++ b/src/libstd/sys/windows/os.rs @@ -13,7 +13,7 @@ #![allow(bad_style)] use prelude::v1::*; -use os::windows::*; +use os::windows::prelude::*; use error::Error as StdError; use ffi::{OsString, OsStr, AsOsStr}; @@ -25,6 +25,7 @@ use mem; #[allow(deprecated)] use old_io::{IoError, IoResult}; use ops::Range; +use os::windows::ffi::EncodeWide; use path::{self, PathBuf}; use ptr; use slice; diff --git a/src/libstd/sys/windows/process2.rs b/src/libstd/sys/windows/process2.rs index 8a6a485cbbe..e3cf5da59f0 100644 --- a/src/libstd/sys/windows/process2.rs +++ b/src/libstd/sys/windows/process2.rs @@ -19,7 +19,7 @@ use fmt; use fs; use io::{self, Error}; use libc::{self, c_void}; -use os::windows::OsStrExt; +use os::windows::ffi::OsStrExt; use ptr; use sync::{StaticMutex, MUTEX_INIT}; use sys::handle::Handle; @@ -128,6 +128,7 @@ impl Process { use env::split_paths; use mem; use iter::IteratorExt; + #[cfg(stage0)] use str::StrExt; // To have the spawning semantics of unix/windows stay the same, we need to |