Remove rt::io::support

This removes the PathLike trait associated with this "support module". This is
yet another "container of bytes" trait, so I didn't want to duplicate what
already exists throughout libstd. In actuality, we're going to pass of C strings
to the libuv APIs, so instead the arguments are now bound with the 'ToCStr'
trait instead.

Additionally, a layer of complexity was removed by immediately converting these
type-generic parameters into CStrings to get handed off to libuv apis.

Author: alexcrichton

src/libstd/c_str.rs

@@ -348,13 +348,56 @@ impl<'self> Iterator<libc::c_char> for CStringIterator<'self> {
     }
 }
 
+/// Parses a C "multistring", eg windows env values or
+/// the req->ptr result in a uv_fs_readdir() call.
+///
+/// Optionally, a `count` can be passed in, limiting the
+/// parsing to only being done `count`-times.
+///
+/// The specified closure is invoked with each string that
+/// is found, and the number of strings found is returned.
+pub unsafe fn from_c_multistring(buf: *libc::c_char,
+                                 count: Option<uint>,
+                                 f: &fn(&CString)) -> uint {
+
+    let mut curr_ptr: uint = buf as uint;
+    let mut ctr = 0;
+    let (limited_count, limit) = match count {
+        Some(limit) => (true, limit),
+        None => (false, 0)
+    };
+    while ((limited_count && ctr < limit) || !limited_count)
+          && *(curr_ptr as *libc::c_char) != 0 as libc::c_char {
+        let cstr = CString::new(curr_ptr as *libc::c_char, false);
+        f(&cstr);
+        curr_ptr += cstr.len() + 1;
+        ctr += 1;
+    }
+    return ctr;
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use libc;
     use ptr;
     use option::{Some, None};
 
+    #[test]
+    fn test_str_multistring_parsing() {
+        unsafe {
+            let input = bytes!("zero", "\x00", "one", "\x00", "\x00");
+            let ptr = vec::raw::to_ptr(input);
+            let expected = ["zero", "one"];
+            let mut it = expected.iter();
+            let result = do from_c_multistring(ptr as *libc::c_char, None) |c| {
+                assert_eq!(c.as_str(), expected.next().unwrap());
+            };
+            assert_eq!(result, 2);
+            assert!(it.next().is_none());
+        }
+    }
+
     #[test]
     fn test_str_to_c_str() {
         do "".to_c_str().with_ref |buf| {

src/libstd/os.rs

@@ -62,7 +62,7 @@ pub fn close(fd: c_int) -> c_int {
 // which are for Windows and for non-Windows, if necessary.
 // See https://github.com/mozilla/rust/issues/9822 for more information.
 
-pub mod rustrt {
+mod rustrt {
     use libc::{c_char, c_int};
     use libc;
 
@@ -200,7 +200,10 @@ pub fn env() -> ~[(~str,~str)] {
                 fail!("os::env() failure getting env string from OS: {}",
                        os::last_os_error());
             }
-            let result = str::raw::from_c_multistring(ch as *libc::c_char, None);
+            let mut result = ~[];
+            do c_str::from_c_multistring(ch as *libc::c_char, None) |cstr| {
+                result.push(cstr.as_str().to_owned());
+            };
             FreeEnvironmentStringsA(ch);
             result
         }

src/libstd/rt/io/file.rs

@@ -15,7 +15,8 @@ with regular files & directories on a filesystem.
 
 At the top-level of the module are a set of freestanding functions,
 associated with various filesystem operations. They all operate
-on a `PathLike` object.
+on a `ToCStr` object. This trait is already defined for common
+objects such as strings and `Path` instances.
 
 All operations in this module, including those as part of `FileStream` et al
 block the task during execution. Most will raise `std::rt::io::{io_error,read_error}`
@@ -30,7 +31,7 @@ free function counterparts.
 */
 
 use prelude::*;
-use super::support::PathLike;
+use c_str::ToCStr;
 use super::{Reader, Writer, Seek};
 use super::{SeekStyle, Read, Write};
 use rt::rtio::{RtioFileStream, IoFactory, IoFactoryObject};
@@ -48,7 +49,6 @@ use path::Path;
 ///
 ///     use std;
 ///     use std::path::Path;
-///     use std::rt::io::support::PathLike;
 ///     use std::rt::io::file::open;
 ///     use std::rt::io::{FileMode, FileAccess};
 ///
@@ -87,13 +87,13 @@ use path::Path;
 /// * Attempting to open a file with a `FileAccess` that the user lacks permissions
 ///   for
 /// * Filesystem-level errors (full disk, etc)
-pub fn open<P: PathLike>(path: &P,
-                         mode: FileMode,
-                         access: FileAccess
-                        ) -> Option<FileStream> {
+pub fn open<P: ToCStr>(path: &P,
+                       mode: FileMode,
+                       access: FileAccess
+                       ) -> Option<FileStream> {
     let open_result = unsafe {
         let io: *mut IoFactoryObject = Local::unsafe_borrow();
-        (*io).fs_open(path, mode, access)
+        (*io).fs_open(&path.to_c_str(), mode, access)
     };
     match open_result {
         Ok(fd) => Some(FileStream {
@@ -113,7 +113,6 @@ pub fn open<P: PathLike>(path: &P,
 ///
 ///     use std;
 ///     use std::path::Path;
-///     use std::rt::io::support::PathLike;
 ///     use std::rt::io::file::unlink;
 ///
 ///     let p = &Path("/some/file/path.txt");
@@ -129,10 +128,10 @@ pub fn open<P: PathLike>(path: &P,
 ///
 /// This function will raise an `io_error` condition if the user lacks permissions to
 /// remove the file or if some other filesystem-level error occurs
-pub fn unlink<P: PathLike>(path: &P) {
+pub fn unlink<P: ToCStr>(path: &P) {
     let unlink_result = unsafe {
         let io: *mut IoFactoryObject = Local::unsafe_borrow();
-        (*io).fs_unlink(path)
+        (*io).fs_unlink(&path.to_c_str())
     };
     match unlink_result {
         Ok(_) => (),
@@ -148,7 +147,6 @@ pub fn unlink<P: PathLike>(path: &P) {
 ///
 ///     use std;
 ///     use std::path::Path;
-///     use std::rt::io::support::PathLike;
 ///     use std::rt::io::file::mkdir;
 ///
 ///     let p = &Path("/some/dir");
@@ -159,10 +157,10 @@ pub fn unlink<P: PathLike>(path: &P) {
 ///
 /// This call will raise an `io_error` condition if the user lacks permissions to make a
 /// new directory at the provided path, or if the directory already exists
-pub fn mkdir<P: PathLike>(path: &P) {
+pub fn mkdir<P: ToCStr>(path: &P) {
     let mkdir_result = unsafe {
         let io: *mut IoFactoryObject = Local::unsafe_borrow();
-        (*io).fs_mkdir(path)
+        (*io).fs_mkdir(&path.to_c_str())
     };
     match mkdir_result {
         Ok(_) => (),
@@ -178,7 +176,6 @@ pub fn mkdir<P: PathLike>(path: &P) {
 ///
 ///     use std;
 ///     use std::path::Path;
-///     use std::rt::io::support::PathLike;
 ///     use std::rt::io::file::rmdir;
 ///
 ///     let p = &Path("/some/dir");
@@ -189,10 +186,10 @@ pub fn mkdir<P: PathLike>(path: &P) {
 ///
 /// This call will raise an `io_error` condition if the user lacks permissions to remove the
 /// directory at the provided path, or if the directory isn't empty
-pub fn rmdir<P: PathLike>(path: &P) {
+pub fn rmdir<P: ToCStr>(path: &P) {
     let rmdir_result = unsafe {
         let io: *mut IoFactoryObject = Local::unsafe_borrow();
-        (*io).fs_rmdir(path)
+        (*io).fs_rmdir(&path.to_c_str())
     };
     match rmdir_result {
         Ok(_) => (),
@@ -204,16 +201,15 @@ pub fn rmdir<P: PathLike>(path: &P) {
 
 /// Get information on the file, directory, etc at the provided path
 ///
-/// Given a `rt::io::support::PathLike`, query the file system to get
-/// information about a file, directory, etc.
+/// Given a path, query the file system to get information about a file,
+/// directory, etc.
 ///
 /// Returns a `Some(std::rt::io::PathInfo)` on success
 ///
 /// # Example
 ///
 ///     use std;
 ///     use std::path::Path;
-///     use std::rt::io::support::PathLike;
 ///     use std::rt::io::file::stat;
 ///
 ///     let p = &Path("/some/file/path.txt");
@@ -238,10 +234,10 @@ pub fn rmdir<P: PathLike>(path: &P) {
 /// This call will raise an `io_error` condition if the user lacks the requisite
 /// permissions to perform a `stat` call on the given path or if there is no
 /// entry in the filesystem at the provided path.
-pub fn stat<P: PathLike>(path: &P) -> Option<FileStat> {
+pub fn stat<P: ToCStr>(path: &P) -> Option<FileStat> {
     let open_result = unsafe {
         let io: *mut IoFactoryObject = Local::unsafe_borrow();
-        (*io).fs_stat(path)
+        (*io).fs_stat(&path.to_c_str())
     };
     match open_result {
         Ok(p) => {
@@ -260,7 +256,6 @@ pub fn stat<P: PathLike>(path: &P) -> Option<FileStat> {
 ///
 ///     use std;
 ///     use std::path::Path;
-///     use std::rt::io::support::PathLike;
 ///     use std::rt::io::file::readdir;
 ///
 ///     fn visit_dirs(dir: &Path, cb: &fn(&Path)) {
@@ -279,10 +274,10 @@ pub fn stat<P: PathLike>(path: &P) -> Option<FileStat> {
 /// Will raise an `io_error` condition if the provided `path` doesn't exist,
 /// the process lacks permissions to view the contents or if the `path` points
 /// at a non-directory file
-pub fn readdir<P: PathLike>(path: &P) -> Option<~[Path]> {
+pub fn readdir<P: ToCStr>(path: &P) -> Option<~[Path]> {
     let readdir_result = unsafe {
         let io: *mut IoFactoryObject = Local::unsafe_borrow();
-        (*io).fs_readdir(path, 0)
+        (*io).fs_readdir(&path.to_c_str(), 0)
     };
     match readdir_result {
         Ok(p) => {

src/libstd/rt/io/mod.rs

@@ -298,10 +298,6 @@ pub mod comm_adapters;
 /// Extension traits
 pub mod extensions;
 
-/// Non-I/O things needed by the I/O module
-// XXX: shouldn this really be pub?
-pub mod support;
-
 /// Basic Timer
 pub mod timer;
 

src/libstd/rt/io/net/unix.rs

@@ -24,7 +24,7 @@ instances as clients.
 
 use prelude::*;
 
-use super::super::support::PathLike;
+use c_str::ToCStr;
 use rt::rtio::{IoFactory, IoFactoryObject, RtioUnixListener};
 use rt::rtio::{RtioUnixAcceptor, RtioPipe, RtioUnixListenerObject};
 use rt::io::pipe::PipeStream;
@@ -59,7 +59,7 @@ impl UnixStream {
     ///     let mut stream = UnixStream::connect(&server);
     ///     stream.write([1, 2, 3]);
     ///
-    pub fn connect<P: PathLike>(path: &P) -> Option<UnixStream> {
+    pub fn connect<P: ToCStr>(path: &P) -> Option<UnixStream> {
         let pipe = unsafe {
             let io: *mut IoFactoryObject = Local::unsafe_borrow();
             (*io).unix_connect(path)
@@ -112,7 +112,7 @@ impl UnixListener {
     ///         client.write([1, 2, 3, 4]);
     ///     }
     ///
-    pub fn bind<P: PathLike>(path: &P) -> Option<UnixListener> {
+    pub fn bind<P: ToCStr>(path: &P) -> Option<UnixListener> {
         let listener = unsafe {
             let io: *mut IoFactoryObject = Local::unsafe_borrow();
             (*io).unix_bind(path)

src/libstd/rt/io/support.rs

@@ -12,14 +12,14 @@ use libc;
 use option::*;
 use result::*;
 use libc::c_int;
+use c_str::CString;
 
 use ai = rt::io::net::addrinfo;
 use rt::io::IoError;
 use super::io::process::ProcessConfig;
 use super::io::net::ip::{IpAddr, SocketAddr};
 use rt::uv::uvio;
 use path::Path;
-use super::io::support::PathLike;
 use super::io::{SeekStyle};
 use super::io::{FileMode, FileAccess, FileStat};
 
@@ -65,15 +65,14 @@ pub trait IoFactory {
     fn udp_bind(&mut self, addr: SocketAddr) -> Result<~RtioUdpSocket, IoError>;
     fn timer_init(&mut self) -> Result<~RtioTimer, IoError>;
     fn fs_from_raw_fd(&mut self, fd: c_int, close_on_drop: bool) -> ~RtioFileStream;
-    fn fs_open<P: PathLike>(&mut self, path: &P, fm: FileMode, fa: FileAccess)
+    fn fs_open(&mut self, path: &CString, fm: FileMode, fa: FileAccess)
         -> Result<~RtioFileStream, IoError>;
-    fn fs_unlink<P: PathLike>(&mut self, path: &P) -> Result<(), IoError>;
     fn get_host_addresses(&mut self, host: Option<&str>, servname: Option<&str>,
                           hint: Option<ai::Hint>) -> Result<~[ai::Info], IoError>;
-    fn fs_stat<P: PathLike>(&mut self, path: &P) -> Result<FileStat, IoError>;
-    fn fs_mkdir<P: PathLike>(&mut self, path: &P) -> Result<(), IoError>;
-    fn fs_rmdir<P: PathLike>(&mut self, path: &P) -> Result<(), IoError>;
-    fn fs_readdir<P: PathLike>(&mut self, path: &P, flags: c_int) ->
+    fn fs_stat(&mut self, path: &CString) -> Result<FileStat, IoError>;
+    fn fs_mkdir(&mut self, path: &CString) -> Result<(), IoError>;
+    fn fs_rmdir(&mut self, path: &CString) -> Result<(), IoError>;
+    fn fs_readdir(&mut self, path: &CString, flags: c_int) ->
         Result<~[Path], IoError>;
     fn spawn(&mut self, config: ProcessConfig)
             -> Result<(~RtioProcess, ~[Option<~RtioPipe>]), IoError>;