Split out libstd crate

28 files changed, 21 insertions, 11864 deletions

diff --git a/src/console.rs b/src/console.rs
index 6e05ec2..78a88a2 100644
--- a/src/console.rs
+++ b/src/console.rs
@@ -3,9 +3,9 @@ use libctru::libc;
 
 use gfx::Screen;
 
-use core::fmt::{self, Write};
-use core::default::Default;
-use core::ptr;
+use std::fmt::{self, Write};
+use std::default::Default;
+use std::ptr;
 
 pub struct Console {
     context: PrintConsole,
diff --git a/src/gfx.rs b/src/gfx.rs
index 7504632..7f819ea 100644
--- a/src/gfx.rs
+++ b/src/gfx.rs
@@ -1,8 +1,8 @@
 use libctru::gfx;
 
-use core::default::Default;
-use core::marker::PhantomData;
-use core::ops::Drop;
+use std::default::Default;
+use std::marker::PhantomData;
+use std::ops::Drop;
 
 use services::gspgpu::FramebufferFormat;
 
@@ -82,9 +82,9 @@ impl Gfx {
     }
 
     pub fn get_framebuffer(&mut self, screen: Screen, side: Side) -> (&'static mut [u8], u16, u16) {
-        use core::convert::Into;
+        use std::convert::Into;
         unsafe {
-            use core::slice::from_raw_parts_mut;
+            use std::slice::from_raw_parts_mut;
 
             let mut w: u16 = 0;
             let mut h: u16 = 0;
@@ -112,12 +112,12 @@ impl Gfx {
     }
 
     pub fn get_framebuffer_format(&self, screen: Screen) -> FramebufferFormat {
-        use core::convert::Into;
+        use std::convert::Into;
         unsafe { gfx::gfxGetScreenFormat(screen.into()).into() }
     }
 
     pub fn set_framebuffer_format(&mut self, screen: Screen, fmt: FramebufferFormat) {
-        use core::convert::Into;
+        use std::convert::Into;
         unsafe { gfx::gfxSetScreenFormat(screen.into(), fmt.into()) }
     }
 
diff --git a/src/lib.rs b/src/lib.rs
index 1f13b99..56ab565 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,79 +1,13 @@
-#![feature(alloc)]
-#![feature(allow_internal_unstable)]
-#![feature(collections)]
-#![feature(core_intrinsics)]
-#![feature(char_escape_debug)]
-#![feature(int_error_internals)]
-#![feature(lang_items)]
-#![feature(macro_reexport)]
-#![feature(prelude_import)]
-#![feature(slice_concat_ext)]
-#![feature(slice_patterns)]
-#![feature(str_internals)]
-#![feature(try_from)]
-#![feature(unicode)]
-
-#![no_std]
-
 #![crate_type = "rlib"]
 #![crate_name = "ctru"]
 
-extern crate alloc;
-extern crate alloc_system;
-#[macro_reexport(format, vec)]
-#[macro_use]
-extern crate collections;
-extern crate rustc_unicode;
-
 extern crate ctru_sys as libctru;
 
-#[prelude_import]
-#[allow(unused)]
-use prelude::*;
-
-pub mod std {
-    pub use core::{any, cell, clone, cmp, convert, default, hash, i16, i32, i64, i8, isize, iter,
-                   marker, mem, ops, option, ptr, result, u16, u32, u64, u8, usize, intrinsics};
-    pub use rustc_unicode::char;
-    pub use alloc::{arc, rc};
-    pub use collections::{borrow, boxed, fmt, slice, str, string, vec};
-    pub use system::{error, io, memchr, ascii, ffi, path};
-
-    pub mod collections {
-        pub use collections::{binary_heap, btree_map, btree_set, linked_list, vec_deque,
-                              BinaryHeap, LinkedList, VecDeque, String, Vec, BTreeMap, BTreeSet};
-    }
-}
-
-pub mod prelude {
-    pub use std;
-    pub use std::marker::{Copy, Send, Sized, Sync};
-    pub use std::ops::{Drop, Fn, FnMut, FnOnce};
-    pub use std::mem::drop;
-    pub use std::boxed::Box;
-    pub use std::borrow::ToOwned;
-    pub use std::clone::Clone;
-    pub use std::cmp::{PartialEq, PartialOrd, Eq, Ord};
-    pub use std::convert::{AsRef, AsMut, Into, From};
-    pub use std::default::Default;
-    pub use std::iter::{Iterator, Extend, IntoIterator};
-    pub use std::iter::{DoubleEndedIterator, ExactSizeIterator};
-    pub use std::option::Option::{self, Some, None};
-    pub use std::result::Result::{self, Ok, Err};
-    pub use std::slice::SliceConcatExt;
-    pub use std::string::{String, ToString};
-    pub use std::vec::Vec;
-    pub use std::fmt::Write;
-}
-
-pub use std::{fmt, boxed, vec};
-
 pub mod console;
 pub mod srv;
 pub mod gfx;
 pub mod services;
 pub mod sdmc;
-pub mod system;
 
 pub use srv::Srv;
 pub use gfx::Gfx;
diff --git a/src/sdmc.rs b/src/sdmc.rs
index 75a58a9..8698f80 100644
--- a/src/sdmc.rs
+++ b/src/sdmc.rs
@@ -1,4 +1,4 @@
-use core::marker::PhantomData;
+use std::marker::PhantomData;
 
 use libctru::sdmc::*;
 
diff --git a/src/services/apt.rs b/src/services/apt.rs
index 69094b2..536f463 100644
--- a/src/services/apt.rs
+++ b/src/services/apt.rs
@@ -1,4 +1,4 @@
-use core::marker::PhantomData;
+use std::marker::PhantomData;
 
 use libctru::services::apt;
 
diff --git a/src/services/fs.rs b/src/services/fs.rs
index 0307dc8..33eef9f 100644
--- a/src/services/fs.rs
+++ b/src/services/fs.rs
@@ -4,12 +4,11 @@
 //! Only the SD card is currently supported.
 
 
-use core::marker::PhantomData;
-use core::ptr;
-use core::slice;
-use core::mem;
-use alloc::arc::Arc;
-use collections::Vec;
+use std::marker::PhantomData;
+use std::ptr;
+use std::slice;
+use std::mem;
+use std::arc::Arc;
 
 use std::path::{Path, PathBuf};
 use std::ffi::OsString;
diff --git a/src/services/gspgpu.rs b/src/services/gspgpu.rs
index efa153d..6bd972c 100644
--- a/src/services/gspgpu.rs
+++ b/src/services/gspgpu.rs
@@ -1,6 +1,6 @@
 use libctru::services::gspgpu;
 
-use core::convert::From;
+use std::convert::From;
 
 pub enum Event {
     Psc0,
diff --git a/src/services/hid.rs b/src/services/hid.rs
index 1b90194..c2a8b3d 100644
--- a/src/services/hid.rs
+++ b/src/services/hid.rs
@@ -1,5 +1,5 @@
-use core::convert::Into;
-use core::marker::PhantomData;
+use std::convert::Into;
+use std::marker::PhantomData;
 
 use libctru::services::hid;
 
diff --git a/src/srv.rs b/src/srv.rs
index 9c4388c..a7376a5 100644
--- a/src/srv.rs
+++ b/src/srv.rs
@@ -1,6 +1,6 @@
 use libctru::srv::*;
 
-use core::marker::PhantomData;
+use std::marker::PhantomData;
 
 pub struct Srv {
     pd: PhantomData<i32>,
diff --git a/src/system/ascii.rs b/src/system/ascii.rs
deleted file mode 100644
index 93f447b..0000000
--- a/src/system/ascii.rs
+++ /dev/null
@@ -1,554 +0,0 @@
-// Copyright 2013-2014 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Operations on ASCII strings and characters.
-
-use core::mem;
-use core::ops::Range;
-use collections::{String, Vec};
-
-/// Extension methods for ASCII-subset only operations on string slices.
-///
-/// Be aware that operations on seemingly non-ASCII characters can sometimes
-/// have unexpected results. Consider this example:
-///
-/// ```
-/// use std::ascii::AsciiExt;
-///
-/// assert_eq!("café".to_ascii_uppercase(), "CAFÉ");
-/// assert_eq!("café".to_ascii_uppercase(), "CAFé");
-/// ```
-///
-/// In the first example, the lowercased string is represented `"cafe\u{301}"`
-/// (the last character is an acute accent [combining character]). Unlike the
-/// other characters in the string, the combining character will not get mapped
-/// to an uppercase variant, resulting in `"CAFE\u{301}"`. In the second
-/// example, the lowercased string is represented `"caf\u{e9}"` (the last
-/// character is a single Unicode character representing an 'e' with an acute
-/// accent). Since the last character is defined outside the scope of ASCII,
-/// it will not get mapped to an uppercase variant, resulting in `"CAF\u{e9}"`.
-///
-/// [combining character]: https://en.wikipedia.org/wiki/Combining_character
-pub trait AsciiExt {
-    /// Container type for copied ASCII characters.
-    type Owned;
-
-    /// Checks if the value is within the ASCII range.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ascii::AsciiExt;
-    ///
-    /// let ascii = 'a';
-    /// let utf8 = '❤';
-    ///
-    /// assert!(ascii.is_ascii());
-    /// assert!(!utf8.is_ascii());
-    /// ```
-    fn is_ascii(&self) -> bool;
-
-    /// Makes a copy of the string in ASCII upper case.
-    ///
-    /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',
-    /// but non-ASCII letters are unchanged.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ascii::AsciiExt;
-    ///
-    /// let ascii = 'a';
-    /// let utf8 = '❤';
-    ///
-    /// assert_eq!('A', ascii.to_ascii_uppercase());
-    /// assert_eq!('❤', utf8.to_ascii_uppercase());
-    /// ```
-    fn to_ascii_uppercase(&self) -> Self::Owned;
-
-    /// Makes a copy of the string in ASCII lower case.
-    ///
-    /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',
-    /// but non-ASCII letters are unchanged.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ascii::AsciiExt;
-    ///
-    /// let ascii = 'A';
-    /// let utf8 = '❤';
-    ///
-    /// assert_eq!('a', ascii.to_ascii_lowercase());
-    /// assert_eq!('❤', utf8.to_ascii_lowercase());
-    /// ```
-    fn to_ascii_lowercase(&self) -> Self::Owned;
-
-    /// Checks that two strings are an ASCII case-insensitive match.
-    ///
-    /// Same as `to_ascii_lowercase(a) == to_ascii_lowercase(b)`,
-    /// but without allocating and copying temporary strings.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ascii::AsciiExt;
-    ///
-    /// let ascii1 = 'A';
-    /// let ascii2 = 'a';
-    /// let ascii3 = 'A';
-    /// let ascii4 = 'z';
-    ///
-    /// assert!(ascii1.eq_ignore_ascii_case(&ascii2));
-    /// assert!(ascii1.eq_ignore_ascii_case(&ascii3));
-    /// assert!(!ascii1.eq_ignore_ascii_case(&ascii4));
-    /// ```
-    fn eq_ignore_ascii_case(&self, other: &Self) -> bool;
-
-    /// Converts this type to its ASCII upper case equivalent in-place.
-    ///
-    /// See `to_ascii_uppercase` for more information.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ascii::AsciiExt;
-    ///
-    /// let mut ascii = 'a';
-    ///
-    /// ascii.make_ascii_uppercase();
-    ///
-    /// assert_eq!('A', ascii);
-    /// ```
-    fn make_ascii_uppercase(&mut self);
-
-    /// Converts this type to its ASCII lower case equivalent in-place.
-    ///
-    /// See `to_ascii_lowercase` for more information.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ascii::AsciiExt;
-    ///
-    /// let mut ascii = 'A';
-    ///
-    /// ascii.make_ascii_lowercase();
-    ///
-    /// assert_eq!('a', ascii);
-    /// ```
-    fn make_ascii_lowercase(&mut self);
-}
-
-impl AsciiExt for str {
-    type Owned = String;
-
-    #[inline]
-    fn is_ascii(&self) -> bool {
-        self.bytes().all(|b| b.is_ascii())
-    }
-
-    #[inline]
-    fn to_ascii_uppercase(&self) -> String {
-        let mut bytes = self.as_bytes().to_vec();
-        bytes.make_ascii_uppercase();
-        // make_ascii_uppercase() preserves the UTF-8 invariant.
-        unsafe { String::from_utf8_unchecked(bytes) }
-    }
-
-    #[inline]
-    fn to_ascii_lowercase(&self) -> String {
-        let mut bytes = self.as_bytes().to_vec();
-        bytes.make_ascii_lowercase();
-        // make_ascii_uppercase() preserves the UTF-8 invariant.
-        unsafe { String::from_utf8_unchecked(bytes) }
-    }
-
-    #[inline]
-    fn eq_ignore_ascii_case(&self, other: &str) -> bool {
-        self.as_bytes().eq_ignore_ascii_case(other.as_bytes())
-    }
-
-    fn make_ascii_uppercase(&mut self) {
-        let me: &mut [u8] = unsafe { mem::transmute(self) };
-        me.make_ascii_uppercase()
-    }
-
-    fn make_ascii_lowercase(&mut self) {
-        let me: &mut [u8] = unsafe { mem::transmute(self) };
-        me.make_ascii_lowercase()
-    }
-}
-
-impl AsciiExt for [u8] {
-    type Owned = Vec<u8>;
-    #[inline]
-    fn is_ascii(&self) -> bool {
-        self.iter().all(|b| b.is_ascii())
-    }
-
-    #[inline]
-    fn to_ascii_uppercase(&self) -> Vec<u8> {
-        let mut me = self.to_vec();
-        me.make_ascii_uppercase();
-        return me
-    }
-
-    #[inline]
-    fn to_ascii_lowercase(&self) -> Vec<u8> {
-        let mut me = self.to_vec();
-        me.make_ascii_lowercase();
-        return me
-    }
-
-    #[inline]
-    fn eq_ignore_ascii_case(&self, other: &[u8]) -> bool {
-        self.len() == other.len() &&
-        self.iter().zip(other).all(|(a, b)| {
-            a.eq_ignore_ascii_case(b)
-        })
-    }
-
-    fn make_ascii_uppercase(&mut self) {
-        for byte in self {
-            byte.make_ascii_uppercase();
-        }
-    }
-
-    fn make_ascii_lowercase(&mut self) {
-        for byte in self {
-            byte.make_ascii_lowercase();
-        }
-    }
-}
-
-impl AsciiExt for u8 {
-    type Owned = u8;
-    #[inline]
-    fn is_ascii(&self) -> bool { *self & 128 == 0 }
-    #[inline]
-    fn to_ascii_uppercase(&self) -> u8 { ASCII_UPPERCASE_MAP[*self as usize] }
-    #[inline]
-    fn to_ascii_lowercase(&self) -> u8 { ASCII_LOWERCASE_MAP[*self as usize] }
-    #[inline]
-    fn eq_ignore_ascii_case(&self, other: &u8) -> bool {
-        self.to_ascii_lowercase() == other.to_ascii_lowercase()
-    }
-    #[inline]
-    fn make_ascii_uppercase(&mut self) { *self = self.to_ascii_uppercase(); }
-    #[inline]
-    fn make_ascii_lowercase(&mut self) { *self = self.to_ascii_lowercase(); }
-}
-
-impl AsciiExt for char {
-    type Owned = char;
-    #[inline]
-    fn is_ascii(&self) -> bool {
-        *self as u32 <= 0x7F
-    }
-
-    #[inline]
-    fn to_ascii_uppercase(&self) -> char {
-        if self.is_ascii() {
-            (*self as u8).to_ascii_uppercase() as char
-        } else {
-            *self
-        }
-    }
-
-    #[inline]
-    fn to_ascii_lowercase(&self) -> char {
-        if self.is_ascii() {
-            (*self as u8).to_ascii_lowercase() as char
-        } else {
-            *self
-        }
-    }
-
-    #[inline]
-    fn eq_ignore_ascii_case(&self, other: &char) -> bool {
-        self.to_ascii_lowercase() == other.to_ascii_lowercase()
-    }
-
-    #[inline]
-    fn make_ascii_uppercase(&mut self) { *self = self.to_ascii_uppercase(); }
-    #[inline]
-    fn make_ascii_lowercase(&mut self) { *self = self.to_ascii_lowercase(); }
-}
-
-/// An iterator over the escaped version of a byte, constructed via
-/// `std::ascii::escape_default`.
-pub struct EscapeDefault {
-    range: Range<usize>,
-    data: [u8; 4],
-}
-
-/// Returns an iterator that produces an escaped version of a `u8`.
-///
-/// The default is chosen with a bias toward producing literals that are
-/// legal in a variety of languages, including C++11 and similar C-family
-/// languages. The exact rules are:
-///
-/// - Tab, CR and LF are escaped as '\t', '\r' and '\n' respectively.
-/// - Single-quote, double-quote and backslash chars are backslash-escaped.
-/// - Any other chars in the range [0x20,0x7e] are not escaped.
-/// - Any other chars are given hex escapes of the form '\xNN'.
-/// - Unicode escapes are never generated by this function.
-///
-/// # Examples
-///
-/// ```
-/// use std::ascii;
-///
-/// let escaped = ascii::escape_default(b'0').next().unwrap();
-/// assert_eq!(b'0', escaped);
-///
-/// let mut escaped = ascii::escape_default(b'\t');
-///
-/// assert_eq!(b'\\', escaped.next().unwrap());
-/// assert_eq!(b't', escaped.next().unwrap());
-/// ```
-pub fn escape_default(c: u8) -> EscapeDefault {
-    let (data, len) = match c {
-        b'\t' => ([b'\\', b't', 0, 0], 2),
-        b'\r' => ([b'\\', b'r', 0, 0], 2),
-        b'\n' => ([b'\\', b'n', 0, 0], 2),
-        b'\\' => ([b'\\', b'\\', 0, 0], 2),
-        b'\'' => ([b'\\', b'\'', 0, 0], 2),
-        b'"' => ([b'\\', b'"', 0, 0], 2),
-        b'\x20' ... b'\x7e' => ([c, 0, 0, 0], 1),
-        _ => ([b'\\', b'x', hexify(c >> 4), hexify(c & 0xf)], 4),
-    };
-
-    return EscapeDefault { range: (0.. len), data: data };
-
-    fn hexify(b: u8) -> u8 {
-        match b {
-            0 ... 9 => b'0' + b,
-            _ => b'a' + b - 10,
-        }
-    }
-}
-
-impl Iterator for EscapeDefault {
-    type Item = u8;
-    fn next(&mut self) -> Option<u8> { self.range.next().map(|i| self.data[i]) }
-    fn size_hint(&self) -> (usize, Option<usize>) { self.range.size_hint() }
-}
-impl DoubleEndedIterator for EscapeDefault {
-    fn next_back(&mut self) -> Option<u8> {
-        self.range.next_back().map(|i| self.data[i])
-    }
-}
-impl ExactSizeIterator for EscapeDefault {}
-
-static ASCII_LOWERCASE_MAP: [u8; 256] = [
-    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-    0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-    0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
-    b' ', b'!', b'"', b'#', b'$', b'%', b'&', b'\'',
-    b'(', b')', b'*', b'+', b',', b'-', b'.', b'/',
-    b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7',
-    b'8', b'9', b':', b';', b'<', b'=', b'>', b'?',
-    b'@',
-
-          b'a', b'b', b'c', b'd', b'e', b'f', b'g',
-    b'h', b'i', b'j', b'k', b'l', b'm', b'n', b'o',
-    b'p', b'q', b'r', b's', b't', b'u', b'v', b'w',
-    b'x', b'y', b'z',
-
-                      b'[', b'\\', b']', b'^', b'_',
-    b'`', b'a', b'b', b'c', b'd', b'e', b'f', b'g',
-    b'h', b'i', b'j', b'k', b'l', b'm', b'n', b'o',
-    b'p', b'q', b'r', b's', b't', b'u', b'v', b'w',
-    b'x', b'y', b'z', b'{', b'|', b'}', b'~', 0x7f,
-    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
-    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
-    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
-    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
-    0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
-    0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
-    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
-    0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
-    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
-    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
-    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
-    0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
-    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
-    0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
-    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
-    0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
-];
-
-static ASCII_UPPERCASE_MAP: [u8; 256] = [
-    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-    0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-    0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
-    b' ', b'!', b'"', b'#', b'$', b'%', b'&', b'\'',
-    b'(', b')', b'*', b'+', b',', b'-', b'.', b'/',
-    b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7',
-    b'8', b'9', b':', b';', b'<', b'=', b'>', b'?',
-    b'@', b'A', b'B', b'C', b'D', b'E', b'F', b'G',
-    b'H', b'I', b'J', b'K', b'L', b'M', b'N', b'O',
-    b'P', b'Q', b'R', b'S', b'T', b'U', b'V', b'W',
-    b'X', b'Y', b'Z', b'[', b'\\', b']', b'^', b'_',
-    b'`',
-
-          b'A', b'B', b'C', b'D', b'E', b'F', b'G',
-    b'H', b'I', b'J', b'K', b'L', b'M', b'N', b'O',
-    b'P', b'Q', b'R', b'S', b'T', b'U', b'V', b'W',
-    b'X', b'Y', b'Z',
-
-                      b'{', b'|', b'}', b'~', 0x7f,
-    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
-    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
-    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
-    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
-    0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
-    0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
-    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
-    0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
-    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
-    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
-    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
-    0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
-    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
-    0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
-    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
-    0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
-];
-
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use rustc_unicode::char::from_u32;
-    use collections::string::ToString;
-
-    #[test]
-    fn test_is_ascii() {
-        assert!(b"".is_ascii());
-        assert!(b"banana\0\x7F".is_ascii());
-        assert!(b"banana\0\x7F".iter().all(|b| b.is_ascii()));
-        assert!(!b"Vi\xe1\xbb\x87t Nam".is_ascii());
-        assert!(!b"Vi\xe1\xbb\x87t Nam".iter().all(|b| b.is_ascii()));
-        assert!(!b"\xe1\xbb\x87".iter().any(|b| b.is_ascii()));
-
-        assert!("".is_ascii());
-        assert!("banana\0\u{7F}".is_ascii());
-        assert!("banana\0\u{7F}".chars().all(|c| c.is_ascii()));
-        assert!(!"ประเทศไทย中华Việt Nam".chars().all(|c| c.is_ascii()));
-
-        // NOTE: This test fails for some reason.
-        assert!(!"ประเทศไทย中华ệ ".chars().any(|c| c.is_ascii()));
-    }
-
-    #[test]
-    fn test_to_ascii_uppercase() {
-        assert_eq!("url()URL()uRl()ürl".to_ascii_uppercase(), "URL()URL()URL()üRL");
-        assert_eq!("hıKß".to_ascii_uppercase(), "HıKß");
-
-        for i in 0..501 {
-            let upper = if 'a' as u32 <= i && i <= 'z' as u32 { i + 'A' as u32 - 'a' as u32 }
-                        else { i };
-            assert_eq!((from_u32(i).unwrap()).to_string().to_ascii_uppercase(),
-                       (from_u32(upper).unwrap()).to_string());
-        }
-    }
-
-    #[test]
-    fn test_to_ascii_lowercase() {
-        assert_eq!("url()URL()uRl()Ürl".to_ascii_lowercase(), "url()url()url()Ürl");
-        // Dotted capital I, Kelvin sign, Sharp S.
-        assert_eq!("HİKß".to_ascii_lowercase(), "hİKß");
-
-        for i in 0..501 {
-            let lower = if 'A' as u32 <= i && i <= 'Z' as u32 { i + 'a' as u32 - 'A' as u32 }
-                        else { i };
-            assert_eq!((from_u32(i).unwrap()).to_string().to_ascii_lowercase(),
-                       (from_u32(lower).unwrap()).to_string());
-        }
-    }
-
-    #[test]
-    fn test_make_ascii_lower_case() {
-        macro_rules! test {
-            ($from: expr, $to: expr) => {
-                {
-                    let mut x = $from;
-                    x.make_ascii_lowercase();
-                    assert_eq!(x, $to);
-                }
-            }
-        }
-        test!(b'A', b'a');
-        test!(b'a', b'a');
-        test!(b'!', b'!');
-        test!('A', 'a');
-        test!('À', 'À');
-        test!('a', 'a');
-        test!('!', '!');
-        test!(b"H\xc3\x89".to_vec(), b"h\xc3\x89");
-        test!("HİKß".to_string(), "hİKß");
-    }
-
-
-    #[test]
-    fn test_make_ascii_upper_case() {
-        macro_rules! test {
-            ($from: expr, $to: expr) => {
-                {
-                    let mut x = $from;
-                    x.make_ascii_uppercase();
-                    assert_eq!(x, $to);
-                }
-            }
-        }
-        test!(b'a', b'A');
-        test!(b'A', b'A');
-        test!(b'!', b'!');
-        test!('a', 'A');
-        test!('à', 'à');
-        test!('A', 'A');
-        test!('!', '!');
-        test!(b"h\xc3\xa9".to_vec(), b"H\xc3\xa9");
-        test!("hıKß".to_string(), "HıKß");
-
-        let mut x = "Hello".to_string();
-        x[..3].make_ascii_uppercase();  // Test IndexMut on String.
-        assert_eq!(x, "HELlo")
-    }
-
-    #[test]
-    fn test_eq_ignore_ascii_case() {
-        assert!("url()URL()uRl()Ürl".eq_ignore_ascii_case("url()url()url()Ürl"));
-        assert!(!"Ürl".eq_ignore_ascii_case("ürl"));
-        // Dotted capital I, Kelvin sign, Sharp S.
-        assert!("HİKß".eq_ignore_ascii_case("hİKß"));
-        assert!(!"İ".eq_ignore_ascii_case("i"));
-        assert!(!"K".eq_ignore_ascii_case("k"));
-        assert!(!"ß".eq_ignore_ascii_case("s"));
-
-        for i in 0..501 {
-            let lower = if 'A' as u32 <= i && i <= 'Z' as u32 { i + 'a' as u32 - 'A' as u32 }
-                        else { i };
-            assert!((from_u32(i).unwrap()).to_string().eq_ignore_ascii_case(
-                    &from_u32(lower).unwrap().to_string()));
-        }
-    }
-
-    #[test]
-    fn inference_works() {
-        let x = "a".to_string();
-        x.eq_ignore_ascii_case("A");
-    }
-}
diff --git a/src/system/error.rs b/src/system/error.rs
deleted file mode 100644
index b5aef1e..0000000
--- a/src/system/error.rs
+++ /dev/null
@@ -1,455 +0,0 @@
-// Copyright 2014 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Traits for working with Errors.
-//!
-//! # The `Error` trait
-//!
-//! `Error` is a trait representing the basic expectations for error values,
-//! i.e. values of type `E` in [`Result<T, E>`]. At a minimum, errors must provide
-//! a description, but they may optionally provide additional detail (via
-//! [`Display`]) and cause chain information:
-//!
-//! ```
-//! use std::fmt::Display;
-//!
-//! trait Error: Display {
-//!     fn description(&self) -> &str;
-//!
-//!     fn cause(&self) -> Option<&Error> { None }
-//! }
-//! ```
-//!
-//! The [`cause`] method is generally used when errors cross "abstraction
-//! boundaries", i.e.  when a one module must report an error that is "caused"
-//! by an error from a lower-level module. This setup makes it possible for the
-//! high-level module to provide its own errors that do not commit to any
-//! particular implementation, but also reveal some of its implementation for
-//! debugging via [`cause`] chains.
-//!
-//! [`Result<T, E>`]: ../result/enum.Result.html
-//! [`Display`]: ../fmt/trait.Display.html
-//! [`cause`]: trait.Error.html#method.cause
-
-// A note about crates and the facade:
-//
-// Originally, the `Error` trait was defined in libcore, and the impls
-// were scattered about. However, coherence objected to this
-// arrangement, because to create the blanket impls for `Box` required
-// knowing that `&str: !Error`, and we have no means to deal with that
-// sort of conflict just now. Therefore, for the time being, we have
-// moved the `Error` trait into libstd. As we evolve a sol'n to the
-// coherence challenge (e.g., specialization, neg impls, etc) we can
-// reconsider what crate these items belong in.
-
-use core::any::TypeId;
-use core::cell;
-use rustc_unicode::char;
-use core::fmt::{self, Debug, Display};
-use core::mem::transmute;
-use core::num;
-use core::str;
-use collections::string::{self, String};
-use alloc::boxed::Box;
-
-/// Base functionality for all errors in Rust.
-pub trait Error: Debug + Display {
-    /// A short description of the error.
-    ///
-    /// The description should not contain newlines or sentence-ending
-    /// punctuation, to facilitate embedding in larger user-facing
-    /// strings.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::error::Error;
-    ///
-    /// match "xc".parse::<u32>() {
-    ///     Err(e) => {
-    ///         println!("Error: {}", e.description());
-    ///     }
-    ///     _ => println!("No error"),
-    /// }
-    /// ```
-    fn description(&self) -> &str;
-
-    /// The lower-level cause of this error, if any.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::error::Error;
-    /// use std::fmt;
-    ///
-    /// #[derive(Debug)]
-    /// struct SuperError {
-    ///     side: SuperErrorSideKick,
-    /// }
-    ///
-    /// impl fmt::Display for SuperError {
-    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    ///         write!(f, "SuperError is here!")
-    ///     }
-    /// }
-    ///
-    /// impl Error for SuperError {
-    ///     fn description(&self) -> &str {
-    ///         "I'm the superhero of errors!"
-    ///     }
-    ///
-    ///     fn cause(&self) -> Option<&Error> {
-    ///         Some(&self.side)
-    ///     }
-    /// }
-    ///
-    /// #[derive(Debug)]
-    /// struct SuperErrorSideKick;
-    ///
-    /// impl fmt::Display for SuperErrorSideKick {
-    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    ///         write!(f, "SuperErrorSideKick is here!")
-    ///     }
-    /// }
-    ///
-    /// impl Error for SuperErrorSideKick {
-    ///     fn description(&self) -> &str {
-    ///         "I'm SuperError side kick!"
-    ///     }
-    /// }
-    ///
-    /// fn get_super_error() -> Result<(), SuperError> {
-    ///     Err(SuperError { side: SuperErrorSideKick })
-    /// }
-    ///
-    /// fn main() {
-    ///     match get_super_error() {
-    ///         Err(e) => {
-    ///             println!("Error: {}", e.description());
-    ///             println!("Caused by: {}", e.cause().unwrap());
-    ///         }
-    ///         _ => println!("No error"),
-    ///     }
-    /// }
-    /// ```
-    fn cause(&self) -> Option<&Error> { None }
-
-    /// Get the `TypeId` of `self`
-    #[doc(hidden)]
-    fn type_id(&self) -> TypeId where Self: 'static {
-        TypeId::of::<Self>()
-    }
-}
-
-impl<'a, E: Error + 'a> From<E> for Box<Error + 'a> {
-    fn from(err: E) -> Box<Error + 'a> {
-        Box::new(err)
-    }
-}
-
-impl<'a, E: Error + Send + Sync + 'a> From<E> for Box<Error + Send + Sync + 'a> {
-    fn from(err: E) -> Box<Error + Send + Sync + 'a> {
-        Box::new(err)
-    }
-}
-
-impl From<String> for Box<Error + Send + Sync> {
-    fn from(err: String) -> Box<Error + Send + Sync> {
-        #[derive(Debug)]
-        struct StringError(String);
-
-        impl Error for StringError {
-            fn description(&self) -> &str { &self.0 }
-        }
-
-        impl Display for StringError {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                Display::fmt(&self.0, f)
-            }
-        }
-
-        Box::new(StringError(err))
-    }
-}
-
-impl From<String> for Box<Error> {
-    fn from(str_err: String) -> Box<Error> {
-        let err1: Box<Error + Send + Sync> = From::from(str_err);
-        let err2: Box<Error> = err1;
-        err2
-    }
-}
-
-impl<'a, 'b> From<&'b str> for Box<Error + Send + Sync + 'a> {
-    fn from(err: &'b str) -> Box<Error + Send + Sync + 'a> {
-        From::from(String::from(err))
-    }
-}
-
-impl<'a> From<&'a str> for Box<Error> {
-    fn from(err: &'a str) -> Box<Error> {
-        From::from(String::from(err))
-    }
-}
-
-impl Error for str::ParseBoolError {
-    fn description(&self) -> &str { "failed to parse bool" }
-}
-
-impl Error for str::Utf8Error {
-    fn description(&self) -> &str {
-        "invalid utf-8: corrupt contents"
-    }
-}
-
-impl Error for num::ParseIntError {
-    fn description(&self) -> &str {
-        self.__description()
-    }
-}
-
-impl Error for num::TryFromIntError {
-    fn description(&self) -> &str {
-        self.__description()
-    }
-}
-
-impl Error for num::ParseFloatError {
-    fn description(&self) -> &str {
-        self.__description()
-    }
-}
-
-impl Error for string::FromUtf8Error {
-    fn description(&self) -> &str {
-        "invalid utf-8"
-    }
-}
-
-impl Error for string::FromUtf16Error {
-    fn description(&self) -> &str {
-        "invalid utf-16"
-    }
-}
-
-impl Error for string::ParseError {
-    fn description(&self) -> &str {
-        match *self {}
-    }
-}
-
-impl Error for char::DecodeUtf16Error {
-    fn description(&self) -> &str {
-        "unpaired surrogate found"
-    }
-}
-
-impl<T: Error> Error for Box<T> {
-    fn description(&self) -> &str {
-        Error::description(&**self)
-    }
-
-    fn cause(&self) -> Option<&Error> {
-        Error::cause(&**self)
-    }
-}
-
-impl Error for fmt::Error {
-    fn description(&self) -> &str {
-        "an error occurred when formatting an argument"
-    }
-}
-
-impl Error for cell::BorrowError {
-    fn description(&self) -> &str {
-        "already mutably borrowed"
-    }
-}
-
-impl Error for cell::BorrowMutError {
-    fn description(&self) -> &str {
-        "already borrowed"
-    }
-}
-
-impl Error for char::CharTryFromError {
-    fn description(&self) -> &str {
-        "converted integer out of range for `char`"
-    }
-}
-
-// copied from any.rs
-impl Error + 'static {
-    /// Returns true if the boxed type is the same as `T`
-    #[inline]
-    pub fn is<T: Error + 'static>(&self) -> bool {
-        // Get TypeId of the type this function is instantiated with
-        let t = TypeId::of::<T>();
-
-        // Get TypeId of the type in the trait object
-        let boxed = self.type_id();
-
-        // Compare both TypeIds on equality
-        t == boxed
-    }
-
-    /// Returns some reference to the boxed value if it is of type `T`, or
-    /// `None` if it isn't.
-    #[inline]
-    pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T> {
-        if self.is::<T>() {
-            unsafe {
-                Some(&*(self as *const Error as *const T))
-            }
-        } else {
-            None
-        }
-    }
-
-    /// Returns some mutable reference to the boxed value if it is of type `T`, or
-    /// `None` if it isn't.
-    #[inline]
-    pub fn downcast_mut<T: Error + 'static>(&mut self) -> Option<&mut T> {
-        if self.is::<T>() {
-            unsafe {
-                Some(&mut *(self as *mut Error as *mut T))
-            }
-        } else {
-            None
-        }
-    }
-}
-
-impl Error + 'static + Send {
-    /// Forwards to the method defined on the type `Any`.
-    #[inline]
-    pub fn is<T: Error + 'static>(&self) -> bool {
-        <Error + 'static>::is::<T>(self)
-    }
-
-    /// Forwards to the method defined on the type `Any`.
-    #[inline]
-    pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T> {
-        <Error + 'static>::downcast_ref::<T>(self)
-    }
-
-    /// Forwards to the method defined on the type `Any`.
-    #[inline]
-    pub fn downcast_mut<T: Error + 'static>(&mut self) -> Option<&mut T> {
-        <Error + 'static>::downcast_mut::<T>(self)
-    }
-}
-
-impl Error + 'static + Send + Sync {
-    /// Forwards to the method defined on the type `Any`.
-    #[inline]
-    pub fn is<T: Error + 'static>(&self) -> bool {
-        <Error + 'static>::is::<T>(self)
-    }
-
-    /// Forwards to the method defined on the type `Any`.
-    #[inline]
-    pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T> {
-        <Error + 'static>::downcast_ref::<T>(self)
-    }
-
-    /// Forwards to the method defined on the type `Any`.
-    #[inline]
-    pub fn downcast_mut<T: Error + 'static>(&mut self) -> Option<&mut T> {
-        <Error + 'static>::downcast_mut::<T>(self)
-    }
-}
-
-impl Error {
-    #[inline]
-    /// Attempt to downcast the box to a concrete type.
-    pub fn downcast<T: Error + 'static>(self: Box<Self>) -> Result<Box<T>, Box<Error>> {
-        if self.is::<T>() {
-            unsafe {
-                let raw: *mut Error = Box::into_raw(self);
-                Ok(Box::from_raw(raw as *mut T))
-            }
-        } else {
-            Err(self)
-        }
-    }
-}
-
-impl Error + Send {
-    #[inline]
-    /// Attempt to downcast the box to a concrete type.
-    pub fn downcast<T: Error + 'static>(self: Box<Self>)
-                                        -> Result<Box<T>, Box<Error + Send>> {
-        let err: Box<Error> = self;
-        <Error>::downcast(err).map_err(|s| unsafe {
-            // reapply the Send marker
-            transmute::<Box<Error>, Box<Error + Send>>(s)
-        })
-    }
-}
-
-impl Error + Send + Sync {
-    #[inline]
-    /// Attempt to downcast the box to a concrete type.
-    pub fn downcast<T: Error + 'static>(self: Box<Self>)
-                                        -> Result<Box<T>, Box<Self>> {
-        let err: Box<Error> = self;
-        <Error>::downcast(err).map_err(|s| unsafe {
-            // reapply the Send+Sync marker
-            transmute::<Box<Error>, Box<Error + Send + Sync>>(s)
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Error;
-    use core::fmt;
-    use alloc::boxed::Box;
-
-    #[derive(Debug, PartialEq)]
-    struct A;
-    #[derive(Debug, PartialEq)]
-    struct B;
-
-    impl fmt::Display for A {
-        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-            write!(f, "A")
-        }
-    }
-    impl fmt::Display for B {
-        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-            write!(f, "B")
-        }
-    }
-
-    impl Error for A {
-        fn description(&self) -> &str { "A-desc" }
-    }
-    impl Error for B {
-        fn description(&self) -> &str { "A-desc" }
-    }
-
-    #[test]
-    fn downcasting() {
-        let mut a = A;
-        let mut a = &mut a as &mut (Error + 'static);
-        assert_eq!(a.downcast_ref::<A>(), Some(&A));
-        assert_eq!(a.downcast_ref::<B>(), None);
-        assert_eq!(a.downcast_mut::<A>(), Some(&mut A));
-        assert_eq!(a.downcast_mut::<B>(), None);
-
-        let a: Box<Error> = Box::new(A);
-        match a.downcast::<B>() {
-            Ok(..) => panic!("expected error"),
-            Err(e) => assert_eq!(*e.downcast::<A>().unwrap(), A),
-        }
-    }
-}
diff --git a/src/system/ffi/c_str.rs b/src/system/ffi/c_str.rs
deleted file mode 100644
index 67d37d8..0000000
--- a/src/system/ffi/c_str.rs
+++ /dev/null
@@ -1,785 +0,0 @@
-// Copyright 2012 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::ascii;
-use std::borrow::{Cow, Borrow};
-use std::cmp::Ordering;
-use std::error::Error;
-use std::fmt::{self, Write};
-use std::io;
-use libctru::libc::{self, c_char};
-use std::mem;
-use system::memchr;
-use std::ops;
-use std::ptr;
-use std::slice;
-use std::str::{self, Utf8Error};
-
-/// A type representing an owned C-compatible string
-///
-/// This type serves the primary purpose of being able to safely generate a
-/// C-compatible string from a Rust byte slice or vector. An instance of this
-/// type is a static guarantee that the underlying bytes contain no interior 0
-/// bytes and the final byte is 0.
-///
-/// A `CString` is created from either a byte slice or a byte vector. After
-/// being created, a `CString` predominately inherits all of its methods from
-/// the `Deref` implementation to `[c_char]`. Note that the underlying array
-/// is represented as an array of `c_char` as opposed to `u8`. A `u8` slice
-/// can be obtained with the `as_bytes` method.  Slices produced from a `CString`
-/// do *not* contain the trailing nul terminator unless otherwise specified.
-///
-/// # Examples
-///
-/// ```no_run
-/// # fn main() {
-/// use std::ffi::CString;
-/// use std::os::raw::c_char;
-///
-/// extern {
-///     fn my_printer(s: *const c_char);
-/// }
-///
-/// let c_to_print = CString::new("Hello, world!").unwrap();
-/// unsafe {
-///     my_printer(c_to_print.as_ptr());
-/// }
-/// # }
-/// ```
-///
-/// # Safety
-///
-/// `CString` is intended for working with traditional C-style strings
-/// (a sequence of non-null bytes terminated by a single null byte); the
-/// primary use case for these kinds of strings is interoperating with C-like
-/// code. Often you will need to transfer ownership to/from that external
-/// code. It is strongly recommended that you thoroughly read through the
-/// documentation of `CString` before use, as improper ownership management
-/// of `CString` instances can lead to invalid memory accesses, memory leaks,
-/// and other memory errors.
-
-#[derive(PartialEq, PartialOrd, Eq, Ord, Hash, Clone)]
-pub struct CString {
-    // Invariant 1: the slice ends with a zero byte and has a length of at least one.
-    // Invariant 2: the slice contains only one zero byte.
-    // Improper usage of unsafe function can break Invariant 2, but not Invariant 1.
-    inner: Box<[u8]>,
-}
-
-/// Representation of a borrowed C string.
-///
-/// This dynamically sized type is only safely constructed via a borrowed
-/// version of an instance of `CString`. This type can be constructed from a raw
-/// C string as well and represents a C string borrowed from another location.
-///
-/// Note that this structure is **not** `repr(C)` and is not recommended to be
-/// placed in the signatures of FFI functions. Instead safe wrappers of FFI
-/// functions may leverage the unsafe `from_ptr` constructor to provide a safe
-/// interface to other consumers.
-///
-/// # Examples
-///
-/// Inspecting a foreign C string
-///
-/// ```no_run
-/// use std::ffi::CStr;
-/// use std::os::raw::c_char;
-///
-/// extern { fn my_string() -> *const c_char; }
-///
-/// unsafe {
-///     let slice = CStr::from_ptr(my_string());
-///     println!("string length: {}", slice.to_bytes().len());
-/// }
-/// ```
-///
-/// Passing a Rust-originating C string
-///
-/// ```no_run
-/// use std::ffi::{CString, CStr};
-/// use std::os::raw::c_char;
-///
-/// fn work(data: &CStr) {
-///     extern { fn work_with(data: *const c_char); }
-///
-///     unsafe { work_with(data.as_ptr()) }
-/// }
-///
-/// let s = CString::new("data data data data").unwrap();
-/// work(&s);
-/// ```
-///
-/// Converting a foreign C string into a Rust `String`
-///
-/// ```no_run
-/// use std::ffi::CStr;
-/// use std::os::raw::c_char;
-///
-/// extern { fn my_string() -> *const c_char; }
-///
-/// fn my_string_safe() -> String {
-///     unsafe {
-///         CStr::from_ptr(my_string()).to_string_lossy().into_owned()
-///     }
-/// }
-///
-/// println!("string: {}", my_string_safe());
-/// ```
-#[derive(Hash)]
-pub struct CStr {
-    // FIXME: this should not be represented with a DST slice but rather with
-    //        just a raw `c_char` along with some form of marker to make
-    //        this an unsized type. Essentially `sizeof(&CStr)` should be the
-    //        same as `sizeof(&c_char)` but `CStr` should be an unsized type.
-    inner: [c_char]
-}
-
-/// An error returned from `CString::new` to indicate that a nul byte was found
-/// in the vector provided.
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub struct NulError(usize, Vec<u8>);
-
-/// An error returned from `CStr::from_bytes_with_nul` to indicate that a nul
-/// byte was found too early in the slice provided or one wasn't found at all.
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub struct FromBytesWithNulError { _a: () }
-
-/// An error returned from `CString::into_string` to indicate that a UTF-8 error
-/// was encountered during the conversion.
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub struct IntoStringError {
-    inner: CString,
-    error: Utf8Error,
-}
-
-impl CString {
-    /// Creates a new C-compatible string from a container of bytes.
-    ///
-    /// This method will consume the provided data and use the underlying bytes
-    /// to construct a new string, ensuring that there is a trailing 0 byte.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::ffi::CString;
-    /// use std::os::raw::c_char;
-    ///
-    /// extern { fn puts(s: *const c_char); }
-    ///
-    /// let to_print = CString::new("Hello!").unwrap();
-    /// unsafe {
-    ///     puts(to_print.as_ptr());
-    /// }
-    /// ```
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error if the bytes yielded contain an
-    /// internal 0 byte. The error returned will contain the bytes as well as
-    /// the position of the nul byte.
-    pub fn new<T: Into<Vec<u8>>>(t: T) -> Result<CString, NulError> {
-        Self::_new(t.into())
-    }
-
-    fn _new(bytes: Vec<u8>) -> Result<CString, NulError> {
-        match memchr::memchr(0, &bytes) {
-            Some(i) => Err(NulError(i, bytes)),
-            None => Ok(unsafe { CString::from_vec_unchecked(bytes) }),
-        }
-    }
-
-    /// Creates a C-compatible string from a byte vector without checking for
-    /// interior 0 bytes.
-    ///
-    /// This method is equivalent to `new` except that no runtime assertion
-    /// is made that `v` contains no 0 bytes, and it requires an actual
-    /// byte vector, not anything that can be converted to one with Into.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::CString;
-    ///
-    /// let raw = b"foo".to_vec();
-    /// unsafe {
-    ///     let c_string = CString::from_vec_unchecked(raw);
-    /// }
-    /// ```
-    pub unsafe fn from_vec_unchecked(mut v: Vec<u8>) -> CString {
-        v.reserve_exact(1);
-        v.push(0);
-        CString { inner: v.into_boxed_slice() }
-    }
-
-    /// Retakes ownership of a `CString` that was transferred to C.
-    ///
-    /// Additionally, the length of the string will be recalculated from the pointer.
-    ///
-    /// # Safety
-    ///
-    /// This should only ever be called with a pointer that was earlier
-    /// obtained by calling `into_raw` on a `CString`. Other usage (e.g. trying to take
-    /// ownership of a string that was allocated by foreign code) is likely to lead
-    /// to undefined behavior or allocator corruption.
-    pub unsafe fn from_raw(ptr: *mut c_char) -> CString {
-        let len = libc::strlen(ptr) + 1; // Including the NUL byte
-        let slice = slice::from_raw_parts(ptr, len as usize);
-        CString { inner: mem::transmute(slice) }
-    }
-
-    /// Transfers ownership of the string to a C caller.
-    ///
-    /// The pointer must be returned to Rust and reconstituted using
-    /// `from_raw` to be properly deallocated. Specifically, one
-    /// should *not* use the standard C `free` function to deallocate
-    /// this string.
-    ///
-    /// Failure to call `from_raw` will lead to a memory leak.
-    pub fn into_raw(self) -> *mut c_char {
-        Box::into_raw(self.into_inner()) as *mut c_char
-    }
-
-    /// Converts the `CString` into a `String` if it contains valid Unicode data.
-    ///
-    /// On failure, ownership of the original `CString` is returned.
-    pub fn into_string(self) -> Result<String, IntoStringError> {
-        String::from_utf8(self.into_bytes())
-            .map_err(|e| IntoStringError {
-                error: e.utf8_error(),
-                inner: unsafe { CString::from_vec_unchecked(e.into_bytes()) },
-            })
-    }
-
-    /// Returns the underlying byte buffer.
-    ///
-    /// The returned buffer does **not** contain the trailing nul separator and
-    /// it is guaranteed to not have any interior nul bytes.
-    pub fn into_bytes(self) -> Vec<u8> {
-        let mut vec = self.into_inner().into_vec();
-        let _nul = vec.pop();
-        debug_assert_eq!(_nul, Some(0u8));
-        vec
-    }
-
-    /// Equivalent to the `into_bytes` function except that the returned vector
-    /// includes the trailing nul byte.
-    pub fn into_bytes_with_nul(self) -> Vec<u8> {
-        self.into_inner().into_vec()
-    }
-
-    /// Returns the contents of this `CString` as a slice of bytes.
-    ///
-    /// The returned slice does **not** contain the trailing nul separator and
-    /// it is guaranteed to not have any interior nul bytes.
-    pub fn as_bytes(&self) -> &[u8] {
-        &self.inner[..self.inner.len() - 1]
-    }
-
-    /// Equivalent to the `as_bytes` function except that the returned slice
-    /// includes the trailing nul byte.
-    pub fn as_bytes_with_nul(&self) -> &[u8] {
-        &self.inner
-    }
-
-    // Bypass "move out of struct which implements `Drop` trait" restriction.
-    fn into_inner(self) -> Box<[u8]> {
-        unsafe {
-            let result = ptr::read(&self.inner);
-            mem::forget(self);
-            result
-        }
-    }
-}
-
-// Turns this `CString` into an empty string to prevent
-// memory unsafe code from working by accident. Inline
-// to prevent LLVM from optimizing it away in debug builds.
-impl Drop for CString {
-    #[inline]
-    fn drop(&mut self) {
-        unsafe { *self.inner.get_unchecked_mut(0) = 0; }
-    }
-}
-
-impl ops::Deref for CString {
-    type Target = CStr;
-
-    fn deref(&self) -> &CStr {
-        unsafe { mem::transmute(self.as_bytes_with_nul()) }
-    }
-}
-
-impl fmt::Debug for CString {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&**self, f)
-    }
-}
-
-impl From<CString> for Vec<u8> {
-    fn from(s: CString) -> Vec<u8> {
-        s.into_bytes()
-    }
-}
-
-impl fmt::Debug for CStr {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "\"")?;
-        for byte in self.to_bytes().iter().flat_map(|&b| ascii::escape_default(b)) {
-            f.write_char(byte as char)?;
-        }
-        write!(f, "\"")
-    }
-}
-
-impl<'a> Default for &'a CStr {
-    fn default() -> &'a CStr {
-        static SLICE: &'static [c_char] = &[0];
-        unsafe { CStr::from_ptr(SLICE.as_ptr()) }
-    }
-}
-
-impl Default for CString {
-    /// Creates an empty `CString`.
-    fn default() -> CString {
-        let a: &CStr = Default::default();
-        a.to_owned()
-    }
-}
-
-impl Borrow<CStr> for CString {
-    fn borrow(&self) -> &CStr { self }
-}
-
-impl NulError {
-    /// Returns the position of the nul byte in the slice that was provided to
-    /// `CString::new`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::CString;
-    ///
-    /// let nul_error = CString::new("foo\0bar").unwrap_err();
-    /// assert_eq!(nul_error.nul_position(), 3);
-    ///
-    /// let nul_error = CString::new("foo bar\0").unwrap_err();
-    /// assert_eq!(nul_error.nul_position(), 7);
-    /// ```
-    pub fn nul_position(&self) -> usize { self.0 }
-
-    /// Consumes this error, returning the underlying vector of bytes which
-    /// generated the error in the first place.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::CString;
-    ///
-    /// let nul_error = CString::new("foo\0bar").unwrap_err();
-    /// assert_eq!(nul_error.into_vec(), b"foo\0bar");
-    /// ```
-    pub fn into_vec(self) -> Vec<u8> { self.1 }
-}
-
-impl Error for NulError {
-    fn description(&self) -> &str { "nul byte found in data" }
-}
-
-impl fmt::Display for NulError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "nul byte found in provided data at position: {}", self.0)
-    }
-}
-
-impl From<NulError> for io::Error {
-    fn from(_: NulError) -> io::Error {
-        io::Error::new(io::ErrorKind::InvalidInput,
-                       "data provided contains a nul byte")
-    }
-}
-
-impl IntoStringError {
-    /// Consumes this error, returning original `CString` which generated the
-    /// error.
-    pub fn into_cstring(self) -> CString {
-        self.inner
-    }
-
-    /// Access the underlying UTF-8 error that was the cause of this error.
-    pub fn utf8_error(&self) -> Utf8Error {
-        self.error
-    }
-}
-
-impl Error for IntoStringError {
-    fn description(&self) -> &str {
-        "C string contained non-utf8 bytes"
-    }
-
-    fn cause(&self) -> Option<&Error> {
-        Some(&self.error)
-    }
-}
-
-impl fmt::Display for IntoStringError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.description().fmt(f)
-    }
-}
-
-impl CStr {
-    /// Casts a raw C string to a safe C string wrapper.
-    ///
-    /// This function will cast the provided `ptr` to the `CStr` wrapper which
-    /// allows inspection and interoperation of non-owned C strings. This method
-    /// is unsafe for a number of reasons:
-    ///
-    /// * There is no guarantee to the validity of `ptr`
-    /// * The returned lifetime is not guaranteed to be the actual lifetime of
-    ///   `ptr`
-    /// * There is no guarantee that the memory pointed to by `ptr` contains a
-    ///   valid nul terminator byte at the end of the string.
-    ///
-    /// > **Note**: This operation is intended to be a 0-cost cast but it is
-    /// > currently implemented with an up-front calculation of the length of
-    /// > the string. This is not guaranteed to always be the case.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// # fn main() {
-    /// use std::ffi::CStr;
-    /// use std::os::raw::c_char;
-    ///
-    /// extern {
-    ///     fn my_string() -> *const c_char;
-    /// }
-    ///
-    /// unsafe {
-    ///     let slice = CStr::from_ptr(my_string());
-    ///     println!("string returned: {}", slice.to_str().unwrap());
-    /// }
-    /// # }
-    /// ```
-    pub unsafe fn from_ptr<'a>(ptr: *const c_char) -> &'a CStr {
-        let len = libc::strlen(ptr);
-        mem::transmute(slice::from_raw_parts(ptr, len as usize + 1))
-    }
-
-    /// Creates a C string wrapper from a byte slice.
-    ///
-    /// This function will cast the provided `bytes` to a `CStr` wrapper after
-    /// ensuring that it is null terminated and does not contain any interior
-    /// nul bytes.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::CStr;
-    ///
-    /// let cstr = CStr::from_bytes_with_nul(b"hello\0");
-    /// assert!(cstr.is_ok());
-    /// ```
-    pub fn from_bytes_with_nul(bytes: &[u8])
-                               -> Result<&CStr, FromBytesWithNulError> {
-        if bytes.is_empty() || memchr::memchr(0, &bytes) != Some(bytes.len() - 1) {
-            Err(FromBytesWithNulError { _a: () })
-        } else {
-            Ok(unsafe { Self::from_bytes_with_nul_unchecked(bytes) })
-        }
-    }
-
-    /// Unsafely creates a C string wrapper from a byte slice.
-    ///
-    /// This function will cast the provided `bytes` to a `CStr` wrapper without
-    /// performing any sanity checks. The provided slice must be null terminated
-    /// and not contain any interior nul bytes.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::{CStr, CString};
-    ///
-    /// unsafe {
-    ///     let cstring = CString::new("hello").unwrap();
-    ///     let cstr = CStr::from_bytes_with_nul_unchecked(cstring.to_bytes_with_nul());
-    ///     assert_eq!(cstr, &*cstring);
-    /// }
-    /// ```
-    pub unsafe fn from_bytes_with_nul_unchecked(bytes: &[u8]) -> &CStr {
-        mem::transmute(bytes)
-    }
-
-    /// Returns the inner pointer to this C string.
-    ///
-    /// The returned pointer will be valid for as long as `self` is and points
-    /// to a contiguous region of memory terminated with a 0 byte to represent
-    /// the end of the string.
-    ///
-    /// **WARNING**
-    ///
-    /// It is your responsibility to make sure that the underlying memory is not
-    /// freed too early. For example, the following code will cause undefined
-    /// behaviour when `ptr` is used inside the `unsafe` block:
-    ///
-    /// ```no_run
-    /// use std::ffi::{CString};
-    ///
-    /// let ptr = CString::new("Hello").unwrap().as_ptr();
-    /// unsafe {
-    ///     // `ptr` is dangling
-    ///     *ptr;
-    /// }
-    /// ```
-    ///
-    /// This happens because the pointer returned by `as_ptr` does not carry any
-    /// lifetime information and the string is deallocated immediately after
-    /// the `CString::new("Hello").unwrap().as_ptr()` expression is evaluated.
-    /// To fix the problem, bind the string to a local variable:
-    ///
-    /// ```no_run
-    /// use std::ffi::{CString};
-    ///
-    /// let hello = CString::new("Hello").unwrap();
-    /// let ptr = hello.as_ptr();
-    /// unsafe {
-    ///     // `ptr` is valid because `hello` is in scope
-    ///     *ptr;
-    /// }
-    /// ```
-    pub fn as_ptr(&self) -> *const c_char {
-        self.inner.as_ptr()
-    }
-
-    /// Converts this C string to a byte slice.
-    ///
-    /// This function will calculate the length of this string (which normally
-    /// requires a linear amount of work to be done) and then return the
-    /// resulting slice of `u8` elements.
-    ///
-    /// The returned slice will **not** contain the trailing nul that this C
-    /// string has.
-    ///
-    /// > **Note**: This method is currently implemented as a 0-cost cast, but
-    /// > it is planned to alter its definition in the future to perform the
-    /// > length calculation whenever this method is called.
-    pub fn to_bytes(&self) -> &[u8] {
-        let bytes = self.to_bytes_with_nul();
-        &bytes[..bytes.len() - 1]
-    }
-
-    /// Converts this C string to a byte slice containing the trailing 0 byte.
-    ///
-    /// This function is the equivalent of `to_bytes` except that it will retain
-    /// the trailing nul instead of chopping it off.
-    ///
-    /// > **Note**: This method is currently implemented as a 0-cost cast, but
-    /// > it is planned to alter its definition in the future to perform the
-    /// > length calculation whenever this method is called.
-    pub fn to_bytes_with_nul(&self) -> &[u8] {
-        unsafe { mem::transmute(&self.inner) }
-    }
-
-    /// Yields a `&str` slice if the `CStr` contains valid UTF-8.
-    ///
-    /// This function will calculate the length of this string and check for
-    /// UTF-8 validity, and then return the `&str` if it's valid.
-    ///
-    /// > **Note**: This method is currently implemented to check for validity
-    /// > after a 0-cost cast, but it is planned to alter its definition in the
-    /// > future to perform the length calculation in addition to the UTF-8
-    /// > check whenever this method is called.
-    pub fn to_str(&self) -> Result<&str, str::Utf8Error> {
-        // NB: When CStr is changed to perform the length check in .to_bytes()
-        // instead of in from_ptr(), it may be worth considering if this should
-        // be rewritten to do the UTF-8 check inline with the length calculation
-        // instead of doing it afterwards.
-        str::from_utf8(self.to_bytes())
-    }
-
-    /// Converts a `CStr` into a `Cow<str>`.
-    ///
-    /// This function will calculate the length of this string (which normally
-    /// requires a linear amount of work to be done) and then return the
-    /// resulting slice as a `Cow<str>`, replacing any invalid UTF-8 sequences
-    /// with `U+FFFD REPLACEMENT CHARACTER`.
-    ///
-    /// > **Note**: This method is currently implemented to check for validity
-    /// > after a 0-cost cast, but it is planned to alter its definition in the
-    /// > future to perform the length calculation in addition to the UTF-8
-    /// > check whenever this method is called.
-    pub fn to_string_lossy(&self) -> Cow<str> {
-        String::from_utf8_lossy(self.to_bytes())
-    }
-}
-
-impl PartialEq for CStr {
-    fn eq(&self, other: &CStr) -> bool {
-        self.to_bytes().eq(other.to_bytes())
-    }
-}
-impl Eq for CStr {}
-impl PartialOrd for CStr {
-    fn partial_cmp(&self, other: &CStr) -> Option<Ordering> {
-        self.to_bytes().partial_cmp(&other.to_bytes())
-    }
-}
-impl Ord for CStr {
-    fn cmp(&self, other: &CStr) -> Ordering {
-        self.to_bytes().cmp(&other.to_bytes())
-    }
-}
-
-impl ToOwned for CStr {
-    type Owned = CString;
-
-    fn to_owned(&self) -> CString {
-        unsafe { CString::from_vec_unchecked(self.to_bytes().to_vec()) }
-    }
-}
-
-impl<'a> From<&'a CStr> for CString {
-    fn from(s: &'a CStr) -> CString {
-        s.to_owned()
-    }
-}
-
-impl ops::Index<ops::RangeFull> for CString {
-    type Output = CStr;
-
-    #[inline]
-    fn index(&self, _index: ops::RangeFull) -> &CStr {
-        self
-    }
-}
-
-impl AsRef<CStr> for CStr {
-    fn as_ref(&self) -> &CStr {
-        self
-    }
-}
-
-impl AsRef<CStr> for CString {
-    fn as_ref(&self) -> &CStr {
-        self
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use libc::c_char;
-    use collections::borrow::Cow::{Borrowed, Owned};
-    use collections::borrow::ToOwned;
-    use core::hash::{Hash, Hasher};
-
-    #[test]
-    fn c_to_rust() {
-        let data = b"123\0";
-        let ptr = data.as_ptr() as *const c_char;
-        unsafe {
-            assert_eq!(CStr::from_ptr(ptr).to_bytes(), b"123");
-            assert_eq!(CStr::from_ptr(ptr).to_bytes_with_nul(), b"123\0");
-        }
-    }
-
-    #[test]
-    fn simple() {
-        let s = CString::new("1234").unwrap();
-        assert_eq!(s.as_bytes(), b"1234");
-        assert_eq!(s.as_bytes_with_nul(), b"1234\0");
-    }
-
-    #[test]
-    fn build_with_zero1() {
-        assert!(CString::new(&b"\0"[..]).is_err());
-    }
-    #[test]
-    fn build_with_zero2() {
-        assert!(CString::new(vec![0]).is_err());
-    }
-
-    #[test]
-    fn build_with_zero3() {
-        unsafe {
-            let s = CString::from_vec_unchecked(vec![0]);
-            assert_eq!(s.as_bytes(), b"\0");
-        }
-    }
-
-    #[test]
-    fn formatted() {
-        let s = CString::new(&b"abc\x01\x02\n\xE2\x80\xA6\xFF"[..]).unwrap();
-        assert_eq!(format!("{:?}", s), r#""abc\x01\x02\n\xe2\x80\xa6\xff""#);
-    }
-
-    #[test]
-    fn borrowed() {
-        unsafe {
-            let s = CStr::from_ptr(b"12\0".as_ptr() as *const _);
-            assert_eq!(s.to_bytes(), b"12");
-            assert_eq!(s.to_bytes_with_nul(), b"12\0");
-        }
-    }
-
-    #[test]
-    fn to_str() {
-        let data = b"123\xE2\x80\xA6\0";
-        let ptr = data.as_ptr() as *const c_char;
-        unsafe {
-            assert_eq!(CStr::from_ptr(ptr).to_str(), Ok("123…"));
-            assert_eq!(CStr::from_ptr(ptr).to_string_lossy(), Borrowed("123…"));
-        }
-        let data = b"123\xE2\0";
-        let ptr = data.as_ptr() as *const c_char;
-        unsafe {
-            assert!(CStr::from_ptr(ptr).to_str().is_err());
-            assert_eq!(CStr::from_ptr(ptr).to_string_lossy(), Owned::<str>(format!("123\u{FFFD}")));
-        }
-    }
-
-    #[test]
-    fn to_owned() {
-        let data = b"123\0";
-        let ptr = data.as_ptr() as *const c_char;
-
-        let owned = unsafe { CStr::from_ptr(ptr).to_owned() };
-        assert_eq!(owned.as_bytes_with_nul(), data);
-    }
-
-    #[test]
-    fn from_bytes_with_nul() {
-        let data = b"123\0";
-        let cstr = CStr::from_bytes_with_nul(data);
-        assert_eq!(cstr.map(CStr::to_bytes), Ok(&b"123"[..]));
-        let cstr = CStr::from_bytes_with_nul(data);
-        assert_eq!(cstr.map(CStr::to_bytes_with_nul), Ok(&b"123\0"[..]));
-
-        unsafe {
-            let cstr = CStr::from_bytes_with_nul(data);
-            let cstr_unchecked = CStr::from_bytes_with_nul_unchecked(data);
-            assert_eq!(cstr, Ok(cstr_unchecked));
-        }
-    }
-
-    #[test]
-    fn from_bytes_with_nul_unterminated() {
-        let data = b"123";
-        let cstr = CStr::from_bytes_with_nul(data);
-        assert!(cstr.is_err());
-    }
-
-    #[test]
-    fn from_bytes_with_nul_interior() {
-        let data = b"1\023\0";
-        let cstr = CStr::from_bytes_with_nul(data);
-        assert!(cstr.is_err());
-    }
-}
diff --git a/src/system/ffi/mod.rs b/src/system/ffi/mod.rs
deleted file mode 100644
index d4ed3a7..0000000
--- a/src/system/ffi/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-pub use self::c_str::{CString, CStr};
-pub use self::os_str::{OsString, OsStr};
-
-mod c_str;
-mod os_str;
diff --git a/src/system/ffi/os_str.rs b/src/system/ffi/os_str.rs
deleted file mode 100644
index 6c0ff5e..0000000
--- a/src/system/ffi/os_str.rs
+++ /dev/null
@@ -1,573 +0,0 @@
-// 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::borrow::{Borrow, Cow};
-use std::fmt::{self, Debug};
-use std::mem;
-use std::ops;
-use std::cmp;
-use std::hash::{Hash, Hasher};
-
-use system::sys::wtf8::{Wtf8, Wtf8Buf};
-use system::sys::{AsInner, IntoInner, FromInner};
-pub use system::sys::wtf8::EncodeWide;
-
-/// A type that can represent owned, mutable platform-native strings, but is
-/// cheaply inter-convertible with Rust strings.
-///
-/// The need for this type arises from the fact that:
-///
-/// * On Unix systems, strings are often arbitrary sequences of non-zero
-///   bytes, in many cases interpreted as UTF-8.
-///
-/// * On Windows, strings are often arbitrary sequences of non-zero 16-bit
-///   values, interpreted as UTF-16 when it is valid to do so.
-///
-/// * In Rust, strings are always valid UTF-8, but may contain zeros.
-///
-/// `OsString` and `OsStr` bridge this gap by simultaneously representing Rust
-/// and platform-native string values, and in particular allowing a Rust string
-/// to be converted into an "OS" string with no cost.
-#[derive(Clone)]
-pub struct OsString {
-    inner: Wtf8Buf 
-}
-
-/// Slices into OS strings (see `OsString`).
-pub struct OsStr {
-    inner: Wtf8
-}
-
-impl OsString {
-    /// Constructs a new empty `OsString`.
-    pub fn new() -> OsString {
-        OsString { inner: Wtf8Buf::from_string(String::new()) }
-    }
-
-    fn _from_bytes(vec: Vec<u8>) -> Option<OsString> {
-        String::from_utf8(vec).ok().map(OsString::from)
-    }
-
-    /// Converts to an `OsStr` slice.
-    pub fn as_os_str(&self) -> &OsStr {
-        self
-    }
-
-    /// Converts the `OsString` into a `String` if it contains valid Unicode data.
-    ///
-    /// On failure, ownership of the original `OsString` is returned.
-    pub fn into_string(self) -> Result<String, OsString> {
-        self.inner.into_string().map_err(|buf| OsString { inner: buf} )
-    }
-
-    /// Extends the string with the given `&OsStr` slice.
-    pub fn push<T: AsRef<OsStr>>(&mut self, s: T) {
-        self.inner.push_wtf8(&s.as_ref().inner)
-    }
-
-    /// Creates a new `OsString` with the given capacity.
-    ///
-    /// The string will be able to hold exactly `capacity` lenth units of other
-    /// OS strings without reallocating. If `capacity` is 0, the string will not
-    /// allocate.
-    ///
-    /// See main `OsString` documentation information about encoding.
-    pub fn with_capacity(capacity: usize) -> OsString {
-        OsString {
-            inner: Wtf8Buf::with_capacity(capacity)
-        }
-    }
-
-    /// Truncates the `OsString` to zero length.
-    pub fn clear(&mut self) {
-        self.inner.clear()
-    }
-
-    /// Returns the capacity this `OsString` can hold without reallocating.
-    ///
-    /// See `OsString` introduction for information about encoding.
-    pub fn capacity(&self) -> usize {
-        self.inner.capacity()
-    }
-
-    /// Reserves capacity for at least `additional` more capacity to be inserted
-    /// in the given `OsString`.
-    ///
-    /// The collection may reserve more space to avoid frequent reallocations.
-    pub fn reserve(&mut self, additional: usize) {
-        self.inner.reserve(additional)
-    }
-
-    /// Reserves the minimum capacity for exactly `additional` more capacity to
-    /// be inserted in the given `OsString`. Does nothing if the capacity is
-    /// already sufficient.
-    ///
-    /// Note that the allocator may give the collection more space than it
-    /// requests. Therefore capacity can not be relied upon to be precisely
-    /// minimal. Prefer reserve if future insertions are expected.
-    pub fn reserve_exact(&mut self, additional: usize) {
-        self.inner.reserve_exact(additional)
-    }
-
-    /// Creates 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.
-    ///
-    /// NOTE: This function was copied from the windows implementation of OsStringExt
-    pub fn from_wide(wide: &[u16]) -> OsString {
-        OsString { inner: Wtf8Buf::from_wide(wide) }
-    }
-}
-
-impl From<String> for OsString {
-    fn from(s: String) -> OsString {
-        OsString { inner: Wtf8Buf::from_string(s) }
-    }
-}
-
-impl<'a, T: ?Sized + AsRef<OsStr>> From<&'a T> for OsString {
-    fn from(s: &'a T) -> OsString {
-        s.as_ref().to_os_string()
-    }
-}
-
-impl ops::Index<ops::RangeFull> for OsString {
-    type Output = OsStr;
-
-    #[inline]
-    fn index(&self, _index: ops::RangeFull) -> &OsStr {
-        OsStr::from_inner(self.inner.as_slice())
-    }
-}
-
-impl ops::Deref for OsString {
-    type Target = OsStr;
-
-    #[inline]
-    fn deref(&self) -> &OsStr {
-        &self[..]
-    }
-}
-
-impl Default for OsString {
-    #[inline]
-    fn default() -> OsString {
-        OsString::new()
-    }
-}
-
-impl Debug for OsString {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        fmt::Debug::fmt(&**self, formatter)
-    }
-}
-
-impl PartialEq for OsString {
-    fn eq(&self, other: &OsString) -> bool {
-        &**self == &**other
-    }
-}
-
-impl PartialEq<str> for OsString {
-    fn eq(&self, other: &str) -> bool {
-        &**self == other
-    }
-}
-
-impl PartialEq<OsString> for str {
-    fn eq(&self, other: &OsString) -> bool {
-        &**other == self
-    }
-}
-
-impl Eq for OsString {}
-
-impl PartialOrd for OsString {
-    #[inline]
-    fn partial_cmp(&self, other: &OsString) -> Option<cmp::Ordering> {
-        (&**self).partial_cmp(&**other)
-    }
-    #[inline]
-    fn lt(&self, other: &OsString) -> bool { &**self < &**other }
-    #[inline]
-    fn le(&self, other: &OsString) -> bool { &**self <= &**other }
-    #[inline]
-    fn gt(&self, other: &OsString) -> bool { &**self > &**other }
-    #[inline]
-    fn ge(&self, other: &OsString) -> bool { &**self >= &**other }
-}
-
-impl PartialOrd<str> for OsString {
-    #[inline]
-    fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> {
-        (&**self).partial_cmp(other)
-    }
-}
-
-impl Ord for OsString {
-    #[inline]
-    fn cmp(&self, other: &OsString) -> cmp::Ordering {
-        (&**self).cmp(&**other)
-    }
-}
-
-impl Hash for OsString {
-    #[inline]
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        (&**self).hash(state)
-    }
-}
-
-impl OsStr {
-    /// Coerces into an `OsStr` slice.
-    pub fn new<S: AsRef<OsStr> + ?Sized>(s: &S) -> &OsStr {
-        s.as_ref()
-    }
-
-    fn from_inner(inner: &Wtf8) -> &OsStr {
-        unsafe { mem::transmute(inner) }
-    }
-
-    /// Yields a `&str` slice if the `OsStr` is valid Unicode.
-    ///
-    /// This conversion may entail doing a check for UTF-8 validity.
-    pub fn to_str(&self) -> Option<&str> {
-        self.inner.as_str()
-    }
-
-    /// Converts an `OsStr` to a `Cow<str>`.
-    ///
-    /// Any non-Unicode sequences are replaced with U+FFFD REPLACEMENT CHARACTER.
-    pub fn to_string_lossy(&self) -> Cow<str> {
-        self.inner.to_string_lossy()
-    }
-
-    /// Copies the slice into an owned `OsString`.
-    pub fn to_os_string(&self) -> OsString {
-        let mut buf = Wtf8Buf::with_capacity(self.inner.len());
-        buf.push_wtf8(&self.inner);
-        OsString { inner: buf }
-    }
-
-    /// Checks whether the `OsStr` is empty.
-    pub fn is_empty(&self) -> bool {
-        self.inner.is_empty()
-    }
-
-    /// Returns the length of this `OsStr`.
-    ///
-    /// Note that this does **not** return the number of bytes in this string
-    /// as, for example, OS strings on Windows are encoded as a list of `u16`
-    /// rather than a list of bytes. This number is simply useful for passing to
-    /// other methods like `OsString::with_capacity` to avoid reallocations.
-    ///
-    /// See `OsStr` introduction for more information about encoding.
-    pub fn len(&self) -> usize {
-        self.inner.len()
-    }
-
-    /// Gets the underlying byte representation.
-    ///
-    /// Note: it is *crucial* that this API is private, to avoid
-    /// revealing the internal, platform-specific encodings.
-    fn bytes(&self) -> &[u8] {
-        unsafe { mem::transmute(&self.inner) }
-    }
-    
-    /// Re-encodes 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.
-    ///
-    /// NOTE: This function was copied from the windows implementation of OsStrExt
-    pub fn encode_wide(&self) -> EncodeWide {
-        self.inner.encode_wide()
-    }
-
-}
-
-impl<'a> Default for &'a OsStr {
-    #[inline]
-    fn default() -> &'a OsStr {
-        OsStr::new("")
-    }
-}
-
-impl PartialEq for OsStr {
-    fn eq(&self, other: &OsStr) -> bool {
-        self.bytes().eq(other.bytes())
-    }
-}
-
-impl PartialEq<str> for OsStr {
-    fn eq(&self, other: &str) -> bool {
-        *self == *OsStr::new(other)
-    }
-}
-
-impl PartialEq<OsStr> for str {
-    fn eq(&self, other: &OsStr) -> bool {
-        *other == *OsStr::new(self)
-    }
-}
-
-impl Eq for OsStr {}
-
-impl PartialOrd for OsStr {
-    #[inline]
-    fn partial_cmp(&self, other: &OsStr) -> Option<cmp::Ordering> {
-        self.bytes().partial_cmp(other.bytes())
-    }
-    #[inline]
-    fn lt(&self, other: &OsStr) -> bool { self.bytes().lt(other.bytes()) }
-    #[inline]
-    fn le(&self, other: &OsStr) -> bool { self.bytes().le(other.bytes()) }
-    #[inline]
-    fn gt(&self, other: &OsStr) -> bool { self.bytes().gt(other.bytes()) }
-    #[inline]
-    fn ge(&self, other: &OsStr) -> bool { self.bytes().ge(other.bytes()) }
-}
-
-impl PartialOrd<str> for OsStr {
-    #[inline]
-    fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> {
-        self.partial_cmp(OsStr::new(other))
-    }
-}
-
-// FIXME (#19470): cannot provide PartialOrd<OsStr> for str until we
-// have more flexible coherence rules.
-
-impl Ord for OsStr {
-    #[inline]
-    fn cmp(&self, other: &OsStr) -> cmp::Ordering { self.bytes().cmp(other.bytes()) }
-}
-
-macro_rules! impl_cmp {
-    ($lhs:ty, $rhs: ty) => {
-        impl<'a, 'b> PartialEq<$rhs> for $lhs {
-            #[inline]
-            fn eq(&self, other: &$rhs) -> bool { <OsStr as PartialEq>::eq(self, other) }
-        }
-
-        impl<'a, 'b> PartialEq<$lhs> for $rhs {
-            #[inline]
-            fn eq(&self, other: &$lhs) -> bool { <OsStr as PartialEq>::eq(self, other) }
-        }
-
-        impl<'a, 'b> PartialOrd<$rhs> for $lhs {
-            #[inline]
-            fn partial_cmp(&self, other: &$rhs) -> Option<cmp::Ordering> {
-                <OsStr as PartialOrd>::partial_cmp(self, other)
-            }
-        }
-
-        impl<'a, 'b> PartialOrd<$lhs> for $rhs {
-            #[inline]
-            fn partial_cmp(&self, other: &$lhs) -> Option<cmp::Ordering> {
-                <OsStr as PartialOrd>::partial_cmp(self, other)
-            }
-        }
-    }
-}
-
-impl_cmp!(OsString, OsStr);
-impl_cmp!(OsString, &'a OsStr);
-impl_cmp!(Cow<'a, OsStr>, OsStr);
-impl_cmp!(Cow<'a, OsStr>, &'b OsStr);
-impl_cmp!(Cow<'a, OsStr>, OsString);
-
-impl Hash for OsStr {
-    #[inline]
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.bytes().hash(state)
-    }
-}
-
-impl Debug for OsStr {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        self.inner.fmt(formatter)
-    }
-}
-
-impl Borrow<OsStr> for OsString {
-    fn borrow(&self) -> &OsStr { &self[..] }
-}
-
-impl ToOwned for OsStr {
-    type Owned = OsString;
-    fn to_owned(&self) -> OsString { self.to_os_string() }
-}
-
-impl AsRef<OsStr> for OsStr {
-    fn as_ref(&self) -> &OsStr {
-        self
-    }
-}
-
-impl AsRef<OsStr> for OsString {
-    fn as_ref(&self) -> &OsStr {
-        self
-    }
-}
-
-impl AsRef<OsStr> for str {
-    fn as_ref(&self) -> &OsStr {
-        OsStr::from_inner(Wtf8::from_str(self))
-    }
-}
-
-impl AsRef<OsStr> for String {
-    fn as_ref(&self) -> &OsStr {
-        (&**self).as_ref()
-    }
-}
-
-impl FromInner<Wtf8Buf> for OsString {
-    fn from_inner(buf: Wtf8Buf) -> OsString {
-        OsString { inner: buf }
-    }
-}
-
-impl IntoInner<Wtf8Buf> for OsString {
-    fn into_inner(self) -> Wtf8Buf {
-        self.inner
-    }
-}
-
-impl AsInner<Wtf8> for OsStr {
-    fn as_inner(&self) -> &Wtf8 {
-        &self.inner
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use sys::{AsInner, IntoInner};
-
-    #[test]
-    fn test_os_string_with_capacity() {
-        let os_string = OsString::with_capacity(0);
-        assert_eq!(0, os_string.inner.capacity());
-
-        let os_string = OsString::with_capacity(10);
-        assert_eq!(10, os_string.inner.capacity());
-
-        let mut os_string = OsString::with_capacity(0);
-        os_string.push("abc");
-        assert!(os_string.inner.capacity() >= 3);
-    }
-
-    #[test]
-    fn test_os_string_clear() {
-        let mut os_string = OsString::from("abc");
-        assert_eq!(3, os_string.inner.len());
-
-        os_string.clear();
-        assert_eq!(&os_string, "");
-        assert_eq!(0, os_string.inner.len());
-    }
-
-    #[test]
-    fn test_os_string_capacity() {
-        let os_string = OsString::with_capacity(0);
-        assert_eq!(0, os_string.capacity());
-
-        let os_string = OsString::with_capacity(10);
-        assert_eq!(10, os_string.capacity());
-
-        let mut os_string = OsString::with_capacity(0);
-        os_string.push("abc");
-        assert!(os_string.capacity() >= 3);
-    }
-
-    #[test]
-    fn test_os_string_reserve() {
-        let mut os_string = OsString::new();
-        assert_eq!(os_string.capacity(), 0);
-
-        os_string.reserve(2);
-        assert!(os_string.capacity() >= 2);
-
-        for _ in 0..16 {
-            os_string.push("a");
-        }
-
-        assert!(os_string.capacity() >= 16);
-        os_string.reserve(16);
-        assert!(os_string.capacity() >= 32);
-
-        os_string.push("a");
-
-        os_string.reserve(16);
-        assert!(os_string.capacity() >= 33)
-    }
-
-    #[test]
-    fn test_os_string_reserve_exact() {
-        let mut os_string = OsString::new();
-        assert_eq!(os_string.capacity(), 0);
-
-        os_string.reserve_exact(2);
-        assert!(os_string.capacity() >= 2);
-
-        for _ in 0..16 {
-            os_string.push("a");
-        }
-
-        assert!(os_string.capacity() >= 16);
-        os_string.reserve_exact(16);
-        assert!(os_string.capacity() >= 32);
-
-        os_string.push("a");
-
-        os_string.reserve_exact(16);
-        assert!(os_string.capacity() >= 33)
-    }
-
-    #[test]
-    fn test_os_string_default() {
-        let os_string: OsString = Default::default();
-        assert_eq!("", &os_string);
-    }
-
-    #[test]
-    fn test_os_str_is_empty() {
-        let mut os_string = OsString::new();
-        assert!(os_string.is_empty());
-
-        os_string.push("abc");
-        assert!(!os_string.is_empty());
-
-        os_string.clear();
-        assert!(os_string.is_empty());
-    }
-
-    #[test]
-    fn test_os_str_len() {
-        let mut os_string = OsString::new();
-        assert_eq!(0, os_string.len());
-
-        os_string.push("abc");
-        assert_eq!(3, os_string.len());
-
-        os_string.clear();
-        assert_eq!(0, os_string.len());
-    }
-
-    #[test]
-    fn test_os_str_default() {
-        let os_str: &OsStr = Default::default();
-        assert_eq!("", os_str);
-    }
-}
diff --git a/src/system/io/buffered.rs b/src/system/io/buffered.rs
deleted file mode 100644
index 22588fc..0000000
--- a/src/system/io/buffered.rs
+++ /dev/null
@@ -1,1117 +0,0 @@
-// Copyright 2013 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Buffering wrappers for I/O traits
-
-use std::io::prelude::*;
-
-use std::cmp;
-use std::error;
-use std::fmt;
-use std::io::{self, DEFAULT_BUF_SIZE, Error, ErrorKind, SeekFrom};
-use std::memchr;
-
-/// The `BufReader` struct adds buffering to any reader.
-///
-/// It can be excessively inefficient to work directly with a `Read` instance.
-/// For example, every call to `read` on `TcpStream` results in a system call.
-/// A `BufReader` performs large, infrequent reads on the underlying `Read`
-/// and maintains an in-memory buffer of the results.
-///
-/// # Examples
-///
-/// ```
-/// use std::io::prelude::*;
-/// use std::io::BufReader;
-/// use std::fs::File;
-///
-/// # fn foo() -> std::io::Result<()> {
-/// let mut f = try!(File::open("log.txt"));
-/// let mut reader = BufReader::new(f);
-///
-/// let mut line = String::new();
-/// let len = try!(reader.read_line(&mut line));
-/// println!("First line is {} bytes long", len);
-/// # Ok(())
-/// # }
-/// ```
-pub struct BufReader<R> {
-    inner: R,
-    buf: Box<[u8]>,
-    pos: usize,
-    cap: usize,
-}
-
-impl<R: Read> BufReader<R> {
-    /// Creates a new `BufReader` with a default buffer capacity.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::io::BufReader;
-    /// use std::fs::File;
-    ///
-    /// # fn foo() -> std::io::Result<()> {
-    /// let mut f = try!(File::open("log.txt"));
-    /// let mut reader = BufReader::new(f);
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn new(inner: R) -> BufReader<R> {
-        BufReader::with_capacity(DEFAULT_BUF_SIZE, inner)
-    }
-
-    /// Creates a new `BufReader` with the specified buffer capacity.
-    ///
-    /// # Examples
-    ///
-    /// Creating a buffer with ten bytes of capacity:
-    ///
-    /// ```
-    /// use std::io::BufReader;
-    /// use std::fs::File;
-    ///
-    /// # fn foo() -> std::io::Result<()> {
-    /// let mut f = try!(File::open("log.txt"));
-    /// let mut reader = BufReader::with_capacity(10, f);
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn with_capacity(cap: usize, inner: R) -> BufReader<R> {
-        BufReader {
-            inner: inner,
-            buf: vec![0; cap].into_boxed_slice(),
-            pos: 0,
-            cap: 0,
-        }
-    }
-
-    /// Gets a reference to the underlying reader.
-    ///
-    /// It is inadvisable to directly read from the underlying reader.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::io::BufReader;
-    /// use std::fs::File;
-    ///
-    /// # fn foo() -> std::io::Result<()> {
-    /// let mut f1 = try!(File::open("log.txt"));
-    /// let mut reader = BufReader::new(f1);
-    ///
-    /// let f2 = reader.get_ref();
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn get_ref(&self) -> &R { &self.inner }
-
-    /// Gets a mutable reference to the underlying reader.
-    ///
-    /// It is inadvisable to directly read from the underlying reader.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::io::BufReader;
-    /// use std::fs::File;
-    ///
-    /// # fn foo() -> std::io::Result<()> {
-    /// let mut f1 = try!(File::open("log.txt"));
-    /// let mut reader = BufReader::new(f1);
-    ///
-    /// let f2 = reader.get_mut();
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn get_mut(&mut self) -> &mut R { &mut self.inner }
-
-    /// Unwraps this `BufReader`, returning the underlying reader.
-    ///
-    /// Note that any leftover data in the internal buffer is lost.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::io::BufReader;
-    /// use std::fs::File;
-    ///
-    /// # fn foo() -> std::io::Result<()> {
-    /// let mut f1 = try!(File::open("log.txt"));
-    /// let mut reader = BufReader::new(f1);
-    ///
-    /// let f2 = reader.into_inner();
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn into_inner(self) -> R { self.inner }
-}
-
-impl<R: Read> Read for BufReader<R> {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        // If we don't have any buffered data and we're doing a massive read
-        // (larger than our internal buffer), bypass our internal buffer
-        // entirely.
-        if self.pos == self.cap && buf.len() >= self.buf.len() {
-            return self.inner.read(buf);
-        }
-        let nread = {
-            let mut rem = self.fill_buf()?;
-            rem.read(buf)?
-        };
-        self.consume(nread);
-        Ok(nread)
-    }
-}
-
-impl<R: Read> BufRead for BufReader<R> {
-    fn fill_buf(&mut self) -> io::Result<&[u8]> {
-        // If we've reached the end of our internal buffer then we need to fetch
-        // some more data from the underlying reader.
-        if self.pos == self.cap {
-            self.cap = self.inner.read(&mut self.buf)?;
-            self.pos = 0;
-        }
-        Ok(&self.buf[self.pos..self.cap])
-    }
-
-    fn consume(&mut self, amt: usize) {
-        self.pos = cmp::min(self.pos + amt, self.cap);
-    }
-}
-
-impl<R> fmt::Debug for BufReader<R> where R: fmt::Debug {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("BufReader")
-            .field("reader", &self.inner)
-            .field("buffer", &format_args!("{}/{}", self.cap - self.pos, self.buf.len()))
-            .finish()
-    }
-}
-
-impl<R: Seek> Seek for BufReader<R> {
-    /// Seek to an offset, in bytes, in the underlying reader.
-    ///
-    /// The position used for seeking with `SeekFrom::Current(_)` is the
-    /// position the underlying reader would be at if the `BufReader` had no
-    /// internal buffer.
-    ///
-    /// Seeking always discards the internal buffer, even if the seek position
-    /// would otherwise fall within it. This guarantees that calling
-    /// `.unwrap()` immediately after a seek yields the underlying reader at
-    /// the same position.
-    ///
-    /// See `std::io::Seek` for more details.
-    ///
-    /// Note: In the edge case where you're seeking with `SeekFrom::Current(n)`
-    /// where `n` minus the internal buffer length underflows an `i64`, two
-    /// seeks will be performed instead of one. If the second seek returns
-    /// `Err`, the underlying reader will be left at the same position it would
-    /// have if you seeked to `SeekFrom::Current(0)`.
-    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
-        let result: u64;
-        if let SeekFrom::Current(n) = pos {
-            let remainder = (self.cap - self.pos) as i64;
-            // it should be safe to assume that remainder fits within an i64 as the alternative
-            // means we managed to allocate 8 ebibytes and that's absurd.
-            // But it's not out of the realm of possibility for some weird underlying reader to
-            // support seeking by i64::min_value() so we need to handle underflow when subtracting
-            // remainder.
-            if let Some(offset) = n.checked_sub(remainder) {
-                result = self.inner.seek(SeekFrom::Current(offset))?;
-            } else {
-                // seek backwards by our remainder, and then by the offset
-                self.inner.seek(SeekFrom::Current(-remainder))?;
-                self.pos = self.cap; // empty the buffer
-                result = self.inner.seek(SeekFrom::Current(n))?;
-            }
-        } else {
-            // Seeking with Start/End doesn't care about our buffer length.
-            result = self.inner.seek(pos)?;
-        }
-        self.pos = self.cap; // empty the buffer
-        Ok(result)
-    }
-}
-
-/// Wraps a writer and buffers its output.
-///
-/// It can be excessively inefficient to work directly with something that
-/// implements `Write`. For example, every call to `write` on `TcpStream`
-/// results in a system call. A `BufWriter` keeps an in-memory buffer of data
-/// and writes it to an underlying writer in large, infrequent batches.
-///
-/// The buffer will be written out when the writer is dropped.
-///
-/// # Examples
-///
-/// Let's write the numbers one through ten to a `TcpStream`:
-///
-/// ```no_run
-/// use std::io::prelude::*;
-/// use std::net::TcpStream;
-///
-/// let mut stream = TcpStream::connect("127.0.0.1:34254").unwrap();
-///
-/// for i in 1..10 {
-///     stream.write(&[i]).unwrap();
-/// }
-/// ```
-///
-/// Because we're not buffering, we write each one in turn, incurring the
-/// overhead of a system call per byte written. We can fix this with a
-/// `BufWriter`:
-///
-/// ```no_run
-/// use std::io::prelude::*;
-/// use std::io::BufWriter;
-/// use std::net::TcpStream;
-///
-/// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
-///
-/// for i in 1..10 {
-///     stream.write(&[i]).unwrap();
-/// }
-/// ```
-///
-/// By wrapping the stream with a `BufWriter`, these ten writes are all grouped
-/// together by the buffer, and will all be written out in one system call when
-/// the `stream` is dropped.
-pub struct BufWriter<W: Write> {
-    inner: Option<W>,
-    buf: Vec<u8>,
-    // #30888: If the inner writer panics in a call to write, we don't want to
-    // write the buffered data a second time in BufWriter's destructor. This
-    // flag tells the Drop impl if it should skip the flush.
-    panicked: bool,
-}
-
-/// An error returned by `into_inner` which combines an error that
-/// happened while writing out the buffer, and the buffered writer object
-/// which may be used to recover from the condition.
-///
-/// # Examples
-///
-/// ```no_run
-/// use std::io::BufWriter;
-/// use std::net::TcpStream;
-///
-/// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
-///
-/// // do stuff with the stream
-///
-/// // we want to get our `TcpStream` back, so let's try:
-///
-/// let stream = match stream.into_inner() {
-///     Ok(s) => s,
-///     Err(e) => {
-///         // Here, e is an IntoInnerError
-///         panic!("An error occurred");
-///     }
-/// };
-/// ```
-#[derive(Debug)]
-pub struct IntoInnerError<W>(W, Error);
-
-impl<W: Write> BufWriter<W> {
-    /// Creates a new `BufWriter` with a default buffer capacity.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::io::BufWriter;
-    /// use std::net::TcpStream;
-    ///
-    /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
-    /// ```
-    pub fn new(inner: W) -> BufWriter<W> {
-        BufWriter::with_capacity(DEFAULT_BUF_SIZE, inner)
-    }
-
-    /// Creates a new `BufWriter` with the specified buffer capacity.
-    ///
-    /// # Examples
-    ///
-    /// Creating a buffer with a buffer of a hundred bytes.
-    ///
-    /// ```no_run
-    /// use std::io::BufWriter;
-    /// use std::net::TcpStream;
-    ///
-    /// let stream = TcpStream::connect("127.0.0.1:34254").unwrap();
-    /// let mut buffer = BufWriter::with_capacity(100, stream);
-    /// ```
-    pub fn with_capacity(cap: usize, inner: W) -> BufWriter<W> {
-        BufWriter {
-            inner: Some(inner),
-            buf: Vec::with_capacity(cap),
-            panicked: false,
-        }
-    }
-
-    fn flush_buf(&mut self) -> io::Result<()> {
-        let mut written = 0;
-        let len = self.buf.len();
-        let mut ret = Ok(());
-        while written < len {
-            self.panicked = true;
-            let r = self.inner.as_mut().unwrap().write(&self.buf[written..]);
-            self.panicked = false;
-
-            match r {
-                Ok(0) => {
-                    ret = Err(Error::new(ErrorKind::WriteZero,
-                                         "failed to write the buffered data"));
-                    break;
-                }
-                Ok(n) => written += n,
-                Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
-                Err(e) => { ret = Err(e); break }
-
-            }
-        }
-        if written > 0 {
-            self.buf.drain(..written);
-        }
-        ret
-    }
-
-    /// Gets a reference to the underlying writer.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::io::BufWriter;
-    /// use std::net::TcpStream;
-    ///
-    /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
-    ///
-    /// // we can use reference just like buffer
-    /// let reference = buffer.get_ref();
-    /// ```
-    pub fn get_ref(&self) -> &W { self.inner.as_ref().unwrap() }
-
-    /// Gets a mutable reference to the underlying writer.
-    ///
-    /// It is inadvisable to directly write to the underlying writer.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::io::BufWriter;
-    /// use std::net::TcpStream;
-    ///
-    /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
-    ///
-    /// // we can use reference just like buffer
-    /// let reference = buffer.get_mut();
-    /// ```
-    pub fn get_mut(&mut self) -> &mut W { self.inner.as_mut().unwrap() }
-
-    /// Unwraps this `BufWriter`, returning the underlying writer.
-    ///
-    /// The buffer is written out before returning the writer.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::io::BufWriter;
-    /// use std::net::TcpStream;
-    ///
-    /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
-    ///
-    /// // unwrap the TcpStream and flush the buffer
-    /// let stream = buffer.into_inner().unwrap();
-    /// ```
-    pub fn into_inner(mut self) -> Result<W, IntoInnerError<BufWriter<W>>> {
-        match self.flush_buf() {
-            Err(e) => Err(IntoInnerError(self, e)),
-            Ok(()) => Ok(self.inner.take().unwrap())
-        }
-    }
-}
-
-impl<W: Write> Write for BufWriter<W> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        if self.buf.len() + buf.len() > self.buf.capacity() {
-            self.flush_buf()?;
-        }
-        if buf.len() >= self.buf.capacity() {
-            self.panicked = true;
-            let r = self.inner.as_mut().unwrap().write(buf);
-            self.panicked = false;
-            r
-        } else {
-            let amt = cmp::min(buf.len(), self.buf.capacity());
-            Write::write(&mut self.buf, &buf[..amt])
-        }
-    }
-    fn flush(&mut self) -> io::Result<()> {
-        self.flush_buf().and_then(|()| self.get_mut().flush())
-    }
-}
-
-impl<W: Write> fmt::Debug for BufWriter<W> where W: fmt::Debug {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("BufWriter")
-            .field("writer", &self.inner.as_ref().unwrap())
-            .field("buffer", &format_args!("{}/{}", self.buf.len(), self.buf.capacity()))
-            .finish()
-    }
-}
-
-impl<W: Write + Seek> Seek for BufWriter<W> {
-    /// Seek to the offset, in bytes, in the underlying writer.
-    ///
-    /// Seeking always writes out the internal buffer before seeking.
-    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
-        self.flush_buf().and_then(|_| self.get_mut().seek(pos))
-    }
-}
-
-impl<W: Write> Drop for BufWriter<W> {
-    fn drop(&mut self) {
-        if self.inner.is_some() && !self.panicked {
-            // dtors should not panic, so we ignore a failed flush
-            let _r = self.flush_buf();
-        }
-    }
-}
-
-impl<W> IntoInnerError<W> {
-    /// Returns the error which caused the call to `into_inner()` to fail.
-    ///
-    /// This error was returned when attempting to write the internal buffer.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::io::BufWriter;
-    /// use std::net::TcpStream;
-    ///
-    /// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
-    ///
-    /// // do stuff with the stream
-    ///
-    /// // we want to get our `TcpStream` back, so let's try:
-    ///
-    /// let stream = match stream.into_inner() {
-    ///     Ok(s) => s,
-    ///     Err(e) => {
-    ///         // Here, e is an IntoInnerError, let's log the inner error.
-    ///         //
-    ///         // We'll just 'log' to stdout for this example.
-    ///         println!("{}", e.error());
-    ///
-    ///         panic!("An unexpected error occurred.");
-    ///     }
-    /// };
-    /// ```
-    pub fn error(&self) -> &Error { &self.1 }
-
-    /// Returns the buffered writer instance which generated the error.
-    ///
-    /// The returned object can be used for error recovery, such as
-    /// re-inspecting the buffer.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::io::BufWriter;
-    /// use std::net::TcpStream;
-    ///
-    /// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
-    ///
-    /// // do stuff with the stream
-    ///
-    /// // we want to get our `TcpStream` back, so let's try:
-    ///
-    /// let stream = match stream.into_inner() {
-    ///     Ok(s) => s,
-    ///     Err(e) => {
-    ///         // Here, e is an IntoInnerError, let's re-examine the buffer:
-    ///         let buffer = e.into_inner();
-    ///
-    ///         // do stuff to try to recover
-    ///
-    ///         // afterwards, let's just return the stream
-    ///         buffer.into_inner().unwrap()
-    ///     }
-    /// };
-    /// ```
-    pub fn into_inner(self) -> W { self.0 }
-}
-
-impl<W> From<IntoInnerError<W>> for Error {
-    fn from(iie: IntoInnerError<W>) -> Error { iie.1 }
-}
-
-impl<W: Send + fmt::Debug> error::Error for IntoInnerError<W> {
-    fn description(&self) -> &str {
-        error::Error::description(self.error())
-    }
-}
-
-impl<W> fmt::Display for IntoInnerError<W> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.error().fmt(f)
-    }
-}
-
-/// Wraps a writer and buffers output to it, flushing whenever a newline
-/// (`0x0a`, `'\n'`) is detected.
-///
-/// The [`BufWriter`][bufwriter] struct wraps a writer and buffers its output.
-/// But it only does this batched write when it goes out of scope, or when the
-/// internal buffer is full. Sometimes, you'd prefer to write each line as it's
-/// completed, rather than the entire buffer at once. Enter `LineWriter`. It
-/// does exactly that.
-///
-/// [bufwriter]: struct.BufWriter.html
-///
-/// If there's still a partial line in the buffer when the `LineWriter` is
-/// dropped, it will flush those contents.
-///
-/// # Examples
-///
-/// We can use `LineWriter` to write one line at a time, significantly
-/// reducing the number of actual writes to the file.
-///
-/// ```
-/// use std::fs::File;
-/// use std::io::prelude::*;
-/// use std::io::LineWriter;
-///
-/// # fn foo() -> std::io::Result<()> {
-/// let road_not_taken = b"I shall be telling this with a sigh
-/// Somewhere ages and ages hence:
-/// Two roads diverged in a wood, and I -
-/// I took the one less traveled by,
-/// And that has made all the difference.";
-///
-/// let file = try!(File::create("poem.txt"));
-/// let mut file = LineWriter::new(file);
-///
-/// for &byte in road_not_taken.iter() {
-///    file.write(&[byte]).unwrap();
-/// }
-///
-/// // let's check we did the right thing.
-/// let mut file = try!(File::open("poem.txt"));
-/// let mut contents = String::new();
-///
-/// try!(file.read_to_string(&mut contents));
-///
-/// assert_eq!(contents.as_bytes(), &road_not_taken[..]);
-/// # Ok(())
-/// # }
-/// ```
-pub struct LineWriter<W: Write> {
-    inner: BufWriter<W>,
-}
-
-impl<W: Write> LineWriter<W> {
-    /// Creates a new `LineWriter`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::fs::File;
-    /// use std::io::LineWriter;
-    ///
-    /// # fn foo() -> std::io::Result<()> {
-    /// let file = try!(File::create("poem.txt"));
-    /// let file = LineWriter::new(file);
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn new(inner: W) -> LineWriter<W> {
-        // Lines typically aren't that long, don't use a giant buffer
-        LineWriter::with_capacity(1024, inner)
-    }
-
-    /// Creates a new `LineWriter` with a specified capacity for the internal
-    /// buffer.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::fs::File;
-    /// use std::io::LineWriter;
-    ///
-    /// # fn foo() -> std::io::Result<()> {
-    /// let file = try!(File::create("poem.txt"));
-    /// let file = LineWriter::with_capacity(100, file);
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn with_capacity(cap: usize, inner: W) -> LineWriter<W> {
-        LineWriter { inner: BufWriter::with_capacity(cap, inner) }
-    }
-
-    /// Gets a reference to the underlying writer.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::fs::File;
-    /// use std::io::LineWriter;
-    ///
-    /// # fn foo() -> std::io::Result<()> {
-    /// let file = try!(File::create("poem.txt"));
-    /// let file = LineWriter::new(file);
-    ///
-    /// let reference = file.get_ref();
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn get_ref(&self) -> &W { self.inner.get_ref() }
-
-    /// Gets a mutable reference to the underlying writer.
-    ///
-    /// Caution must be taken when calling methods on the mutable reference
-    /// returned as extra writes could corrupt the output stream.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::fs::File;
-    /// use std::io::LineWriter;
-    ///
-    /// # fn foo() -> std::io::Result<()> {
-    /// let file = try!(File::create("poem.txt"));
-    /// let mut file = LineWriter::new(file);
-    ///
-    /// // we can use reference just like file
-    /// let reference = file.get_mut();
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn get_mut(&mut self) -> &mut W { self.inner.get_mut() }
-
-    /// Unwraps this `LineWriter`, returning the underlying writer.
-    ///
-    /// The internal buffer is written out before returning the writer.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::fs::File;
-    /// use std::io::LineWriter;
-    ///
-    /// # fn foo() -> std::io::Result<()> {
-    /// let file = try!(File::create("poem.txt"));
-    ///
-    /// let writer: LineWriter<File> = LineWriter::new(file);
-    ///
-    /// let file: File = try!(writer.into_inner());
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn into_inner(self) -> Result<W, IntoInnerError<LineWriter<W>>> {
-        self.inner.into_inner().map_err(|IntoInnerError(buf, e)| {
-            IntoInnerError(LineWriter { inner: buf }, e)
-        })
-    }
-}
-
-impl<W: Write> Write for LineWriter<W> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        match memchr::memrchr(b'\n', buf) {
-            Some(i) => {
-                let n = self.inner.write(&buf[..i + 1])?;
-                if n != i + 1 || self.inner.flush().is_err() {
-                    // Do not return errors on partial writes.
-                    return Ok(n);
-                }
-                self.inner.write(&buf[i + 1..]).map(|i| n + i)
-            }
-            None => self.inner.write(buf),
-        }
-    }
-
-    fn flush(&mut self) -> io::Result<()> { self.inner.flush() }
-}
-
-impl<W: Write> fmt::Debug for LineWriter<W> where W: fmt::Debug {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("LineWriter")
-            .field("writer", &self.inner.inner)
-            .field("buffer",
-                   &format_args!("{}/{}", self.inner.buf.len(), self.inner.buf.capacity()))
-            .finish()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use io::prelude::*;
-    use io::{self, BufReader, BufWriter, LineWriter, SeekFrom};
-    //use sync::atomic::{AtomicUsize, Ordering};
-    //use thread;
-    use test;
-
-    use collections::{Vec, String};
-    use collections::string::ToString;
-
-    /// A dummy reader intended at testing short-reads propagation.
-    pub struct ShortReader {
-        lengths: Vec<usize>,
-    }
-
-    impl Read for ShortReader {
-        fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
-            if self.lengths.is_empty() {
-                Ok(0)
-            } else {
-                Ok(self.lengths.remove(0))
-            }
-        }
-    }
-
-    #[test]
-    fn test_buffered_reader() {
-        let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
-        let mut reader = BufReader::with_capacity(2, inner);
-
-        let mut buf = [0, 0, 0];
-        let nread = reader.read(&mut buf);
-        assert_eq!(nread.unwrap(), 3);
-        let b: &[_] = &[5, 6, 7];
-        assert_eq!(buf, b);
-
-        let mut buf = [0, 0];
-        let nread = reader.read(&mut buf);
-        assert_eq!(nread.unwrap(), 2);
-        let b: &[_] = &[0, 1];
-        assert_eq!(buf, b);
-
-        let mut buf = [0];
-        let nread = reader.read(&mut buf);
-        assert_eq!(nread.unwrap(), 1);
-        let b: &[_] = &[2];
-        assert_eq!(buf, b);
-
-        let mut buf = [0, 0, 0];
-        let nread = reader.read(&mut buf);
-        assert_eq!(nread.unwrap(), 1);
-        let b: &[_] = &[3, 0, 0];
-        assert_eq!(buf, b);
-
-        let nread = reader.read(&mut buf);
-        assert_eq!(nread.unwrap(), 1);
-        let b: &[_] = &[4, 0, 0];
-        assert_eq!(buf, b);
-
-        assert_eq!(reader.read(&mut buf).unwrap(), 0);
-    }
-
-    #[test]
-    fn test_buffered_reader_seek() {
-        let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
-        let mut reader = BufReader::with_capacity(2, io::Cursor::new(inner));
-
-        assert_eq!(reader.seek(SeekFrom::Start(3)).ok(), Some(3));
-        assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));
-        assert_eq!(reader.seek(SeekFrom::Current(0)).ok(), Some(3));
-        assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));
-        assert_eq!(reader.seek(SeekFrom::Current(1)).ok(), Some(4));
-        assert_eq!(reader.fill_buf().ok(), Some(&[1, 2][..]));
-        reader.consume(1);
-        assert_eq!(reader.seek(SeekFrom::Current(-2)).ok(), Some(3));
-    }
-
-    #[test]
-    fn test_buffered_reader_seek_underflow() {
-        // gimmick reader that yields its position modulo 256 for each byte
-        struct PositionReader {
-            pos: u64
-        }
-        impl Read for PositionReader {
-            fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-                let len = buf.len();
-                for x in buf {
-                    *x = self.pos as u8;
-                    self.pos = self.pos.wrapping_add(1);
-                }
-                Ok(len)
-            }
-        }
-        impl Seek for PositionReader {
-            fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
-                match pos {
-                    SeekFrom::Start(n) => {
-                        self.pos = n;
-                    }
-                    SeekFrom::Current(n) => {
-                        self.pos = self.pos.wrapping_add(n as u64);
-                    }
-                    SeekFrom::End(n) => {
-                        self.pos = u64::max_value().wrapping_add(n as u64);
-                    }
-                }
-                Ok(self.pos)
-            }
-        }
-
-        let mut reader = BufReader::with_capacity(5, PositionReader { pos: 0 });
-        assert_eq!(reader.fill_buf().ok(), Some(&[0, 1, 2, 3, 4][..]));
-        assert_eq!(reader.seek(SeekFrom::End(-5)).ok(), Some(u64::max_value()-5));
-        assert_eq!(reader.fill_buf().ok().map(|s| s.len()), Some(5));
-        // the following seek will require two underlying seeks
-        let expected = 9223372036854775802;
-        assert_eq!(reader.seek(SeekFrom::Current(i64::min_value())).ok(), Some(expected));
-        assert_eq!(reader.fill_buf().ok().map(|s| s.len()), Some(5));
-        // seeking to 0 should empty the buffer.
-        assert_eq!(reader.seek(SeekFrom::Current(0)).ok(), Some(expected));
-        assert_eq!(reader.get_ref().pos, expected);
-    }
-
-    #[test]
-    fn test_buffered_writer() {
-        let inner = Vec::new();
-        let mut writer = BufWriter::with_capacity(2, inner);
-
-        writer.write(&[0, 1]).unwrap();
-        assert_eq!(*writer.get_ref(), [0, 1]);
-
-        writer.write(&[2]).unwrap();
-        assert_eq!(*writer.get_ref(), [0, 1]);
-
-        writer.write(&[3]).unwrap();
-        assert_eq!(*writer.get_ref(), [0, 1]);
-
-        writer.flush().unwrap();
-        assert_eq!(*writer.get_ref(), [0, 1, 2, 3]);
-
-        writer.write(&[4]).unwrap();
-        writer.write(&[5]).unwrap();
-        assert_eq!(*writer.get_ref(), [0, 1, 2, 3]);
-
-        writer.write(&[6]).unwrap();
-        assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5]);
-
-        writer.write(&[7, 8]).unwrap();
-        assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8]);
-
-        writer.write(&[9, 10, 11]).unwrap();
-        assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
-
-        writer.flush().unwrap();
-        assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
-    }
-
-    #[test]
-    fn test_buffered_writer_inner_flushes() {
-        let mut w = BufWriter::with_capacity(3, Vec::new());
-        w.write(&[0, 1]).unwrap();
-        assert_eq!(*w.get_ref(), []);
-        let w = w.into_inner().unwrap();
-        assert_eq!(w, [0, 1]);
-    }
-
-    #[test]
-    fn test_buffered_writer_seek() {
-        let mut w = BufWriter::with_capacity(3, io::Cursor::new(Vec::new()));
-        w.write_all(&[0, 1, 2, 3, 4, 5]).unwrap();
-        w.write_all(&[6, 7]).unwrap();
-        assert_eq!(w.seek(SeekFrom::Current(0)).ok(), Some(8));
-        assert_eq!(&w.get_ref().get_ref()[..], &[0, 1, 2, 3, 4, 5, 6, 7][..]);
-        assert_eq!(w.seek(SeekFrom::Start(2)).ok(), Some(2));
-        w.write_all(&[8, 9]).unwrap();
-        assert_eq!(&w.into_inner().unwrap().into_inner()[..], &[0, 1, 8, 9, 4, 5, 6, 7]);
-    }
-
-    #[test]
-    fn test_read_until() {
-        let inner: &[u8] = &[0, 1, 2, 1, 0];
-        let mut reader = BufReader::with_capacity(2, inner);
-        let mut v = Vec::new();
-        reader.read_until(0, &mut v).unwrap();
-        assert_eq!(v, [0]);
-        v.truncate(0);
-        reader.read_until(2, &mut v).unwrap();
-        assert_eq!(v, [1, 2]);
-        v.truncate(0);
-        reader.read_until(1, &mut v).unwrap();
-        assert_eq!(v, [1]);
-        v.truncate(0);
-        reader.read_until(8, &mut v).unwrap();
-        assert_eq!(v, [0]);
-        v.truncate(0);
-        reader.read_until(9, &mut v).unwrap();
-        assert_eq!(v, []);
-    }
-
-    #[test]
-    fn test_line_buffer_fail_flush() {
-        // Issue #32085
-        struct FailFlushWriter<'a>(&'a mut Vec<u8>);
-
-        impl<'a> Write for FailFlushWriter<'a> {
-            fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-                self.0.extend_from_slice(buf);
-                Ok(buf.len())
-            }
-            fn flush(&mut self) -> io::Result<()> {
-                Err(io::Error::new(io::ErrorKind::Other, "flush failed"))
-            }
-        }
-
-        let mut buf = Vec::new();
-        {
-            let mut writer = LineWriter::new(FailFlushWriter(&mut buf));
-            let to_write = b"abc\ndef";
-            if let Ok(written) = writer.write(to_write) {
-                assert!(written < to_write.len(), "didn't flush on new line");
-                // PASS
-                return;
-            }
-        }
-        assert!(buf.is_empty(), "write returned an error but wrote data");
-    }
-
-    #[test]
-    fn test_line_buffer() {
-        let mut writer = LineWriter::new(Vec::new());
-        writer.write(&[0]).unwrap();
-        assert_eq!(*writer.get_ref(), []);
-        writer.write(&[1]).unwrap();
-        assert_eq!(*writer.get_ref(), []);
-        writer.flush().unwrap();
-        assert_eq!(*writer.get_ref(), [0, 1]);
-        writer.write(&[0, b'\n', 1, b'\n', 2]).unwrap();
-        assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n']);
-        writer.flush().unwrap();
-        assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n', 2]);
-        writer.write(&[3, b'\n']).unwrap();
-        assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n', 2, 3, b'\n']);
-    }
-
-    #[test]
-    fn test_read_line() {
-        let in_buf: &[u8] = b"a\nb\nc";
-        let mut reader = BufReader::with_capacity(2, in_buf);
-        let mut s = String::new();
-        reader.read_line(&mut s).unwrap();
-        assert_eq!(s, "a\n");
-        s.truncate(0);
-        reader.read_line(&mut s).unwrap();
-        assert_eq!(s, "b\n");
-        s.truncate(0);
-        reader.read_line(&mut s).unwrap();
-        assert_eq!(s, "c");
-        s.truncate(0);
-        reader.read_line(&mut s).unwrap();
-        assert_eq!(s, "");
-    }
-
-    #[test]
-    fn test_lines() {
-        let in_buf: &[u8] = b"a\nb\nc";
-        let reader = BufReader::with_capacity(2, in_buf);
-        let mut it = reader.lines();
-        assert_eq!(it.next().unwrap().unwrap(), "a".to_string());
-        assert_eq!(it.next().unwrap().unwrap(), "b".to_string());
-        assert_eq!(it.next().unwrap().unwrap(), "c".to_string());
-        assert!(it.next().is_none());
-    }
-
-    #[test]
-    fn test_short_reads() {
-        let inner = ShortReader{lengths: vec![0, 1, 2, 0, 1, 0]};
-        let mut reader = BufReader::new(inner);
-        let mut buf = [0, 0];
-        assert_eq!(reader.read(&mut buf).unwrap(), 0);
-        assert_eq!(reader.read(&mut buf).unwrap(), 1);
-        assert_eq!(reader.read(&mut buf).unwrap(), 2);
-        assert_eq!(reader.read(&mut buf).unwrap(), 0);
-        assert_eq!(reader.read(&mut buf).unwrap(), 1);
-        assert_eq!(reader.read(&mut buf).unwrap(), 0);
-        assert_eq!(reader.read(&mut buf).unwrap(), 0);
-    }
-
-    #[test]
-    fn read_char_buffered() {
-        let buf = [195, 159];
-        let reader = BufReader::with_capacity(1, &buf[..]);
-        assert_eq!(reader.chars().next().unwrap().unwrap(), 'ß');
-    }
-
-    #[test]
-    fn test_chars() {
-        let buf = [195, 159, b'a'];
-        let reader = BufReader::with_capacity(1, &buf[..]);
-        let mut it = reader.chars();
-        assert_eq!(it.next().unwrap().unwrap(), 'ß');
-        assert_eq!(it.next().unwrap().unwrap(), 'a');
-        assert!(it.next().is_none());
-    }
-
-    #[test]
-    #[should_panic]
-    fn dont_panic_in_drop_on_panicked_flush() {
-        struct FailFlushWriter;
-
-        impl Write for FailFlushWriter {
-            fn write(&mut self, buf: &[u8]) -> io::Result<usize> { Ok(buf.len()) }
-            fn flush(&mut self) -> io::Result<()> {
-                Err(io::Error::last_os_error())
-            }
-        }
-
-        let writer = FailFlushWriter;
-        let _writer = BufWriter::new(writer);
-
-        // If writer panics *again* due to the flush error then the process will
-        // abort.
-        panic!();
-    }
-
-    // NOTE: These tests are for threading stuff that is not yet implemented
-    /*
-    #[test]
-    fn panic_in_write_doesnt_flush_in_drop() {
-        static WRITES: AtomicUsize = AtomicUsize::new(0);
-
-        struct PanicWriter;
-
-        impl Write for PanicWriter {
-            fn write(&mut self, _: &[u8]) -> io::Result<usize> {
-                WRITES.fetch_add(1, Ordering::SeqCst);
-                panic!();
-            }
-            fn flush(&mut self) -> io::Result<()> { Ok(()) }
-        }
-
-        thread::spawn(|| {
-            let mut writer = BufWriter::new(PanicWriter);
-            let _ = writer.write(b"hello world");
-            let _ = writer.flush();
-        }).join().unwrap_err();
-
-        assert_eq!(WRITES.load(Ordering::SeqCst), 1);
-    }
-
-    #[bench]
-    fn bench_buffered_reader(b: &mut test::Bencher) {
-        b.iter(|| {
-            BufReader::new(io::empty())
-        });
-    }
-
-    #[bench]
-    fn bench_buffered_writer(b: &mut test::Bencher) {
-        b.iter(|| {
-            BufWriter::new(io::sink())
-        });
-    }
-    */
-}
diff --git a/src/system/io/cursor.rs b/src/system/io/cursor.rs
deleted file mode 100644
index 99d4115..0000000
--- a/src/system/io/cursor.rs
+++ /dev/null
@@ -1,572 +0,0 @@
-// 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::io::prelude::*;
-
-use std::cmp;
-use std::io::{self, SeekFrom, Error, ErrorKind};
-
-/// A `Cursor` wraps another type and provides it with a
-/// [`Seek`](trait.Seek.html) implementation.
-///
-/// Cursors are typically used with in-memory buffers to allow them to
-/// implement `Read` and/or `Write`, allowing these buffers to be used
-/// anywhere you might use a reader or writer that does actual I/O.
-///
-/// The standard library implements some I/O traits on various types which
-/// are commonly used as a buffer, like `Cursor<Vec<u8>>` and `Cursor<&[u8]>`.
-///
-/// # Examples
-///
-/// We may want to write bytes to a [`File`][file] in our production
-/// code, but use an in-memory buffer in our tests. We can do this with
-/// `Cursor`:
-///
-/// [file]: ../fs/struct.File.html
-///
-/// ```no_run
-/// use std::io::prelude::*;
-/// use std::io::{self, SeekFrom};
-/// use std::fs::File;
-///
-/// // a library function we've written
-/// fn write_ten_bytes_at_end<W: Write + Seek>(writer: &mut W) -> io::Result<()> {
-///     try!(writer.seek(SeekFrom::End(-10)));
-///
-///     for i in 0..10 {
-///         try!(writer.write(&[i]));
-///     }
-///
-///     // all went well
-///     Ok(())
-/// }
-///
-/// # fn foo() -> io::Result<()> {
-/// // Here's some code that uses this library function.
-/// //
-/// // We might want to use a BufReader here for efficiency, but let's
-/// // keep this example focused.
-/// let mut file = try!(File::create("foo.txt"));
-///
-/// try!(write_ten_bytes_at_end(&mut file));
-/// # Ok(())
-/// # }
-///
-/// // now let's write a test
-/// #[test]
-/// fn test_writes_bytes() {
-///     // setting up a real File is much more slow than an in-memory buffer,
-///     // let's use a cursor instead
-///     use std::io::Cursor;
-///     let mut buff = Cursor::new(vec![0; 15]);
-///
-///     write_ten_bytes_at_end(&mut buff).unwrap();
-///
-///     assert_eq!(&buff.get_ref()[5..15], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
-/// }
-/// ```
-#[derive(Clone, Debug)]
-pub struct Cursor<T> {
-    inner: T,
-    pos: u64,
-}
-
-impl<T> Cursor<T> {
-    /// Creates a new cursor wrapping the provided underlying I/O object.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::io::Cursor;
-    ///
-    /// let buff = Cursor::new(Vec::new());
-    /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
-    /// # force_inference(&buff);
-    /// ```
-    pub fn new(inner: T) -> Cursor<T> {
-        Cursor { pos: 0, inner: inner }
-    }
-
-    /// Consumes this cursor, returning the underlying value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::io::Cursor;
-    ///
-    /// let buff = Cursor::new(Vec::new());
-    /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
-    /// # force_inference(&buff);
-    ///
-    /// let vec = buff.into_inner();
-    /// ```
-    pub fn into_inner(self) -> T { self.inner }
-
-    /// Gets a reference to the underlying value in this cursor.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::io::Cursor;
-    ///
-    /// let buff = Cursor::new(Vec::new());
-    /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
-    /// # force_inference(&buff);
-    ///
-    /// let reference = buff.get_ref();
-    /// ```
-    pub fn get_ref(&self) -> &T { &self.inner }
-
-    /// Gets a mutable reference to the underlying value in this cursor.
-    ///
-    /// Care should be taken to avoid modifying the internal I/O state of the
-    /// underlying value as it may corrupt this cursor's position.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::io::Cursor;
-    ///
-    /// let mut buff = Cursor::new(Vec::new());
-    /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
-    /// # force_inference(&buff);
-    ///
-    /// let reference = buff.get_mut();
-    /// ```
-    pub fn get_mut(&mut self) -> &mut T { &mut self.inner }
-
-    /// Returns the current position of this cursor.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::io::Cursor;
-    /// use std::io::prelude::*;
-    /// use std::io::SeekFrom;
-    ///
-    /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
-    ///
-    /// assert_eq!(buff.position(), 0);
-    ///
-    /// buff.seek(SeekFrom::Current(2)).unwrap();
-    /// assert_eq!(buff.position(), 2);
-    ///
-    /// buff.seek(SeekFrom::Current(-1)).unwrap();
-    /// assert_eq!(buff.position(), 1);
-    /// ```
-    pub fn position(&self) -> u64 { self.pos }
-
-    /// Sets the position of this cursor.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::io::Cursor;
-    ///
-    /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
-    ///
-    /// assert_eq!(buff.position(), 0);
-    ///
-    /// buff.set_position(2);
-    /// assert_eq!(buff.position(), 2);
-    ///
-    /// buff.set_position(4);
-    /// assert_eq!(buff.position(), 4);
-    /// ```
-    pub fn set_position(&mut self, pos: u64) { self.pos = pos; }
-}
-
-impl<T> io::Seek for Cursor<T> where T: AsRef<[u8]> {
-    fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {
-        let pos = match style {
-            SeekFrom::Start(n) => { self.pos = n; return Ok(n) }
-            SeekFrom::End(n) => self.inner.as_ref().len() as i64 + n,
-            SeekFrom::Current(n) => self.pos as i64 + n,
-        };
-
-        if pos < 0 {
-            Err(Error::new(ErrorKind::InvalidInput,
-                           "invalid seek to a negative position"))
-        } else {
-            self.pos = pos as u64;
-            Ok(self.pos)
-        }
-    }
-}
-
-impl<T> Read for Cursor<T> where T: AsRef<[u8]> {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        let n = Read::read(&mut self.fill_buf()?, buf)?;
-        self.pos += n as u64;
-        Ok(n)
-    }
-}
-
-impl<T> BufRead for Cursor<T> where T: AsRef<[u8]> {
-    fn fill_buf(&mut self) -> io::Result<&[u8]> {
-        let amt = cmp::min(self.pos, self.inner.as_ref().len() as u64);
-        Ok(&self.inner.as_ref()[(amt as usize)..])
-    }
-    fn consume(&mut self, amt: usize) { self.pos += amt as u64; }
-}
-
-impl<'a> Write for Cursor<&'a mut [u8]> {
-    #[inline]
-    fn write(&mut self, data: &[u8]) -> io::Result<usize> {
-        let pos = cmp::min(self.pos, self.inner.len() as u64);
-        let amt = (&mut self.inner[(pos as usize)..]).write(data)?;
-        self.pos += amt as u64;
-        Ok(amt)
-    }
-    fn flush(&mut self) -> io::Result<()> { Ok(()) }
-}
-
-impl Write for Cursor<Vec<u8>> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        // Make sure the internal buffer is as least as big as where we
-        // currently are
-        let pos = self.position();
-        let amt = pos.saturating_sub(self.inner.len() as u64);
-        // use `resize` so that the zero filling is as efficient as possible
-        let len = self.inner.len();
-        self.inner.resize(len + amt as usize, 0);
-
-        // Figure out what bytes will be used to overwrite what's currently
-        // there (left), and what will be appended on the end (right)
-        {
-            let pos = pos as usize;
-            let space = self.inner.len() - pos;
-            let (left, right) = buf.split_at(cmp::min(space, buf.len()));
-            self.inner[pos..pos + left.len()].copy_from_slice(left);
-            self.inner.extend_from_slice(right);
-        }
-
-        // Bump us forward
-        self.set_position(pos + buf.len() as u64);
-        Ok(buf.len())
-    }
-    fn flush(&mut self) -> io::Result<()> { Ok(()) }
-}
-
-impl Write for Cursor<Box<[u8]>> {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        let pos = cmp::min(self.pos, self.inner.len() as u64);
-        let amt = (&mut self.inner[(pos as usize)..]).write(buf)?;
-        self.pos += amt as u64;
-        Ok(amt)
-    }
-    fn flush(&mut self) -> io::Result<()> { Ok(()) }
-}
-
-#[cfg(test)]
-mod tests {
-    use io::prelude::*;
-    use io::{Cursor, SeekFrom};
-
-    use collections::Vec;
-
-    #[test]
-    fn test_vec_writer() {
-        let mut writer = Vec::new();
-        assert_eq!(writer.write(&[0]).unwrap(), 1);
-        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
-        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
-        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
-        assert_eq!(writer, b);
-    }
-
-    #[test]
-    fn test_mem_writer() {
-        let mut writer = Cursor::new(Vec::new());
-        assert_eq!(writer.write(&[0]).unwrap(), 1);
-        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
-        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
-        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
-        assert_eq!(&writer.get_ref()[..], b);
-    }
-
-    #[test]
-    fn test_box_slice_writer() {
-        let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
-        assert_eq!(writer.position(), 0);
-        assert_eq!(writer.write(&[0]).unwrap(), 1);
-        assert_eq!(writer.position(), 1);
-        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
-        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
-        assert_eq!(writer.position(), 8);
-        assert_eq!(writer.write(&[]).unwrap(), 0);
-        assert_eq!(writer.position(), 8);
-
-        assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
-        assert_eq!(writer.write(&[10]).unwrap(), 0);
-        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
-        assert_eq!(&**writer.get_ref(), b);
-    }
-
-    #[test]
-    fn test_buf_writer() {
-        let mut buf = [0 as u8; 9];
-        {
-            let mut writer = Cursor::new(&mut buf[..]);
-            assert_eq!(writer.position(), 0);
-            assert_eq!(writer.write(&[0]).unwrap(), 1);
-            assert_eq!(writer.position(), 1);
-            assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
-            assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
-            assert_eq!(writer.position(), 8);
-            assert_eq!(writer.write(&[]).unwrap(), 0);
-            assert_eq!(writer.position(), 8);
-
-            assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
-            assert_eq!(writer.write(&[10]).unwrap(), 0);
-        }
-        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
-        assert_eq!(buf, b);
-    }
-
-    #[test]
-    fn test_buf_writer_seek() {
-        let mut buf = [0 as u8; 8];
-        {
-            let mut writer = Cursor::new(&mut buf[..]);
-            assert_eq!(writer.position(), 0);
-            assert_eq!(writer.write(&[1]).unwrap(), 1);
-            assert_eq!(writer.position(), 1);
-
-            assert_eq!(writer.seek(SeekFrom::Start(2)).unwrap(), 2);
-            assert_eq!(writer.position(), 2);
-            assert_eq!(writer.write(&[2]).unwrap(), 1);
-            assert_eq!(writer.position(), 3);
-
-            assert_eq!(writer.seek(SeekFrom::Current(-2)).unwrap(), 1);
-            assert_eq!(writer.position(), 1);
-            assert_eq!(writer.write(&[3]).unwrap(), 1);
-            assert_eq!(writer.position(), 2);
-
-            assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
-            assert_eq!(writer.position(), 7);
-            assert_eq!(writer.write(&[4]).unwrap(), 1);
-            assert_eq!(writer.position(), 8);
-
-        }
-        let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
-        assert_eq!(buf, b);
-    }
-
-    #[test]
-    fn test_buf_writer_error() {
-        let mut buf = [0 as u8; 2];
-        let mut writer = Cursor::new(&mut buf[..]);
-        assert_eq!(writer.write(&[0]).unwrap(), 1);
-        assert_eq!(writer.write(&[0, 0]).unwrap(), 1);
-        assert_eq!(writer.write(&[0, 0]).unwrap(), 0);
-    }
-
-    #[test]
-    fn test_mem_reader() {
-        let mut reader = Cursor::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
-        let mut buf = [];
-        assert_eq!(reader.read(&mut buf).unwrap(), 0);
-        assert_eq!(reader.position(), 0);
-        let mut buf = [0];
-        assert_eq!(reader.read(&mut buf).unwrap(), 1);
-        assert_eq!(reader.position(), 1);
-        let b: &[_] = &[0];
-        assert_eq!(buf, b);
-        let mut buf = [0; 4];
-        assert_eq!(reader.read(&mut buf).unwrap(), 4);
-        assert_eq!(reader.position(), 5);
-        let b: &[_] = &[1, 2, 3, 4];
-        assert_eq!(buf, b);
-        assert_eq!(reader.read(&mut buf).unwrap(), 3);
-        let b: &[_] = &[5, 6, 7];
-        assert_eq!(&buf[..3], b);
-        assert_eq!(reader.read(&mut buf).unwrap(), 0);
-    }
-
-    #[test]
-    fn test_boxed_slice_reader() {
-        let mut reader = Cursor::new(vec!(0, 1, 2, 3, 4, 5, 6, 7).into_boxed_slice());
-        let mut buf = [];
-        assert_eq!(reader.read(&mut buf).unwrap(), 0);
-        assert_eq!(reader.position(), 0);
-        let mut buf = [0];
-        assert_eq!(reader.read(&mut buf).unwrap(), 1);
-        assert_eq!(reader.position(), 1);
-        let b: &[_] = &[0];
-        assert_eq!(buf, b);
-        let mut buf = [0; 4];
-        assert_eq!(reader.read(&mut buf).unwrap(), 4);
-        assert_eq!(reader.position(), 5);
-        let b: &[_] = &[1, 2, 3, 4];
-        assert_eq!(buf, b);
-        assert_eq!(reader.read(&mut buf).unwrap(), 3);
-        let b: &[_] = &[5, 6, 7];
-        assert_eq!(&buf[..3], b);
-        assert_eq!(reader.read(&mut buf).unwrap(), 0);
-    }
-
-    #[test]
-    fn read_to_end() {
-        let mut reader = Cursor::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
-        let mut v = Vec::new();
-        reader.read_to_end(&mut v).unwrap();
-        assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);
-    }
-
-    #[test]
-    fn test_slice_reader() {
-        let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
-        let mut reader = &mut &in_buf[..];
-        let mut buf = [];
-        assert_eq!(reader.read(&mut buf).unwrap(), 0);
-        let mut buf = [0];
-        assert_eq!(reader.read(&mut buf).unwrap(), 1);
-        assert_eq!(reader.len(), 7);
-        let b: &[_] = &[0];
-        assert_eq!(&buf[..], b);
-        let mut buf = [0; 4];
-        assert_eq!(reader.read(&mut buf).unwrap(), 4);
-        assert_eq!(reader.len(), 3);
-        let b: &[_] = &[1, 2, 3, 4];
-        assert_eq!(&buf[..], b);
-        assert_eq!(reader.read(&mut buf).unwrap(), 3);
-        let b: &[_] = &[5, 6, 7];
-        assert_eq!(&buf[..3], b);
-        assert_eq!(reader.read(&mut buf).unwrap(), 0);
-    }
-
-    #[test]
-    fn test_buf_reader() {
-        let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
-        let mut reader = Cursor::new(&in_buf[..]);
-        let mut buf = [];
-        assert_eq!(reader.read(&mut buf).unwrap(), 0);
-        assert_eq!(reader.position(), 0);
-        let mut buf = [0];
-        assert_eq!(reader.read(&mut buf).unwrap(), 1);
-        assert_eq!(reader.position(), 1);
-        let b: &[_] = &[0];
-        assert_eq!(buf, b);
-        let mut buf = [0; 4];
-        assert_eq!(reader.read(&mut buf).unwrap(), 4);
-        assert_eq!(reader.position(), 5);
-        let b: &[_] = &[1, 2, 3, 4];
-        assert_eq!(buf, b);
-        assert_eq!(reader.read(&mut buf).unwrap(), 3);
-        let b: &[_] = &[5, 6, 7];
-        assert_eq!(&buf[..3], b);
-        assert_eq!(reader.read(&mut buf).unwrap(), 0);
-    }
-
-    #[test]
-    fn test_read_char() {
-        let b = &b"Vi\xE1\xBB\x87t"[..];
-        let mut c = Cursor::new(b).chars();
-        assert_eq!(c.next().unwrap().unwrap(), 'V');
-        assert_eq!(c.next().unwrap().unwrap(), 'i');
-        assert_eq!(c.next().unwrap().unwrap(), 'ệ');
-        assert_eq!(c.next().unwrap().unwrap(), 't');
-        assert!(c.next().is_none());
-    }
-
-    #[test]
-    fn test_read_bad_char() {
-        let b = &b"\x80"[..];
-        let mut c = Cursor::new(b).chars();
-        assert!(c.next().unwrap().is_err());
-    }
-
-    #[test]
-    fn seek_past_end() {
-        let buf = [0xff];
-        let mut r = Cursor::new(&buf[..]);
-        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
-        assert_eq!(r.read(&mut [0]).unwrap(), 0);
-
-        let mut r = Cursor::new(vec!(10));
-        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
-        assert_eq!(r.read(&mut [0]).unwrap(), 0);
-
-        let mut buf = [0];
-        let mut r = Cursor::new(&mut buf[..]);
-        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
-        assert_eq!(r.write(&[3]).unwrap(), 0);
-
-        let mut r = Cursor::new(vec![10].into_boxed_slice());
-        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
-        assert_eq!(r.write(&[3]).unwrap(), 0);
-    }
-
-    #[test]
-    fn seek_before_0() {
-        let buf = [0xff];
-        let mut r = Cursor::new(&buf[..]);
-        assert!(r.seek(SeekFrom::End(-2)).is_err());
-
-        let mut r = Cursor::new(vec!(10));
-        assert!(r.seek(SeekFrom::End(-2)).is_err());
-
-        let mut buf = [0];
-        let mut r = Cursor::new(&mut buf[..]);
-        assert!(r.seek(SeekFrom::End(-2)).is_err());
-
-        let mut r = Cursor::new(vec!(10).into_boxed_slice());
-        assert!(r.seek(SeekFrom::End(-2)).is_err());
-    }
-
-    #[test]
-    fn test_seekable_mem_writer() {
-        let mut writer = Cursor::new(Vec::<u8>::new());
-        assert_eq!(writer.position(), 0);
-        assert_eq!(writer.write(&[0]).unwrap(), 1);
-        assert_eq!(writer.position(), 1);
-        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
-        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
-        assert_eq!(writer.position(), 8);
-        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
-        assert_eq!(&writer.get_ref()[..], b);
-
-        assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0);
-        assert_eq!(writer.position(), 0);
-        assert_eq!(writer.write(&[3, 4]).unwrap(), 2);
-        let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
-        assert_eq!(&writer.get_ref()[..], b);
-
-        assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3);
-        assert_eq!(writer.write(&[0, 1]).unwrap(), 2);
-        let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
-        assert_eq!(&writer.get_ref()[..], b);
-
-        assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
-        assert_eq!(writer.write(&[1, 2]).unwrap(), 2);
-        let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
-        assert_eq!(&writer.get_ref()[..], b);
-
-        assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10);
-        assert_eq!(writer.write(&[1]).unwrap(), 1);
-        let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
-        assert_eq!(&writer.get_ref()[..], b);
-    }
-
-    #[test]
-    fn vec_seek_past_end() {
-        let mut r = Cursor::new(Vec::new());
-        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
-        assert_eq!(r.write(&[3]).unwrap(), 1);
-    }
-
-    #[test]
-    fn vec_seek_before_0() {
-        let mut r = Cursor::new(Vec::new());
-        assert!(r.seek(SeekFrom::End(-2)).is_err());
-    }
-}
diff --git a/src/system/io/error.rs b/src/system/io/error.rs
deleted file mode 100644
index 4b99e7a..0000000
--- a/src/system/io/error.rs
+++ /dev/null
@@ -1,341 +0,0 @@
-// 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-
-use std::error;
-use std::fmt;
-use std::result;
-
-/// A specialized [`Result`](../result/enum.Result.html) type for I/O
-/// operations.
-///
-/// This type is broadly used across `std::io` for any operation which may
-/// produce an error.
-///
-/// This typedef is generally used to avoid writing out `io::Error` directly and
-/// is otherwise a direct mapping to `Result`.
-///
-/// While usual Rust style is to import types directly, aliases of `Result`
-/// often are not, to make it easier to distinguish between them. `Result` is
-/// generally assumed to be `std::result::Result`, and so users of this alias
-/// will generally use `io::Result` instead of shadowing the prelude's import
-/// of `std::result::Result`.
-///
-/// # Examples
-///
-/// A convenience function that bubbles an `io::Result` to its caller:
-///
-/// ```
-/// use std::io;
-///
-/// fn get_string() -> io::Result<String> {
-///     let mut buffer = String::new();
-///
-///     try!(io::stdin().read_line(&mut buffer));
-///
-///     Ok(buffer)
-/// }
-/// ```
-pub type Result<T> = result::Result<T, Error>;
-
-/// The error type for I/O operations of the `Read`, `Write`, `Seek`, and
-/// associated traits.
-///
-/// Errors mostly originate from the underlying OS, but custom instances of
-/// `Error` can be created with crafted error messages and a particular value of
-/// `ErrorKind`.
-#[derive(Debug)]
-pub struct Error {
-    repr: Repr,
-}
-
-enum Repr {
-    Os(i32),
-    Custom(Box<Custom>),
-}
-
-#[derive(Debug)]
-struct Custom {
-    kind: ErrorKind,
-    error: Box<error::Error+Send+Sync>,
-}
-
-/// A list specifying general categories of I/O error.
-///
-/// This list is intended to grow over time and it is not recommended to
-/// exhaustively match against it.
-#[derive(Copy, PartialEq, Eq, Clone, Debug)]
-#[allow(deprecated)]
-pub enum ErrorKind {
-    /// An entity was not found, often a file.
-    NotFound,
-    /// The operation lacked the necessary privileges to complete.
-    PermissionDenied,
-    /// The connection was refused by the remote server.
-    ConnectionRefused,
-    /// The connection was reset by the remote server.
-    ConnectionReset,
-    /// The connection was aborted (terminated) by the remote server.
-    ConnectionAborted,
-    /// The network operation failed because it was not connected yet.
-    NotConnected,
-    /// A socket address could not be bound because the address is already in
-    /// use elsewhere.
-    AddrInUse,
-    /// A nonexistent interface was requested or the requested address was not
-    /// local.
-    AddrNotAvailable,
-    /// The operation failed because a pipe was closed.
-    BrokenPipe,
-    /// An entity already exists, often a file.
-    AlreadyExists,
-    /// The operation needs to block to complete, but the blocking operation was
-    /// requested to not occur.
-    WouldBlock,
-    /// A parameter was incorrect.
-    InvalidInput,
-    /// Data not valid for the operation were encountered.
-    ///
-    /// Unlike `InvalidInput`, this typically means that the operation
-    /// parameters were valid, however the error was caused by malformed
-    /// input data.
-    ///
-    /// For example, a function that reads a file into a string will error with
-    /// `InvalidData` if the file's contents are not valid UTF-8.
-    InvalidData,
-    /// The I/O operation's timeout expired, causing it to be canceled.
-    TimedOut,
-    /// An error returned when an operation could not be completed because a
-    /// call to `write` returned `Ok(0)`.
-    ///
-    /// This typically means that an operation could only succeed if it wrote a
-    /// particular number of bytes but only a smaller number of bytes could be
-    /// written.
-    WriteZero,
-    /// This operation was interrupted.
-    ///
-    /// Interrupted operations can typically be retried.
-    Interrupted,
-    /// Any I/O error not part of this list.
-    Other,
-
-    /// An error returned when an operation could not be completed because an
-    /// "end of file" was reached prematurely.
-    ///
-    /// This typically means that an operation could only succeed if it read a
-    /// particular number of bytes but only a smaller number of bytes could be
-    /// read.
-    UnexpectedEof,
-
-    /// Any I/O error not part of this list.
-    #[doc(hidden)]
-    __Nonexhaustive,
-}
-
-impl Error {
-    /// Creates a new I/O error from a known kind of error as well as an
-    /// arbitrary error payload.
-    ///
-    /// This function is used to generically create I/O errors which do not
-    /// originate from the OS itself. The `error` argument is an arbitrary
-    /// payload which will be contained in this `Error`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::io::{Error, ErrorKind};
-    ///
-    /// // errors can be created from strings
-    /// let custom_error = Error::new(ErrorKind::Other, "oh no!");
-    ///
-    /// // errors can also be created from other errors
-    /// let custom_error2 = Error::new(ErrorKind::Interrupted, custom_error);
-    /// ```
-    pub fn new<E>(kind: ErrorKind, error: E) -> Error
-        where E: Into<Box<error::Error+Send+Sync>>
-    {
-        Self::_new(kind, error.into())
-    }
-
-    fn _new(kind: ErrorKind, error: Box<error::Error+Send+Sync>) -> Error {
-        Error {
-            repr: Repr::Custom(Box::new(Custom {
-                kind: kind,
-                error: error,
-            }))
-        }
-    }
-
-    /// Creates a new instance of an `Error` from a particular OS error code.
-    pub fn from_raw_os_error(code: i32) -> Error {
-        Error { repr: Repr::Os(code) }
-    }
-
-    /// Returns the OS error that this error represents (if any).
-    ///
-    /// If this `Error` was constructed via `last_os_error` or
-    /// `from_raw_os_error`, then this function will return `Some`, otherwise
-    /// it will return `None`.
-    pub fn raw_os_error(&self) -> Option<i32> {
-        match self.repr {
-            Repr::Os(i) => Some(i),
-            Repr::Custom(..) => None,
-        }
-    }
-
-    /// Returns a reference to the inner error wrapped by this error (if any).
-    ///
-    /// If this `Error` was constructed via `new` then this function will
-    /// return `Some`, otherwise it will return `None`.
-    pub fn get_ref(&self) -> Option<&(error::Error+Send+Sync+'static)> {
-        match self.repr {
-            Repr::Os(..) => None,
-            Repr::Custom(ref c) => Some(&*c.error),
-        }
-    }
-
-    /// Returns a mutable reference to the inner error wrapped by this error
-    /// (if any).
-    ///
-    /// If this `Error` was constructed via `new` then this function will
-    /// return `Some`, otherwise it will return `None`.
-    pub fn get_mut(&mut self) -> Option<&mut (error::Error+Send+Sync+'static)> {
-        match self.repr {
-            Repr::Os(..) => None,
-            Repr::Custom(ref mut c) => Some(&mut *c.error),
-        }
-    }
-
-    /// Consumes the `Error`, returning its inner error (if any).
-    ///
-    /// If this `Error` was constructed via `new` then this function will
-    /// return `Some`, otherwise it will return `None`.
-    pub fn into_inner(self) -> Option<Box<error::Error+Send+Sync>> {
-        match self.repr {
-            Repr::Os(..) => None,
-            Repr::Custom(c) => Some(c.error)
-        }
-    }
-
-    /// Returns the corresponding `ErrorKind` for this error.
-    pub fn kind(&self) -> ErrorKind {
-        match self.repr {
-            Repr::Os(_code) => ErrorKind::Other,
-            Repr::Custom(ref c) => c.kind,
-        }
-    }
-}
-
-impl fmt::Debug for Repr {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Repr::Os(ref code) =>
-                fmt.debug_struct("Os").field("code", code).finish(),
-            Repr::Custom(ref c) => fmt.debug_tuple("Custom").field(c).finish(),
-        }
-    }
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match self.repr {
-            Repr::Os(code) => {
-                write!(fmt, "os error {}", code)
-            }
-            Repr::Custom(ref c) => c.error.fmt(fmt),
-        }
-    }
-}
-
-impl error::Error for Error {
-    fn description(&self) -> &str {
-        match self.repr {
-            Repr::Os(..) => match self.kind() {
-                ErrorKind::NotFound => "entity not found",
-                ErrorKind::PermissionDenied => "permission denied",
-                ErrorKind::ConnectionRefused => "connection refused",
-                ErrorKind::ConnectionReset => "connection reset",
-                ErrorKind::ConnectionAborted => "connection aborted",
-                ErrorKind::NotConnected => "not connected",
-                ErrorKind::AddrInUse => "address in use",
-                ErrorKind::AddrNotAvailable => "address not available",
-                ErrorKind::BrokenPipe => "broken pipe",
-                ErrorKind::AlreadyExists => "entity already exists",
-                ErrorKind::WouldBlock => "operation would block",
-                ErrorKind::InvalidInput => "invalid input parameter",
-                ErrorKind::InvalidData => "invalid data",
-                ErrorKind::TimedOut => "timed out",
-                ErrorKind::WriteZero => "write zero",
-                ErrorKind::Interrupted => "operation interrupted",
-                ErrorKind::Other => "other os error",
-                ErrorKind::UnexpectedEof => "unexpected end of file",
-                ErrorKind::__Nonexhaustive => unreachable!()
-            },
-            Repr::Custom(ref c) => c.error.description(),
-        }
-    }
-
-    fn cause(&self) -> Option<&error::Error> {
-        match self.repr {
-            Repr::Os(..) => None,
-            Repr::Custom(ref c) => c.error.cause(),
-        }
-    }
-}
-
-fn _assert_error_is_sync_send() {
-    fn _is_sync_send<T: Sync+Send>() {}
-    _is_sync_send::<Error>();
-}
-
-#[cfg(test)]
-mod test {
-    use prelude::v1::*;
-    use super::{Error, ErrorKind};
-    use error;
-    use fmt;
-    use sys::os::error_string;
-
-    #[test]
-    fn test_debug_error() {
-        let code = 6;
-        let msg = error_string(code);
-        let err = Error { repr: super::Repr::Os(code) };
-        let expected = format!("Error {{ repr: Os {{ code: {:?}, message: {:?} }} }}", code, msg);
-        assert_eq!(format!("{:?}", err), expected);
-    }
-
-    #[test]
-    fn test_downcasting() {
-        #[derive(Debug)]
-        struct TestError;
-
-        impl fmt::Display for TestError {
-            fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
-                Ok(())
-            }
-        }
-
-        impl error::Error for TestError {
-            fn description(&self) -> &str {
-                "asdf"
-            }
-        }
-
-        // we have to call all of these UFCS style right now since method
-        // resolution won't implicitly drop the Send+Sync bounds
-        let mut err = Error::new(ErrorKind::Other, TestError);
-        assert!(err.get_ref().unwrap().is::<TestError>());
-        assert_eq!("asdf", err.get_ref().unwrap().description());
-        assert!(err.get_mut().unwrap().is::<TestError>());
-        let extracted = err.into_inner().unwrap();
-        extracted.downcast::<TestError>().unwrap();
-    }
-}
diff --git a/src/system/io/impls.rs b/src/system/io/impls.rs
deleted file mode 100644
index fc39a50..0000000
--- a/src/system/io/impls.rs
+++ /dev/null
@@ -1,275 +0,0 @@
-// 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::cmp;
-use std::io::{self, SeekFrom, Read, Write, Seek, BufRead, Error, ErrorKind};
-use std::fmt;
-use std::mem;
-
-// =============================================================================
-// Forwarding implementations
-
-impl<'a, R: Read + ?Sized> Read for &'a mut R {
-    #[inline]
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        (**self).read(buf)
-    }
-
-    #[inline]
-    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
-        (**self).read_to_end(buf)
-    }
-
-    #[inline]
-    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
-        (**self).read_to_string(buf)
-    }
-
-    #[inline]
-    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
-        (**self).read_exact(buf)
-    }
-}
-impl<'a, W: Write + ?Sized> Write for &'a mut W {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> { (**self).write(buf) }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> { (**self).flush() }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        (**self).write_all(buf)
-    }
-
-    #[inline]
-    fn write_fmt(&mut self, fmt: fmt::Arguments) -> io::Result<()> {
-        (**self).write_fmt(fmt)
-    }
-}
-impl<'a, S: Seek + ?Sized> Seek for &'a mut S {
-    #[inline]
-    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { (**self).seek(pos) }
-}
-impl<'a, B: BufRead + ?Sized> BufRead for &'a mut B {
-    #[inline]
-    fn fill_buf(&mut self) -> io::Result<&[u8]> { (**self).fill_buf() }
-
-    #[inline]
-    fn consume(&mut self, amt: usize) { (**self).consume(amt) }
-
-    #[inline]
-    fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> {
-        (**self).read_until(byte, buf)
-    }
-
-    #[inline]
-    fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {
-        (**self).read_line(buf)
-    }
-}
-
-impl<R: Read + ?Sized> Read for Box<R> {
-    #[inline]
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        (**self).read(buf)
-    }
-
-    #[inline]
-    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
-        (**self).read_to_end(buf)
-    }
-
-    #[inline]
-    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
-        (**self).read_to_string(buf)
-    }
-
-    #[inline]
-    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
-        (**self).read_exact(buf)
-    }
-}
-impl<W: Write + ?Sized> Write for Box<W> {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> { (**self).write(buf) }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> { (**self).flush() }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        (**self).write_all(buf)
-    }
-
-    #[inline]
-    fn write_fmt(&mut self, fmt: fmt::Arguments) -> io::Result<()> {
-        (**self).write_fmt(fmt)
-    }
-}
-impl<S: Seek + ?Sized> Seek for Box<S> {
-    #[inline]
-    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { (**self).seek(pos) }
-}
-impl<B: BufRead + ?Sized> BufRead for Box<B> {
-    #[inline]
-    fn fill_buf(&mut self) -> io::Result<&[u8]> { (**self).fill_buf() }
-
-    #[inline]
-    fn consume(&mut self, amt: usize) { (**self).consume(amt) }
-
-    #[inline]
-    fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> {
-        (**self).read_until(byte, buf)
-    }
-
-    #[inline]
-    fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {
-        (**self).read_line(buf)
-    }
-}
-
-// =============================================================================
-// In-memory buffer implementations
-
-impl<'a> Read for &'a [u8] {
-    #[inline]
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        let amt = cmp::min(buf.len(), self.len());
-        let (a, b) = self.split_at(amt);
-        buf[..amt].copy_from_slice(a);
-        *self = b;
-        Ok(amt)
-    }
-
-    #[inline]
-    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
-        if buf.len() > self.len() {
-            return Err(Error::new(ErrorKind::UnexpectedEof,
-                                  "failed to fill whole buffer"));
-        }
-        let (a, b) = self.split_at(buf.len());
-        buf.copy_from_slice(a);
-        *self = b;
-        Ok(())
-    }
-}
-
-impl<'a> BufRead for &'a [u8] {
-    #[inline]
-    fn fill_buf(&mut self) -> io::Result<&[u8]> { Ok(*self) }
-
-    #[inline]
-    fn consume(&mut self, amt: usize) { *self = &self[amt..]; }
-}
-
-impl<'a> Write for &'a mut [u8] {
-    #[inline]
-    fn write(&mut self, data: &[u8]) -> io::Result<usize> {
-        let amt = cmp::min(data.len(), self.len());
-        let (a, b) = mem::replace(self, &mut []).split_at_mut(amt);
-        a.copy_from_slice(&data[..amt]);
-        *self = b;
-        Ok(amt)
-    }
-
-    #[inline]
-    fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
-        if self.write(data)? == data.len() {
-            Ok(())
-        } else {
-            Err(Error::new(ErrorKind::WriteZero, "failed to write whole buffer"))
-        }
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> { Ok(()) }
-}
-
-impl Write for Vec<u8> {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.extend_from_slice(buf);
-        Ok(buf.len())
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        self.extend_from_slice(buf);
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> { Ok(()) }
-}
-
-#[cfg(test)]
-mod tests {
-    use io::prelude::*;
-    use test;
-
-    use collections::Vec;
-
-    #[bench]
-    fn bench_read_slice(b: &mut test::Bencher) {
-        let buf = [5; 1024];
-        let mut dst = [0; 128];
-
-        b.iter(|| {
-            let mut rd = &buf[..];
-            for _ in 0..8 {
-                let _ = rd.read(&mut dst);
-                test::black_box(&dst);
-            }
-        })
-    }
-
-    #[bench]
-    fn bench_write_slice(b: &mut test::Bencher) {
-        let mut buf = [0; 1024];
-        let src = [5; 128];
-
-        b.iter(|| {
-            let mut wr = &mut buf[..];
-            for _ in 0..8 {
-                let _ = wr.write_all(&src);
-                test::black_box(&wr);
-            }
-        })
-    }
-
-    #[bench]
-    fn bench_read_vec(b: &mut test::Bencher) {
-        let buf = vec![5; 1024];
-        let mut dst = [0; 128];
-
-        b.iter(|| {
-            let mut rd = &buf[..];
-            for _ in 0..8 {
-                let _ = rd.read(&mut dst);
-                test::black_box(&dst);
-            }
-        })
-    }
-
-    #[bench]
-    fn bench_write_vec(b: &mut test::Bencher) {
-        let mut buf = Vec::with_capacity(1024);
-        let src = [5; 128];
-
-        b.iter(|| {
-            let mut wr = &mut buf[..];
-            for _ in 0..8 {
-                let _ = wr.write_all(&src);
-                test::black_box(&wr);
-            }
-        })
-    }
-}
diff --git a/src/system/io/mod.rs b/src/system/io/mod.rs
deleted file mode 100644
index 0551836..0000000
--- a/src/system/io/mod.rs
+++ /dev/null
@@ -1,1883 +0,0 @@
-// 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Traits, helpers, and type definitions for core I/O functionality.
-//!
-//! The `std::io` module contains a number of common things you'll need
-//! when doing input and output. The most core part of this module is
-//! the [`Read`][read] and [`Write`][write] traits, which provide the
-//! most general interface for reading and writing input and output.
-//!
-//! [read]: trait.Read.html
-//! [write]: trait.Write.html
-//!
-//! # Read and Write
-//!
-//! Because they are traits, `Read` and `Write` are implemented by a number
-//! of other types, and you can implement them for your types too. As such,
-//! you'll see a few different types of I/O throughout the documentation in
-//! this module: `File`s, `TcpStream`s, and sometimes even `Vec<T>`s. For
-//! example, `Read` adds a `read()` method, which we can use on `File`s:
-//!
-//! ```
-//! use std::io;
-//! use std::io::prelude::*;
-//! use std::fs::File;
-//!
-//! # fn foo() -> io::Result<()> {
-//! let mut f = try!(File::open("foo.txt"));
-//! let mut buffer = [0; 10];
-//!
-//! // read up to 10 bytes
-//! try!(f.read(&mut buffer));
-//!
-//! println!("The bytes: {:?}", buffer);
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! `Read` and `Write` are so important, implementors of the two traits have a
-//! nickname: readers and writers. So you'll sometimes see 'a reader' instead
-//! of 'a type that implements the `Read` trait'. Much easier!
-//!
-//! ## Seek and BufRead
-//!
-//! Beyond that, there are two important traits that are provided: [`Seek`][seek]
-//! and [`BufRead`][bufread]. Both of these build on top of a reader to control
-//! how the reading happens. `Seek` lets you control where the next byte is
-//! coming from:
-//!
-//! ```
-//! use std::io;
-//! use std::io::prelude::*;
-//! use std::io::SeekFrom;
-//! use std::fs::File;
-//!
-//! # fn foo() -> io::Result<()> {
-//! let mut f = try!(File::open("foo.txt"));
-//! let mut buffer = [0; 10];
-//!
-//! // skip to the last 10 bytes of the file
-//! try!(f.seek(SeekFrom::End(-10)));
-//!
-//! // read up to 10 bytes
-//! try!(f.read(&mut buffer));
-//!
-//! println!("The bytes: {:?}", buffer);
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! [seek]: trait.Seek.html
-//! [bufread]: trait.BufRead.html
-//!
-//! `BufRead` uses an internal buffer to provide a number of other ways to read, but
-//! to show it off, we'll need to talk about buffers in general. Keep reading!
-//!
-//! ## BufReader and BufWriter
-//!
-//! Byte-based interfaces are unwieldy and can be inefficient, as we'd need to be
-//! making near-constant calls to the operating system. To help with this,
-//! `std::io` comes with two structs, `BufReader` and `BufWriter`, which wrap
-//! readers and writers. The wrapper uses a buffer, reducing the number of
-//! calls and providing nicer methods for accessing exactly what you want.
-//!
-//! For example, `BufReader` works with the `BufRead` trait to add extra
-//! methods to any reader:
-//!
-//! ```
-//! use std::io;
-//! use std::io::prelude::*;
-//! use std::io::BufReader;
-//! use std::fs::File;
-//!
-//! # fn foo() -> io::Result<()> {
-//! let f = try!(File::open("foo.txt"));
-//! let mut reader = BufReader::new(f);
-//! let mut buffer = String::new();
-//!
-//! // read a line into buffer
-//! try!(reader.read_line(&mut buffer));
-//!
-//! println!("{}", buffer);
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! `BufWriter` doesn't add any new ways of writing; it just buffers every call
-//! to [`write()`][write()]:
-//!
-//! ```
-//! use std::io;
-//! use std::io::prelude::*;
-//! use std::io::BufWriter;
-//! use std::fs::File;
-//!
-//! # fn foo() -> io::Result<()> {
-//! let f = try!(File::create("foo.txt"));
-//! {
-//!     let mut writer = BufWriter::new(f);
-//!
-//!     // write a byte to the buffer
-//!     try!(writer.write(&[42]));
-//!
-//! } // the buffer is flushed once writer goes out of scope
-//!
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! [write()]: trait.Write.html#tymethod.write
-//!
-//! ## Standard input and output
-//!
-//! A very common source of input is standard input:
-//!
-//! ```
-//! use std::io;
-//!
-//! # fn foo() -> io::Result<()> {
-//! let mut input = String::new();
-//!
-//! try!(io::stdin().read_line(&mut input));
-//!
-//! println!("You typed: {}", input.trim());
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! And a very common source of output is standard output:
-//!
-//! ```
-//! use std::io;
-//! use std::io::prelude::*;
-//!
-//! # fn foo() -> io::Result<()> {
-//! try!(io::stdout().write(&[42]));
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! Of course, using `io::stdout()` directly is less common than something like
-//! `println!`.
-//!
-//! ## Iterator types
-//!
-//! A large number of the structures provided by `std::io` are for various
-//! ways of iterating over I/O. For example, `Lines` is used to split over
-//! lines:
-//!
-//! ```
-//! use std::io;
-//! use std::io::prelude::*;
-//! use std::io::BufReader;
-//! use std::fs::File;
-//!
-//! # fn foo() -> io::Result<()> {
-//! let f = try!(File::open("foo.txt"));
-//! let reader = BufReader::new(f);
-//!
-//! for line in reader.lines() {
-//!     println!("{}", try!(line));
-//! }
-//!
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! ## Functions
-//!
-//! There are a number of [functions][functions-list] that offer access to various
-//! features. For example, we can use three of these functions to copy everything
-//! from standard input to standard output:
-//!
-//! ```
-//! use std::io;
-//!
-//! # fn foo() -> io::Result<()> {
-//! try!(io::copy(&mut io::stdin(), &mut io::stdout()));
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! [functions-list]: #functions-1
-//!
-//! ## io::Result
-//!
-//! Last, but certainly not least, is [`io::Result`][result]. This type is used
-//! as the return type of many `std::io` functions that can cause an error, and
-//! can be returned from your own functions as well. Many of the examples in this
-//! module use the [`try!`][try] macro:
-//!
-//! ```
-//! use std::io;
-//!
-//! fn read_input() -> io::Result<()> {
-//!     let mut input = String::new();
-//!
-//!     try!(io::stdin().read_line(&mut input));
-//!
-//!     println!("You typed: {}", input.trim());
-//!
-//!     Ok(())
-//! }
-//! ```
-//!
-//! The return type of `read_input()`, `io::Result<()>`, is a very common type
-//! for functions which don't have a 'real' return value, but do want to return
-//! errors if they happen. In this case, the only purpose of this function is
-//! to read the line and print it, so we use `()`.
-//!
-//! [result]: type.Result.html
-//! [try]: ../macro.try.html
-//!
-//! ## Platform-specific behavior
-//!
-//! Many I/O functions throughout the standard library are documented to indicate
-//! what various library or syscalls they are delegated to. This is done to help
-//! applications both understand what's happening under the hood as well as investigate
-//! any possibly unclear semantics. Note, however, that this is informative, not a binding
-//! contract. The implementation of many of these functions are subject to change over
-//! time and may call fewer or more syscalls/library functions.
-
-use std::cmp;
-use rustc_unicode::str as core_str;
-use std::error as std_error;
-use std::fmt;
-use std::result;
-use std::str;
-use std::memchr;
-
-pub use self::buffered::{BufReader, BufWriter, LineWriter};
-pub use self::buffered::IntoInnerError;
-pub use self::cursor::Cursor;
-pub use self::error::{Result, Error, ErrorKind};
-pub use self::util::{copy, sink, Sink, empty, Empty, repeat, Repeat};
-
-//pub use self::stdio::{stdin, stdout, stderr, _print, Stdin, Stdout, Stderr};
-//pub use self::stdio::{StdoutLock, StderrLock, StdinLock};
-#[doc(no_inline, hidden)]
-//pub use self::stdio::{set_panic, set_print};
-
-pub mod prelude;
-mod buffered;
-mod cursor;
-mod error;
-mod impls;
-mod util;
-
-//mod lazy;
-//mod stdio;
-
-const DEFAULT_BUF_SIZE: usize = 8 * 1024;
-
-// A few methods below (read_to_string, read_line) will append data into a
-// `String` buffer, but we need to be pretty careful when doing this. The
-// implementation will just call `.as_mut_vec()` and then delegate to a
-// byte-oriented reading method, but we must ensure that when returning we never
-// leave `buf` in a state such that it contains invalid UTF-8 in its bounds.
-//
-// To this end, we use an RAII guard (to protect against panics) which updates
-// the length of the string when it is dropped. This guard initially truncates
-// the string to the prior length and only after we've validated that the
-// new contents are valid UTF-8 do we allow it to set a longer length.
-//
-// The unsafety in this function is twofold:
-//
-// 1. We're looking at the raw bytes of `buf`, so we take on the burden of UTF-8
-//    checks.
-// 2. We're passing a raw buffer to the function `f`, and it is expected that
-//    the function only *appends* bytes to the buffer. We'll get undefined
-//    behavior if existing bytes are overwritten to have non-UTF-8 data.
-fn append_to_string<F>(buf: &mut String, f: F) -> Result<usize>
-    where F: FnOnce(&mut Vec<u8>) -> Result<usize>
-{
-    struct Guard<'a> { s: &'a mut Vec<u8>, len: usize }
-        impl<'a> Drop for Guard<'a> {
-        fn drop(&mut self) {
-            unsafe { self.s.set_len(self.len); }
-        }
-    }
-
-    unsafe {
-        let mut g = Guard { len: buf.len(), s: buf.as_mut_vec() };
-        let ret = f(g.s);
-        if str::from_utf8(&g.s[g.len..]).is_err() {
-            ret.and_then(|_| {
-                Err(Error::new(ErrorKind::InvalidData,
-                               "stream did not contain valid UTF-8"))
-            })
-        } else {
-            g.len = g.s.len();
-            ret
-        }
-    }
-}
-
-// This uses an adaptive system to extend the vector when it fills. We want to
-// avoid paying to allocate and zero a huge chunk of memory if the reader only
-// has 4 bytes while still making large reads if the reader does have a ton
-// of data to return. Simply tacking on an extra DEFAULT_BUF_SIZE space every
-// time is 4,500 times (!) slower than this if the reader has a very small
-// amount of data to return.
-fn read_to_end<R: Read + ?Sized>(r: &mut R, buf: &mut Vec<u8>) -> Result<usize> {
-    let start_len = buf.len();
-    let mut len = start_len;
-    let mut new_write_size = 16;
-    let ret;
-    loop {
-        if len == buf.len() {
-            if new_write_size < DEFAULT_BUF_SIZE {
-                new_write_size *= 2;
-            }
-            buf.resize(len + new_write_size, 0);
-        }
-
-        match r.read(&mut buf[len..]) {
-            Ok(0) => {
-                ret = Ok(len - start_len);
-                break;
-            }
-            Ok(n) => len += n,
-            Err(ref e) if e.kind() == ErrorKind::Interrupted => {}
-            Err(e) => {
-                ret = Err(e);
-                break;
-            }
-        }
-    }
-
-    buf.truncate(len);
-    ret
-}
-
-/// The `Read` trait allows for reading bytes from a source.
-///
-/// Implementors of the `Read` trait are sometimes called 'readers'.
-///
-/// Readers are defined by one required method, `read()`. Each call to `read`
-/// will attempt to pull bytes from this source into a provided buffer. A
-/// number of other methods are implemented in terms of `read()`, giving
-/// implementors a number of ways to read bytes while only needing to implement
-/// a single method.
-///
-/// Readers are intended to be composable with one another. Many implementors
-/// throughout `std::io` take and provide types which implement the `Read`
-/// trait.
-///
-/// Please note that each call to `read` may involve a system call, and
-/// therefore, using something that implements [`BufRead`][bufread], such as
-/// [`BufReader`][bufreader], will be more efficient.
-///
-/// [bufread]: trait.BufRead.html
-/// [bufreader]: struct.BufReader.html
-///
-/// # Examples
-///
-/// [`File`][file]s implement `Read`:
-///
-/// [file]: ../fs/struct.File.html
-///
-/// ```
-/// use std::io;
-/// use std::io::prelude::*;
-/// use std::fs::File;
-///
-/// # fn foo() -> io::Result<()> {
-/// let mut f = try!(File::open("foo.txt"));
-/// let mut buffer = [0; 10];
-///
-/// // read up to 10 bytes
-/// try!(f.read(&mut buffer));
-///
-/// let mut buffer = vec![0; 10];
-/// // read the whole file
-/// try!(f.read_to_end(&mut buffer));
-///
-/// // read into a String, so that you don't need to do the conversion.
-/// let mut buffer = String::new();
-/// try!(f.read_to_string(&mut buffer));
-///
-/// // and more! See the other methods for more details.
-/// # Ok(())
-/// # }
-/// ```
-pub trait Read {
-    /// Pull some bytes from this source into the specified buffer, returning
-    /// how many bytes were read.
-    ///
-    /// This function does not provide any guarantees about whether it blocks
-    /// waiting for data, but if an object needs to block for a read but cannot
-    /// it will typically signal this via an `Err` return value.
-    ///
-    /// If the return value of this method is `Ok(n)`, then it must be
-    /// guaranteed that `0 <= n <= buf.len()`. A nonzero `n` value indicates
-    /// that the buffer `buf` has been filled in with `n` bytes of data from this
-    /// source. If `n` is `0`, then it can indicate one of two scenarios:
-    ///
-    /// 1. This reader has reached its "end of file" and will likely no longer
-    ///    be able to produce bytes. Note that this does not mean that the
-    ///    reader will *always* no longer be able to produce bytes.
-    /// 2. The buffer specified was 0 bytes in length.
-    ///
-    /// No guarantees are provided about the contents of `buf` when this
-    /// function is called, implementations cannot rely on any property of the
-    /// contents of `buf` being true. It is recommended that implementations
-    /// only write data to `buf` instead of reading its contents.
-    ///
-    /// # Errors
-    ///
-    /// If this function encounters any form of I/O or other error, an error
-    /// variant will be returned. If an error is returned then it must be
-    /// guaranteed that no bytes were read.
-    ///
-    /// # Examples
-    ///
-    /// [`File`][file]s implement `Read`:
-    ///
-    /// [file]: ../fs/struct.File.html
-    ///
-    /// ```
-    /// use std::io;
-    /// use std::io::prelude::*;
-    /// use std::fs::File;
-    ///
-    /// # fn foo() -> io::Result<()> {
-    /// let mut f = try!(File::open("foo.txt"));
-    /// let mut buffer = [0; 10];
-    ///
-    /// // read 10 bytes
-    /// try!(f.read(&mut buffer[..]));
-    /// # Ok(())
-    /// # }
-    /// ```
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize>;
-
-    /// Read all bytes until EOF in this source, placing them into `buf`.
-    ///
-    /// All bytes read from this source will be appended to the specified buffer
-    /// `buf`. This function will continuously call `read` to append more data to
-    /// `buf` until `read` returns either `Ok(0)` or an error of
-    /// non-`ErrorKind::Interrupted` kind.
-    ///
-    /// If successful, this function will return the total number of bytes read.
-    ///
-    /// # Errors
-    ///
-    /// If this function encounters an error of the kind
-    /// `ErrorKind::Interrupted` then the error is ignored and the operation
-    /// will continue.
-    ///
-    /// If any other read error is encountered then this function immediately
-    /// returns. Any bytes which have already been read will be appended to
-    /// `buf`.
-    ///
-    /// # Examples
-    ///
-    /// [`File`][file]s implement `Read`:
-    ///
-    /// [file]: ../fs/struct.File.html
-    ///
-    /// ```
-    /// use std::io;
-    /// use std::io::prelude::*;
-    /// use std::fs::File;
-    ///
-    /// # fn foo() -> io::Result<()> {
-    /// let mut f = try!(File::open("foo.txt"));
-    /// let mut buffer = Vec::new();
-    ///
-    /// // read the whole file
-    /// try!(f.read_to_end(&mut buffer));
-    /// # Ok(())
-    /// # }
-    /// ```
-    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize> {
-        read_to_end(self, buf)
-    }
-
-    /// Read all bytes until EOF in this source, placing them into `buf`.
-    ///
-    /// If successful, this function returns the number of bytes which were read
-    /// and appended to `buf`.
-    ///
-    /// # Errors
-    ///
-    /// If the data in this stream is *not* valid UTF-8 then an error is
-    /// returned and `buf` is unchanged.
-    ///
-    /// See [`read_to_end()`][readtoend] for other error semantics.
-    ///
-    /// [readtoend]: #method.read_to_end
-    ///
-    /// # Examples
-    ///
-    /// [`File`][file]s implement `Read`:
-    ///
-    /// [file]: ../fs/struct.File.html
-    ///
-    /// ```
-    /// use std::io;
-    /// use std::io::prelude::*;
-    /// use std::fs::File;
-    ///
-    /// # fn foo() -> io::Result<()> {
-    /// let mut f = try!(File::open("foo.txt"));
-    /// let mut buffer = String::new();
-    ///
-    /// try!(f.read_to_string(&mut buffer));
-    /// # Ok(())
-    /// # }
-    /// ```
-    fn read_to_string(&mut self, buf: &mut String) -> Result<usize> {
-        // Note that we do *not* call `.read_to_end()` here. We are passing
-        // `&mut Vec<u8>` (the raw contents of `buf`) into the `read_to_end`
-        // method to fill it up. An arbitrary implementation could overwrite the
-        // entire contents of the vector, not just append to it (which is what
-        // we are expecting).
-        //
-        // To prevent extraneously checking the UTF-8-ness of the entire buffer
-        // we pass it to our hardcoded `read_to_end` implementation which we
-        // know is guaranteed to only read data into the end of the buffer.
-        append_to_string(buf, |b| read_to_end(self, b))
-    }
-
-    /// Read the exact number of bytes required to fill `buf`.
-    ///
-    /// This function reads as many bytes as necessary to completely fill the
-    /// specified buffer `buf`.
-    ///
-    /// No guarantees are provided about the contents of `buf` when this
-    /// function is called, implementations cannot rely on any property of the
-    /// contents of `buf` being true. It is recommended that implementations
-    /// only write data to `buf` instead of reading its contents.
-    ///
-    /// # Errors
-    ///
-    /// If this function encounters an error of the kind
-    /// `ErrorKind::Interrupted` then the error is ignored and the operation
-    /// will continue.
-    ///
-    /// If this function encounters an "end of file" before completely filling
-    /// the buffer, it returns an error of the kind `ErrorKind::UnexpectedEof`.
-    /// The contents of `buf` are unspecified in this case.
-    ///
-    /// If any other read error is encountered then this function immediately
-    /// returns. The contents of `buf` are unspecified in this case.
-    ///
-    /// If this function returns an error, it is unspecified how many bytes it
-    /// has read, but it will never read more than would be necessary to
-    /// completely fill the buffer.
-    ///
-    /// # Examples
-    ///
-    /// [`File`][file]s implement `Read`:
-    ///
-    /// [file]: ../fs/struct.File.html
-    ///
-    /// ```
-    /// use std::io;
-    /// use std::io::prelude::*;
-    /// use std::fs::File;
-    ///
-    /// # fn foo() -> io::Result<()> {
-    /// let mut f = try!(File::open("foo.txt"));
-    /// let mut buffer = [0; 10];
-    ///
-    /// // read exactly 10 bytes
-    /// try!(f.read_exact(&mut buffer));
-    /// # Ok(())
-    /// # }
-    /// ```
-    fn read_exact(&mut self, mut buf: &mut [u8]) -> Result<()> {
-        while !buf.is_empty() {
-            match self.read(buf) {
-                Ok(0) => break,
-                Ok(n) => { let tmp = buf; buf = &mut tmp[n..]; }
-                Err(ref e) if e.kind() == ErrorKind::Interrupted => {}
-                Err(e) => return Err(e),
-            }
-        }
-        if !buf.is_empty() {
-            Err(Error::new(ErrorKind::UnexpectedEof,
-                           "failed to fill whole buffer"))
-        } else {
-            Ok(())
-        }
-    }
-
-    /// Creates a "by reference" adaptor for this instance of `Read`.
-    ///
-    /// The returned adaptor also implements `Read` and will simply borrow this
-    /// current reader.
-    ///
-    /// # Examples
-    ///
-    /// [`File`][file]s implement `Read`:
-    ///
-    /// [file]: ../fs/struct.File.html
-    ///
-    /// ```
-    /// use std::io;
-    /// use std::io::Read;
-    /// use std::fs::File;
-    ///
-    /// # fn foo() -> io::Result<()> {
-    /// let mut f = try!(File::open("foo.txt"));
-    /// let mut buffer = Vec::new();
-    /// let mut other_buffer = Vec::new();
-    ///
-    /// {
-    ///     let reference = f.by_ref();
-    ///
-    ///     // read at most 5 bytes
-    ///     try!(reference.take(5).read_to_end(&mut buffer));
-    ///
-    /// } // drop our &mut reference so we can use f again
-    ///
-    /// // original file still usable, read the rest
-    /// try!(f.read_to_end(&mut other_buffer));
-    /// # Ok(())
-    /// # }
-    /// ```
-    fn by_ref(&mut self) -> &mut Self where Self: Sized { self }
-
-    /// Transforms this `Read` instance to an `Iterator` over its bytes.
-    ///
-    /// The returned type implements `Iterator` where the `Item` is `Result<u8,
-    /// R::Err>`.  The yielded item is `Ok` if a byte was successfully read and
-    /// `Err` otherwise for I/O errors. EOF is mapped to returning `None` from
-    /// this iterator.
-    ///
-    /// # Examples
-    ///
-    /// [`File`][file]s implement `Read`:
-    ///
-    /// [file]: ../fs/struct.File.html
-    ///
-    /// ```
-    /// use std::io;
-    /// use std::io::prelude::*;
-    /// use std::fs::File;
-    ///
-    /// # fn foo() -> io::Result<()> {
-    /// let mut f = try!(File::open("foo.txt"));
-    ///
-    /// for byte in f.bytes() {
-    ///     println!("{}", byte.unwrap());
-    /// }
-    /// # Ok(())
-    /// # }
-    /// ```
-    fn bytes(self) -> Bytes<Self> where Self: Sized {
-        Bytes { inner: self }
-    }
-
-    /// Transforms this `Read` instance to an `Iterator` over `char`s.
-    ///
-    /// This adaptor will attempt to interpret this reader as a UTF-8 encoded
-    /// sequence of characters. The returned iterator will return `None` once
-    /// EOF is reached for this reader. Otherwise each element yielded will be a
-    /// `Result<char, E>` where `E` may contain information about what I/O error
-    /// occurred or where decoding failed.
-    ///
-    /// Currently this adaptor will discard intermediate data read, and should
-    /// be avoided if this is not desired.
-    ///
-    /// # Examples
-    ///
-    /// [`File`][file]s implement `Read`:
-    ///
-    /// [file]: ../fs/struct.File.html
-    ///
-    /// ```
-    /// #![feature(io)]
-    /// use std::io;
-    /// use std::io::prelude::*;
-    /// use std::fs::File;
-    ///
-    /// # fn foo() -> io::Result<()> {
-    /// let mut f = try!(File::open("foo.txt"));
-    ///
-    /// for c in f.chars() {
-    ///     println!("{}", c.unwrap());
-    /// }
-    /// # Ok(())
-    /// # }
-    /// ```
-    fn chars(self) -> Chars<Self> where Self: Sized {
-        Chars { inner: self }
-    }
-
-    /// Creates an adaptor which will chain this stream with another.
-    ///
-    /// The returned `Read` instance will first read all bytes from this object
-    /// until EOF is encountered. Afterwards the output is equivalent to the
-    /// output of `next`.
-    ///
-    /// # Examples
-    ///
-    /// [`File`][file]s implement `Read`:
-    ///
-    /// [file]: ../fs/struct.File.html
-    ///
-    /// ```
-    /// use std::io;
-    /// use std::io::prelude::*;
-    /// use std::fs::File;
-    ///
-    /// # fn foo() -> io::Result<()> {
-    /// let mut f1 = try!(File::open("foo.txt"));
-    /// let mut f2 = try!(File::open("bar.txt"));
-    ///
-    /// let mut handle = f1.chain(f2);
-    /// let mut buffer = String::new();
-    ///
-    /// // read the value into a String. We could use any Read method here,
-    /// // this is just one example.
-    /// try!(handle.read_to_string(&mut buffer));
-    /// # Ok(())
-    /// # }
-    /// ```
-    fn chain<R: Read>(self, next: R) -> Chain<Self, R> where Self: Sized {
-        Chain { first: self, second: next, done_first: false }
-    }
-
-    /// Creates an adaptor which will read at most `limit` bytes from it.
-    ///
-    /// This function returns a new instance of `Read` which will read at most
-    /// `limit` bytes, after which it will always return EOF (`Ok(0)`). Any
-    /// read errors will not count towards the number of bytes read and future
-    /// calls to `read` may succeed.
-    ///
-    /// # Examples
-    ///
-    /// [`File`][file]s implement `Read`:
-    ///
-    /// [file]: ../fs/struct.File.html
-    ///
-    /// ```
-    /// use std::io;
-    /// use std::io::prelude::*;
-    /// use std::fs::File;
-    ///
-    /// # fn foo() -> io::Result<()> {
-    /// let mut f = try!(File::open("foo.txt"));
-    /// let mut buffer = [0; 5];
-    ///
-    /// // read at most five bytes
-    /// let mut handle = f.take(5);
-    ///
-    /// try!(handle.read(&mut buffer));
-    /// # Ok(())
-    /// # }
-    /// ```
-    fn take(self, limit: u64) -> Take<Self> where Self: Sized {
-        Take { inner: self, limit: limit }
-    }
-}
-
-/// A trait for objects which are byte-oriented sinks.
-///
-/// Implementors of the `Write` trait are sometimes called 'writers'.
-///
-/// Writers are defined by two required methods, `write()` and `flush()`:
-///
-/// * The `write()` method will attempt to write some data into the object,
-///   returning how many bytes were successfully written.
-///
-/// * The `flush()` method is useful for adaptors and explicit buffers
-///   themselves for ensuring that all buffered data has been pushed out to the
-///   'true sink'.
-///
-/// Writers are intended to be composable with one another. Many implementors
-/// throughout `std::io` take and provide types which implement the `Write`
-/// trait.
-///
-/// # Examples
-///
-/// ```
-/// use std::io::prelude::*;
-/// use std::fs::File;
-///
-/// # fn foo() -> std::io::Result<()> {
-/// let mut buffer = try!(File::create("foo.txt"));
-///
-/// try!(buffer.write(b"some bytes"));
-/// # Ok(())
-/// # }
-/// ```
-pub trait Write {
-    /// Write a buffer into this object, returning how many bytes were written.
-    ///
-    /// This function will attempt to write the entire contents of `buf`, but
-    /// the entire write may not succeed, or the write may also generate an
-    /// error. A call to `write` represents *at most one* attempt to write to
-    /// any wrapped object.
-    ///
-    /// Calls to `write` are not guaranteed to block waiting for data to be
-    /// written, and a write which would otherwise block can be indicated through
-    /// an `Err` variant.
-    ///
-    /// If the return value is `Ok(n)` then it must be guaranteed that
-    /// `0 <= n <= buf.len()`. A return value of `0` typically means that the
-    /// underlying object is no longer able to accept bytes and will likely not
-    /// be able to in the future as well, or that the buffer provided is empty.
-    ///
-    /// # Errors
-    ///
-    /// Each call to `write` may generate an I/O error indicating that the
-    /// operation could not be completed. If an error is returned then no bytes
-    /// in the buffer were written to this writer.
-    ///
-    /// It is **not** considered an error if the entire buffer could not be
-    /// written to this writer.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::io::prelude::*;
-    /// use std::fs::File;
-    ///
-    /// # fn foo() -> std::io::Result<()> {
-    /// let mut buffer = try!(File::create("foo.txt"));
-    ///
-    /// try!(buffer.write(b"some bytes"));
-    /// # Ok(())
-    /// # }
-    /// ```
-    fn write(&mut self, buf: &[u8]) -> Result<usize>;
-
-    /// Flush this output stream, ensuring that all intermediately buffered
-    /// contents reach their destination.
-    ///
-    /// # Errors
-    ///
-    /// It is considered an error if not all bytes could be written due to
-    /// I/O errors or EOF being reached.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::io::prelude::*;
-    /// use std::io::BufWriter;
-    /// use std::fs::File;
-    ///
-    /// # fn foo() -> std::io::Result<()> {
-    /// let mut buffer = BufWriter::new(try!(File::create("foo.txt")));
-    ///
-    /// try!(buffer.write(b"some bytes"));
-    /// try!(buffer.flush());
-    /// # Ok(())
-    /// # }
-    /// ```
-    fn flush(&mut self) -> Result<()>;
-
-    /// Attempts to write an entire buffer into this write.
-    ///
-    /// This method will continuously call `write` while there is more data to
-    /// write. This method will not return until the entire buffer has been
-    /// successfully written or an error occurs. The first error generated from
-    /// this method will be returned.
-    ///
-    /// # Errors
-    ///
-    /// This function will return the first error that `write` returns.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::io::prelude::*;
-    /// use std::fs::File;
-    ///
-    /// # fn foo() -> std::io::Result<()> {
-    /// let mut buffer = try!(File::create("foo.txt"));
-    ///
-    /// try!(buffer.write_all(b"some bytes"));
-    /// # Ok(())
-    /// # }
-    /// ```
-    fn write_all(&mut self, mut buf: &[u8]) -> Result<()> {
-        while !buf.is_empty() {
-            match self.write(buf) {
-                Ok(0) => return Err(Error::new(ErrorKind::WriteZero,
-                                               "failed to write whole buffer")),
-                Ok(n) => buf = &buf[n..],
-                Err(ref e) if e.kind() == ErrorKind::Interrupted => {}
-                Err(e) => return Err(e),
-            }
-        }
-        Ok(())
-    }
-
-    /// Writes a formatted string into this writer, returning any error
-    /// encountered.
-    ///
-    /// This method is primarily used to interface with the
-    /// [`format_args!`][formatargs] macro, but it is rare that this should
-    /// explicitly be called. The [`write!`][write] macro should be favored to
-    /// invoke this method instead.
-    ///
-    /// [formatargs]: ../macro.format_args.html
-    /// [write]: ../macro.write.html
-    ///
-    /// This function internally uses the [`write_all`][writeall] method on
-    /// this trait and hence will continuously write data so long as no errors
-    /// are received. This also means that partial writes are not indicated in
-    /// this signature.
-    ///
-    /// [writeall]: #method.write_all
-    ///
-    /// # Errors
-    ///
-    /// This function will return any I/O error reported while formatting.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::io::prelude::*;
-    /// use std::fs::File;
-    ///
-    /// # fn foo() -> std::io::Result<()> {
-    /// let mut buffer = try!(File::create("foo.txt"));
-    ///
-    /// // this call
-    /// try!(write!(buffer, "{:.*}", 2, 1.234567));
-    /// // turns into this:
-    /// try!(buffer.write_fmt(format_args!("{:.*}", 2, 1.234567)));
-    /// # Ok(())
-    /// # }
-    /// ```
-    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<()> {
-        // Create a shim which translates a Write to a fmt::Write and saves
-        // off I/O errors. instead of discarding them
-        struct Adaptor<'a, T: ?Sized + 'a> {
-            inner: &'a mut T,
-            error: Result<()>,
-        }
-
-        impl<'a, T: Write + ?Sized> fmt::Write for Adaptor<'a, T> {
-            fn write_str(&mut self, s: &str) -> fmt::Result {
-                match self.inner.write_all(s.as_bytes()) {
-                    Ok(()) => Ok(()),
-                    Err(e) => {
-                        self.error = Err(e);
-                        Err(fmt::Error)
-                    }
-                }
-            }
-        }
-
-        let mut output = Adaptor { inner: self, error: Ok(()) };
-        match fmt::write(&mut output, fmt) {
-            Ok(()) => Ok(()),
-            Err(..) => {
-                // check if the error came from the underlying `Write` or not
-                if output.error.is_err() {
-                    output.error
-                } else {
-                    Err(Error::new(ErrorKind::Other, "formatter error"))
-                }
-            }
-        }
-    }
-
-    /// Creates a "by reference" adaptor for this instance of `Write`.
-    ///
-    /// The returned adaptor also implements `Write` and will simply borrow this
-    /// current writer.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::io::Write;
-    /// use std::fs::File;
-    ///
-    /// # fn foo() -> std::io::Result<()> {
-    /// let mut buffer = try!(File::create("foo.txt"));
-    ///
-    /// let reference = buffer.by_ref();
-    ///
-    /// // we can use reference just like our original buffer
-    /// try!(reference.write_all(b"some bytes"));
-    /// # Ok(())
-    /// # }
-    /// ```
-    fn by_ref(&mut self) -> &mut Self where Self: Sized { self }
-}
-
-/// The `Seek` trait provides a cursor which can be moved within a stream of
-/// bytes.
-///
-/// The stream typically has a fixed size, allowing seeking relative to either
-/// end or the current offset.
-///
-/// # Examples
-///
-/// [`File`][file]s implement `Seek`:
-///
-/// [file]: ../fs/struct.File.html
-///
-/// ```
-/// use std::io;
-/// use std::io::prelude::*;
-/// use std::fs::File;
-/// use std::io::SeekFrom;
-///
-/// # fn foo() -> io::Result<()> {
-/// let mut f = try!(File::open("foo.txt"));
-///
-/// // move the cursor 42 bytes from the start of the file
-/// try!(f.seek(SeekFrom::Start(42)));
-/// # Ok(())
-/// # }
-/// ```
-pub trait Seek {
-    /// Seek to an offset, in bytes, in a stream.
-    ///
-    /// A seek beyond the end of a stream is allowed, but implementation
-    /// defined.
-    ///
-    /// If the seek operation completed successfully,
-    /// this method returns the new position from the start of the stream.
-    /// That position can be used later with [`SeekFrom::Start`].
-    ///
-    /// # Errors
-    ///
-    /// Seeking to a negative offset is considered an error.
-    ///
-    /// [`SeekFrom::Start`]: enum.SeekFrom.html#variant.Start
-    fn seek(&mut self, pos: SeekFrom) -> Result<u64>;
-}
-
-/// Enumeration of possible methods to seek within an I/O object.
-///
-/// It is used by the [`Seek`] trait.
-///
-/// [`Seek`]: trait.Seek.html
-#[derive(Copy, PartialEq, Eq, Clone, Debug)]
-pub enum SeekFrom {
-    /// Set the offset to the provided number of bytes.
-    Start(u64),
-
-    /// Set the offset to the size of this object plus the specified number of
-    /// bytes.
-    ///
-    /// It is possible to seek beyond the end of an object, but it's an error to
-    /// seek before byte 0.
-    End(i64),
-
-    /// Set the offset to the current position plus the specified number of
-    /// bytes.
-    ///
-    /// It is possible to seek beyond the end of an object, but it's an error to
-    /// seek before byte 0.
-    Current(i64),
-}
-
-fn read_until<R: BufRead + ?Sized>(r: &mut R, delim: u8, buf: &mut Vec<u8>)
-                                   -> Result<usize> {
-    let mut read = 0;
-    loop {
-        let (done, used) = {
-            let available = match r.fill_buf() {
-                Ok(n) => n,
-                Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
-                Err(e) => return Err(e)
-            };
-            match memchr::memchr(delim, available) {
-                Some(i) => {
-                    buf.extend_from_slice(&available[..i + 1]);
-                    (true, i + 1)
-                }
-                None => {
-                    buf.extend_from_slice(available);
-                    (false, available.len())
-                }
-            }
-        };
-        r.consume(used);
-        read += used;
-        if done || used == 0 {
-            return Ok(read);
-        }
-    }
-}
-
-/// A `BufRead` is a type of `Read`er which has an internal buffer, allowing it
-/// to perform extra ways of reading.
-///
-/// For example, reading line-by-line is inefficient without using a buffer, so
-/// if you want to read by line, you'll need `BufRead`, which includes a
-/// [`read_line()`][readline] method as well as a [`lines()`][lines] iterator.
-///
-/// [readline]: #method.read_line
-/// [lines]: #method.lines
-///
-/// # Examples
-///
-/// A locked standard input implements `BufRead`:
-///
-/// ```
-/// use std::io;
-/// use std::io::prelude::*;
-///
-/// let stdin = io::stdin();
-/// for line in stdin.lock().lines() {
-///     println!("{}", line.unwrap());
-/// }
-/// ```
-///
-/// If you have something that implements `Read`, you can use the [`BufReader`
-/// type][bufreader] to turn it into a `BufRead`.
-///
-/// For example, [`File`][file] implements `Read`, but not `BufRead`.
-/// `BufReader` to the rescue!
-///
-/// [bufreader]: struct.BufReader.html
-/// [file]: ../fs/struct.File.html
-///
-/// ```
-/// use std::io::{self, BufReader};
-/// use std::io::prelude::*;
-/// use std::fs::File;
-///
-/// # fn foo() -> io::Result<()> {
-/// let f = try!(File::open("foo.txt"));
-/// let f = BufReader::new(f);
-///
-/// for line in f.lines() {
-///     println!("{}", line.unwrap());
-/// }
-///
-/// # Ok(())
-/// # }
-/// ```
-///
-pub trait BufRead: Read {
-    /// Fills the internal buffer of this object, returning the buffer contents.
-    ///
-    /// This function is a lower-level call. It needs to be paired with the
-    /// [`consume`][consume] method to function properly. When calling this
-    /// method, none of the contents will be "read" in the sense that later
-    /// calling `read` may return the same contents. As such, `consume` must be
-    /// called with the number of bytes that are consumed from this buffer to
-    /// ensure that the bytes are never returned twice.
-    ///
-    /// [consume]: #tymethod.consume
-    ///
-    /// An empty buffer returned indicates that the stream has reached EOF.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an I/O error if the underlying reader was
-    /// read, but returned an error.
-    ///
-    /// # Examples
-    ///
-    /// A locked standard input implements `BufRead`:
-    ///
-    /// ```
-    /// use std::io;
-    /// use std::io::prelude::*;
-    ///
-    /// let stdin = io::stdin();
-    /// let mut stdin = stdin.lock();
-    ///
-    /// // we can't have two `&mut` references to `stdin`, so use a block
-    /// // to end the borrow early.
-    /// let length = {
-    ///     let buffer = stdin.fill_buf().unwrap();
-    ///
-    ///     // work with buffer
-    ///     println!("{:?}", buffer);
-    ///
-    ///     buffer.len()
-    /// };
-    ///
-    /// // ensure the bytes we worked with aren't returned again later
-    /// stdin.consume(length);
-    /// ```
-    fn fill_buf(&mut self) -> Result<&[u8]>;
-
-    /// Tells this buffer that `amt` bytes have been consumed from the buffer,
-    /// so they should no longer be returned in calls to `read`.
-    ///
-    /// This function is a lower-level call. It needs to be paired with the
-    /// [`fill_buf`][fillbuf] method to function properly. This function does
-    /// not perform any I/O, it simply informs this object that some amount of
-    /// its buffer, returned from `fill_buf`, has been consumed and should no
-    /// longer be returned. As such, this function may do odd things if
-    /// `fill_buf` isn't called before calling it.
-    ///
-    /// [fillbuf]: #tymethod.fill_buf
-    ///
-    /// The `amt` must be `<=` the number of bytes in the buffer returned by
-    /// `fill_buf`.
-    ///
-    /// # Examples
-    ///
-    /// Since `consume()` is meant to be used with [`fill_buf()`][fillbuf],
-    /// that method's example includes an example of `consume()`.
-    fn consume(&mut self, amt: usize);
-
-    /// Read all bytes into `buf` until the delimiter `byte` is reached.
-    ///
-    /// This function will read bytes from the underlying stream until the
-    /// delimiter or EOF is found. Once found, all bytes up to, and including,
-    /// the delimiter (if found) will be appended to `buf`.
-    ///
-    /// If this reader is currently at EOF then this function will not modify
-    /// `buf` and will return `Ok(n)` where `n` is the number of bytes which
-    /// were read.
-    ///
-    /// # Errors
-    ///
-    /// This function will ignore all instances of `ErrorKind::Interrupted` and
-    /// will otherwise return any errors returned by `fill_buf`.
-    ///
-    /// If an I/O error is encountered then all bytes read so far will be
-    /// present in `buf` and its length will have been adjusted appropriately.
-    ///
-    /// # Examples
-    ///
-    /// A locked standard input implements `BufRead`. In this example, we'll
-    /// read from standard input until we see an `a` byte.
-    ///
-    /// ```
-    /// use std::io;
-    /// use std::io::prelude::*;
-    ///
-    /// fn foo() -> io::Result<()> {
-    /// let stdin = io::stdin();
-    /// let mut stdin = stdin.lock();
-    /// let mut buffer = Vec::new();
-    ///
-    /// try!(stdin.read_until(b'a', &mut buffer));
-    ///
-    /// println!("{:?}", buffer);
-    /// # Ok(())
-    /// # }
-    /// ```
-    fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<usize> {
-        read_until(self, byte, buf)
-    }
-
-    /// Read all bytes until a newline (the 0xA byte) is reached, and append
-    /// them to the provided buffer.
-    ///
-    /// This function will read bytes from the underlying stream until the
-    /// newline delimiter (the 0xA byte) or EOF is found. Once found, all bytes
-    /// up to, and including, the delimiter (if found) will be appended to
-    /// `buf`.
-    ///
-    /// If this reader is currently at EOF then this function will not modify
-    /// `buf` and will return `Ok(n)` where `n` is the number of bytes which
-    /// were read.
-    ///
-    /// # Errors
-    ///
-    /// This function has the same error semantics as `read_until` and will also
-    /// return an error if the read bytes are not valid UTF-8. If an I/O error
-    /// is encountered then `buf` may contain some bytes already read in the
-    /// event that all data read so far was valid UTF-8.
-    ///
-    /// # Examples
-    ///
-    /// A locked standard input implements `BufRead`. In this example, we'll
-    /// read all of the lines from standard input. If we were to do this in
-    /// an actual project, the [`lines()`][lines] method would be easier, of
-    /// course.
-    ///
-    /// [lines]: #method.lines
-    ///
-    /// ```
-    /// use std::io;
-    /// use std::io::prelude::*;
-    ///
-    /// let stdin = io::stdin();
-    /// let mut stdin = stdin.lock();
-    /// let mut buffer = String::new();
-    ///
-    /// while stdin.read_line(&mut buffer).unwrap() > 0 {
-    ///     // work with buffer
-    ///     println!("{:?}", buffer);
-    ///
-    ///     buffer.clear();
-    /// }
-    /// ```
-    fn read_line(&mut self, buf: &mut String) -> Result<usize> {
-        // Note that we are not calling the `.read_until` method here, but
-        // rather our hardcoded implementation. For more details as to why, see
-        // the comments in `read_to_end`.
-        append_to_string(buf, |b| read_until(self, b'\n', b))
-    }
-
-    /// Returns an iterator over the contents of this reader split on the byte
-    /// `byte`.
-    ///
-    /// The iterator returned from this function will return instances of
-    /// `io::Result<Vec<u8>>`. Each vector returned will *not* have the
-    /// delimiter byte at the end.
-    ///
-    /// This function will yield errors whenever `read_until` would have also
-    /// yielded an error.
-    ///
-    /// # Examples
-    ///
-    /// A locked standard input implements `BufRead`. In this example, we'll
-    /// read some input from standard input, splitting on commas.
-    ///
-    /// ```
-    /// use std::io;
-    /// use std::io::prelude::*;
-    ///
-    /// let stdin = io::stdin();
-    ///
-    /// for content in stdin.lock().split(b',') {
-    ///     println!("{:?}", content.unwrap());
-    /// }
-    /// ```
-    fn split(self, byte: u8) -> Split<Self> where Self: Sized {
-        Split { buf: self, delim: byte }
-    }
-
-    /// Returns an iterator over the lines of this reader.
-    ///
-    /// The iterator returned from this function will yield instances of
-    /// `io::Result<String>`. Each string returned will *not* have a newline
-    /// byte (the 0xA byte) or CRLF (0xD, 0xA bytes) at the end.
-    ///
-    /// # Examples
-    ///
-    /// A locked standard input implements `BufRead`:
-    ///
-    /// ```
-    /// use std::io;
-    /// use std::io::prelude::*;
-    ///
-    /// let stdin = io::stdin();
-    ///
-    /// for line in stdin.lock().lines() {
-    ///     println!("{}", line.unwrap());
-    /// }
-    /// ```
-    fn lines(self) -> Lines<Self> where Self: Sized {
-        Lines { buf: self }
-    }
-}
-
-/// Adaptor to chain together two readers.
-///
-/// This struct is generally created by calling [`chain()`][chain] on a reader.
-/// Please see the documentation of `chain()` for more details.
-///
-/// [chain]: trait.Read.html#method.chain
-pub struct Chain<T, U> {
-    first: T,
-    second: U,
-    done_first: bool,
-}
-
-impl<T: Read, U: Read> Read for Chain<T, U> {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
-        if !self.done_first {
-            match self.first.read(buf)? {
-                0 => { self.done_first = true; }
-                n => return Ok(n),
-            }
-        }
-        self.second.read(buf)
-    }
-}
-
-impl<T: BufRead, U: BufRead> BufRead for Chain<T, U> {
-    fn fill_buf(&mut self) -> Result<&[u8]> {
-        if !self.done_first {
-            match self.first.fill_buf()? {
-                buf if buf.len() == 0 => { self.done_first = true; }
-                buf => return Ok(buf),
-            }
-        }
-        self.second.fill_buf()
-    }
-
-    fn consume(&mut self, amt: usize) {
-        if !self.done_first {
-            self.first.consume(amt)
-        } else {
-            self.second.consume(amt)
-        }
-    }
-}
-
-/// Reader adaptor which limits the bytes read from an underlying reader.
-///
-/// This struct is generally created by calling [`take()`][take] on a reader.
-/// Please see the documentation of `take()` for more details.
-///
-/// [take]: trait.Read.html#method.take
-pub struct Take<T> {
-    inner: T,
-    limit: u64,
-}
-
-impl<T> Take<T> {
-    /// Returns the number of bytes that can be read before this instance will
-    /// return EOF.
-    ///
-    /// # Note
-    ///
-    /// This instance may reach EOF after reading fewer bytes than indicated by
-    /// this method if the underlying `Read` instance reaches EOF.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::io;
-    /// use std::io::prelude::*;
-    /// use std::fs::File;
-    ///
-    /// # fn foo() -> io::Result<()> {
-    /// let f = try!(File::open("foo.txt"));
-    ///
-    /// // read at most five bytes
-    /// let handle = f.take(5);
-    ///
-    /// println!("limit: {}", handle.limit());
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn limit(&self) -> u64 { self.limit }
-}
-
-impl<T: Read> Read for Take<T> {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
-        // Don't call into inner reader at all at EOF because it may still block
-        if self.limit == 0 {
-            return Ok(0);
-        }
-
-        let max = cmp::min(buf.len() as u64, self.limit) as usize;
-        let n = self.inner.read(&mut buf[..max])?;
-        self.limit -= n as u64;
-        Ok(n)
-    }
-}
-
-impl<T: BufRead> BufRead for Take<T> {
-    fn fill_buf(&mut self) -> Result<&[u8]> {
-        // Don't call into inner reader at all at EOF because it may still block
-        if self.limit == 0 {
-            return Ok(&[]);
-        }
-
-        let buf = self.inner.fill_buf()?;
-        let cap = cmp::min(buf.len() as u64, self.limit) as usize;
-        Ok(&buf[..cap])
-    }
-
-    fn consume(&mut self, amt: usize) {
-        // Don't let callers reset the limit by passing an overlarge value
-        let amt = cmp::min(amt as u64, self.limit) as usize;
-        self.limit -= amt as u64;
-        self.inner.consume(amt);
-    }
-}
-
-fn read_one_byte(reader: &mut Read) -> Option<Result<u8>> {
-    let mut buf = [0];
-    loop {
-        return match reader.read(&mut buf) {
-            Ok(0) => None,
-            Ok(..) => Some(Ok(buf[0])),
-            Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
-            Err(e) => Some(Err(e)),
-        };
-    }
-}
-
-/// An iterator over `u8` values of a reader.
-///
-/// This struct is generally created by calling [`bytes()`][bytes] on a reader.
-/// Please see the documentation of `bytes()` for more details.
-///
-/// [bytes]: trait.Read.html#method.bytes
-pub struct Bytes<R> {
-    inner: R,
-}
-
-impl<R: Read> Iterator for Bytes<R> {
-    type Item = Result<u8>;
-
-    fn next(&mut self) -> Option<Result<u8>> {
-        read_one_byte(&mut self.inner)
-    }
-}
-
-/// An iterator over the `char`s of a reader.
-///
-/// This struct is generally created by calling [`chars()`][chars] on a reader.
-/// Please see the documentation of `chars()` for more details.
-///
-/// [chars]: trait.Read.html#method.chars
-pub struct Chars<R> {
-    inner: R,
-}
-
-/// An enumeration of possible errors that can be generated from the `Chars`
-/// adapter.
-#[derive(Debug)]
-pub enum CharsError {
-    /// Variant representing that the underlying stream was read successfully
-    /// but it did not contain valid utf8 data.
-    NotUtf8,
-
-    /// Variant representing that an I/O error occurred.
-    Other(Error),
-}
-
-impl<R: Read> Iterator for Chars<R> {
-    type Item = result::Result<char, CharsError>;
-
-    fn next(&mut self) -> Option<result::Result<char, CharsError>> {
-        let first_byte = match read_one_byte(&mut self.inner) {
-            None => return None,
-            Some(Ok(b)) => b,
-            Some(Err(e)) => return Some(Err(CharsError::Other(e))),
-        };
-        let width = core_str::utf8_char_width(first_byte);
-        if width == 1 { return Some(Ok(first_byte as char)) }
-        if width == 0 { return Some(Err(CharsError::NotUtf8)) }
-        let mut buf = [first_byte, 0, 0, 0];
-        {
-            let mut start = 1;
-            while start < width {
-                match self.inner.read(&mut buf[start..width]) {
-                    Ok(0) => return Some(Err(CharsError::NotUtf8)),
-                    Ok(n) => start += n,
-                    Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
-                    Err(e) => return Some(Err(CharsError::Other(e))),
-                }
-            }
-        }
-        Some(match str::from_utf8(&buf[..width]).ok() {
-            Some(s) => Ok(s.chars().next().unwrap()),
-            None => Err(CharsError::NotUtf8),
-        })
-    }
-}
-
-impl std_error::Error for CharsError {
-    fn description(&self) -> &str {
-        match *self {
-            CharsError::NotUtf8 => "invalid utf8 encoding",
-            CharsError::Other(ref e) => std_error::Error::description(e),
-        }
-    }
-    fn cause(&self) -> Option<&std_error::Error> {
-        match *self {
-            CharsError::NotUtf8 => None,
-            CharsError::Other(ref e) => e.cause(),
-        }
-    }
-}
-
-impl fmt::Display for CharsError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            CharsError::NotUtf8 => {
-                "byte stream did not contain valid utf8".fmt(f)
-            }
-            CharsError::Other(ref e) => e.fmt(f),
-        }
-    }
-}
-
-/// An iterator over the contents of an instance of `BufRead` split on a
-/// particular byte.
-///
-/// This struct is generally created by calling [`split()`][split] on a
-/// `BufRead`. Please see the documentation of `split()` for more details.
-///
-/// [split]: trait.BufRead.html#method.split
-pub struct Split<B> {
-    buf: B,
-    delim: u8,
-}
-
-impl<B: BufRead> Iterator for Split<B> {
-    type Item = Result<Vec<u8>>;
-
-    fn next(&mut self) -> Option<Result<Vec<u8>>> {
-        let mut buf = Vec::new();
-        match self.buf.read_until(self.delim, &mut buf) {
-            Ok(0) => None,
-            Ok(_n) => {
-                if buf[buf.len() - 1] == self.delim {
-                    buf.pop();
-                }
-                Some(Ok(buf))
-            }
-            Err(e) => Some(Err(e))
-        }
-    }
-}
-
-/// An iterator over the lines of an instance of `BufRead`.
-///
-/// This struct is generally created by calling [`lines()`][lines] on a
-/// `BufRead`. Please see the documentation of `lines()` for more details.
-///
-/// [lines]: trait.BufRead.html#method.lines
-pub struct Lines<B> {
-    buf: B,
-}
-
-impl<B: BufRead> Iterator for Lines<B> {
-    type Item = Result<String>;
-
-    fn next(&mut self) -> Option<Result<String>> {
-        let mut buf = String::new();
-        match self.buf.read_line(&mut buf) {
-            Ok(0) => None,
-            Ok(_n) => {
-                if buf.ends_with("\n") {
-                    buf.pop();
-                    if buf.ends_with("\r") {
-                        buf.pop();
-                    }
-                }
-                Some(Ok(buf))
-            }
-            Err(e) => Some(Err(e))
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use io::prelude::*;
-    use io;
-    use super::Cursor;
-    use super::repeat;
-    use test;
-
-    use collections::{Vec, String};
-    use collections::string::ToString;
-
-    #[test]
-    fn read_until() {
-        let mut buf = Cursor::new(&b"12"[..]);
-        let mut v = Vec::new();
-        assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 2);
-        assert_eq!(v, b"12");
-
-        let mut buf = Cursor::new(&b"1233"[..]);
-        let mut v = Vec::new();
-        assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 3);
-        assert_eq!(v, b"123");
-        v.truncate(0);
-        assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 1);
-        assert_eq!(v, b"3");
-        v.truncate(0);
-        assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 0);
-        assert_eq!(v, []);
-    }
-
-    #[test]
-    fn split() {
-        let buf = Cursor::new(&b"12"[..]);
-        let mut s = buf.split(b'3');
-        assert_eq!(s.next().unwrap().unwrap(), vec![b'1', b'2']);
-        assert!(s.next().is_none());
-
-        let buf = Cursor::new(&b"1233"[..]);
-        let mut s = buf.split(b'3');
-        assert_eq!(s.next().unwrap().unwrap(), vec![b'1', b'2']);
-        assert_eq!(s.next().unwrap().unwrap(), vec![]);
-        assert!(s.next().is_none());
-    }
-
-    #[test]
-    fn read_line() {
-        let mut buf = Cursor::new(&b"12"[..]);
-        let mut v = String::new();
-        assert_eq!(buf.read_line(&mut v).unwrap(), 2);
-        assert_eq!(v, "12");
-
-        let mut buf = Cursor::new(&b"12\n\n"[..]);
-        let mut v = String::new();
-        assert_eq!(buf.read_line(&mut v).unwrap(), 3);
-        assert_eq!(v, "12\n");
-        v.truncate(0);
-        assert_eq!(buf.read_line(&mut v).unwrap(), 1);
-        assert_eq!(v, "\n");
-        v.truncate(0);
-        assert_eq!(buf.read_line(&mut v).unwrap(), 0);
-        assert_eq!(v, "");
-    }
-
-    #[test]
-    fn lines() {
-        let buf = Cursor::new(&b"12\r"[..]);
-        let mut s = buf.lines();
-        assert_eq!(s.next().unwrap().unwrap(), "12\r".to_string());
-        assert!(s.next().is_none());
-
-        let buf = Cursor::new(&b"12\r\n\n"[..]);
-        let mut s = buf.lines();
-        assert_eq!(s.next().unwrap().unwrap(), "12".to_string());
-        assert_eq!(s.next().unwrap().unwrap(), "".to_string());
-        assert!(s.next().is_none());
-    }
-
-    #[test]
-    fn read_to_end() {
-        let mut c = Cursor::new(&b""[..]);
-        let mut v = Vec::new();
-        assert_eq!(c.read_to_end(&mut v).unwrap(), 0);
-        assert_eq!(v, []);
-
-        let mut c = Cursor::new(&b"1"[..]);
-        let mut v = Vec::new();
-        assert_eq!(c.read_to_end(&mut v).unwrap(), 1);
-        assert_eq!(v, b"1");
-
-        let cap = 1024 * 1024;
-        let data = (0..cap).map(|i| (i / 3) as u8).collect::<Vec<_>>();
-        let mut v = Vec::new();
-        let (a, b) = data.split_at(data.len() / 2);
-        assert_eq!(Cursor::new(a).read_to_end(&mut v).unwrap(), a.len());
-        assert_eq!(Cursor::new(b).read_to_end(&mut v).unwrap(), b.len());
-        assert_eq!(v, data);
-    }
-
-    #[test]
-    fn read_to_string() {
-        let mut c = Cursor::new(&b""[..]);
-        let mut v = String::new();
-        assert_eq!(c.read_to_string(&mut v).unwrap(), 0);
-        assert_eq!(v, "");
-
-        let mut c = Cursor::new(&b"1"[..]);
-        let mut v = String::new();
-        assert_eq!(c.read_to_string(&mut v).unwrap(), 1);
-        assert_eq!(v, "1");
-
-        let mut c = Cursor::new(&b"\xff"[..]);
-        let mut v = String::new();
-        assert!(c.read_to_string(&mut v).is_err());
-    }
-
-    #[test]
-    fn read_exact() {
-        let mut buf = [0; 4];
-
-        let mut c = Cursor::new(&b""[..]);
-        assert_eq!(c.read_exact(&mut buf).unwrap_err().kind(),
-                   io::ErrorKind::UnexpectedEof);
-
-        let mut c = Cursor::new(&b"123"[..]).chain(Cursor::new(&b"456789"[..]));
-        c.read_exact(&mut buf).unwrap();
-        assert_eq!(&buf, b"1234");
-        c.read_exact(&mut buf).unwrap();
-        assert_eq!(&buf, b"5678");
-        assert_eq!(c.read_exact(&mut buf).unwrap_err().kind(),
-                   io::ErrorKind::UnexpectedEof);
-    }
-
-    #[test]
-    fn read_exact_slice() {
-        let mut buf = [0; 4];
-
-        let mut c = &b""[..];
-        assert_eq!(c.read_exact(&mut buf).unwrap_err().kind(),
-                   io::ErrorKind::UnexpectedEof);
-
-        let mut c = &b"123"[..];
-        assert_eq!(c.read_exact(&mut buf).unwrap_err().kind(),
-                   io::ErrorKind::UnexpectedEof);
-        // make sure the optimized (early returning) method is being used
-        assert_eq!(&buf, &[0; 4]);
-
-        let mut c = &b"1234"[..];
-        c.read_exact(&mut buf).unwrap();
-        assert_eq!(&buf, b"1234");
-
-        let mut c = &b"56789"[..];
-        c.read_exact(&mut buf).unwrap();
-        assert_eq!(&buf, b"5678");
-        assert_eq!(c, b"9");
-    }
-
-    #[test]
-    fn take_eof() {
-        struct R;
-
-        impl Read for R {
-            fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
-                Err(io::Error::new(io::ErrorKind::Other, ""))
-            }
-        }
-        impl BufRead for R {
-            fn fill_buf(&mut self) -> io::Result<&[u8]> {
-                Err(io::Error::new(io::ErrorKind::Other, ""))
-            }
-            fn consume(&mut self, _amt: usize) { }
-        }
-
-        let mut buf = [0; 1];
-        assert_eq!(0, R.take(0).read(&mut buf).unwrap());
-        assert_eq!(b"", R.take(0).fill_buf().unwrap());
-    }
-
-    fn cmp_bufread<Br1: BufRead, Br2: BufRead>(mut br1: Br1, mut br2: Br2, exp: &[u8]) {
-        let mut cat = Vec::new();
-        loop {
-            let consume = {
-                let buf1 = br1.fill_buf().unwrap();
-                let buf2 = br2.fill_buf().unwrap();
-                let minlen = if buf1.len() < buf2.len() { buf1.len() } else { buf2.len() };
-                assert_eq!(buf1[..minlen], buf2[..minlen]);
-                cat.extend_from_slice(&buf1[..minlen]);
-                minlen
-            };
-            if consume == 0 {
-                break;
-            }
-            br1.consume(consume);
-            br2.consume(consume);
-        }
-        assert_eq!(br1.fill_buf().unwrap().len(), 0);
-        assert_eq!(br2.fill_buf().unwrap().len(), 0);
-        assert_eq!(&cat[..], &exp[..])
-    }
-
-    #[test]
-    fn chain_bufread() {
-        let testdata = b"ABCDEFGHIJKL";
-        let chain1 = (&testdata[..3]).chain(&testdata[3..6])
-                                     .chain(&testdata[6..9])
-                                     .chain(&testdata[9..]);
-        let chain2 = (&testdata[..4]).chain(&testdata[4..8])
-                                     .chain(&testdata[8..]);
-        cmp_bufread(chain1, chain2, &testdata[..]);
-    }
-
-    #[bench]
-    fn bench_read_to_end(b: &mut test::Bencher) {
-        b.iter(|| {
-            let mut lr = repeat(1).take(10000000);
-            let mut vec = Vec::with_capacity(1024);
-            super::read_to_end(&mut lr, &mut vec)
-        });
-    }
-}
diff --git a/src/system/io/prelude.rs b/src/system/io/prelude.rs
deleted file mode 100644
index 8f209e5..0000000
--- a/src/system/io/prelude.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-// 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! The I/O Prelude
-//!
-//! The purpose of this module is to alleviate imports of many common I/O traits
-//! by adding a glob import to the top of I/O heavy modules:
-//!
-//! ```
-//! # #![allow(unused_imports)]
-//! use std::io::prelude::*;
-//! ```
-
-
-pub use super::{Read, Write, BufRead, Seek};
diff --git a/src/system/io/util.rs b/src/system/io/util.rs
deleted file mode 100644
index 7b24cd4..0000000
--- a/src/system/io/util.rs
+++ /dev/null
@@ -1,204 +0,0 @@
-// Copyright 2014 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![allow(missing_copy_implementations)]
-
-use std::io::{self, Read, Write, ErrorKind, BufRead};
-
-/// Copies the entire contents of a reader into a writer.
-///
-/// This function will continuously read data from `reader` and then
-/// write it into `writer` in a streaming fashion until `reader`
-/// returns EOF.
-///
-/// On success, the total number of bytes that were copied from
-/// `reader` to `writer` is returned.
-///
-/// # Errors
-///
-/// This function will return an error immediately if any call to `read` or
-/// `write` returns an error. All instances of `ErrorKind::Interrupted` are
-/// handled by this function and the underlying operation is retried.
-///
-/// # Examples
-///
-/// ```
-/// use std::io;
-///
-/// # fn foo() -> io::Result<()> {
-/// let mut reader: &[u8] = b"hello";
-/// let mut writer: Vec<u8> = vec![];
-///
-/// try!(io::copy(&mut reader, &mut writer));
-///
-/// assert_eq!(reader, &writer[..]);
-/// # Ok(())
-/// # }
-/// ```
-pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> io::Result<u64>
-    where R: Read, W: Write
-{
-    let mut buf = [0; super::DEFAULT_BUF_SIZE];
-    let mut written = 0;
-    loop {
-        let len = match reader.read(&mut buf) {
-            Ok(0) => return Ok(written),
-            Ok(len) => len,
-            Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
-            Err(e) => return Err(e),
-        };
-        writer.write_all(&buf[..len])?;
-        written += len as u64;
-    }
-}
-
-/// A reader which is always at EOF.
-///
-/// This struct is generally created by calling [`empty()`][empty]. Please see
-/// the documentation of `empty()` for more details.
-///
-/// [empty]: fn.empty.html
-pub struct Empty { _priv: () }
-
-/// Constructs a new handle to an empty reader.
-///
-/// All reads from the returned reader will return `Ok(0)`.
-///
-/// # Examples
-///
-/// A slightly sad example of not reading anything into a buffer:
-///
-/// ```
-/// use std::io::{self, Read};
-///
-/// let mut buffer = String::new();
-/// io::empty().read_to_string(&mut buffer).unwrap();
-/// assert!(buffer.is_empty());
-/// ```
-pub fn empty() -> Empty { Empty { _priv: () } }
-
-impl Read for Empty {
-    fn read(&mut self, _buf: &mut [u8]) -> io::Result<usize> { Ok(0) }
-}
-impl BufRead for Empty {
-    fn fill_buf(&mut self) -> io::Result<&[u8]> { Ok(&[]) }
-    fn consume(&mut self, _n: usize) {}
-}
-
-/// A reader which yields one byte over and over and over and over and over and...
-///
-/// This struct is generally created by calling [`repeat()`][repeat]. Please
-/// see the documentation of `repeat()` for more details.
-///
-/// [repeat]: fn.repeat.html
-pub struct Repeat { byte: u8 }
-
-/// Creates an instance of a reader that infinitely repeats one byte.
-///
-/// All reads from this reader will succeed by filling the specified buffer with
-/// the given byte.
-///
-/// # Examples
-///
-/// ```
-/// use std::io::{self, Read};
-///
-/// let mut buffer = [0; 3];
-/// io::repeat(0b101).read_exact(&mut buffer).unwrap();
-/// assert_eq!(buffer, [0b101, 0b101, 0b101]);
-/// ```
-pub fn repeat(byte: u8) -> Repeat { Repeat { byte: byte } }
-
-impl Read for Repeat {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        for slot in &mut *buf {
-            *slot = self.byte;
-        }
-        Ok(buf.len())
-    }
-}
-
-/// A writer which will move data into the void.
-///
-/// This struct is generally created by calling [`sink()`][sink]. Please
-/// see the documentation of `sink()` for more details.
-///
-/// [sink]: fn.sink.html
-pub struct Sink { _priv: () }
-
-/// Creates an instance of a writer which will successfully consume all data.
-///
-/// All calls to `write` on the returned instance will return `Ok(buf.len())`
-/// and the contents of the buffer will not be inspected.
-///
-/// # Examples
-///
-/// ```rust
-/// use std::io::{self, Write};
-///
-/// let buffer = vec![1, 2, 3, 5, 8];
-/// let num_bytes = io::sink().write(&buffer).unwrap();
-/// assert_eq!(num_bytes, 5);
-/// ```
-pub fn sink() -> Sink { Sink { _priv: () } }
-
-impl Write for Sink {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> { Ok(buf.len()) }
-    fn flush(&mut self) -> io::Result<()> { Ok(()) }
-}
-
-#[cfg(test)]
-mod tests {
-    use io::prelude::*;
-    use io::{copy, sink, empty, repeat};
-
-    #[test]
-    fn copy_copies() {
-        let mut r = repeat(0).take(4);
-        let mut w = sink();
-        assert_eq!(copy(&mut r, &mut w).unwrap(), 4);
-
-        let mut r = repeat(0).take(1 << 17);
-        assert_eq!(copy(&mut r as &mut Read, &mut w as &mut Write).unwrap(), 1 << 17);
-    }
-
-    #[test]
-    fn sink_sinks() {
-        let mut s = sink();
-        assert_eq!(s.write(&[]).unwrap(), 0);
-        assert_eq!(s.write(&[0]).unwrap(), 1);
-        assert_eq!(s.write(&[0; 1024]).unwrap(), 1024);
-        assert_eq!(s.by_ref().write(&[0; 1024]).unwrap(), 1024);
-    }
-
-    #[test]
-    fn empty_reads() {
-        let mut e = empty();
-        assert_eq!(e.read(&mut []).unwrap(), 0);
-        assert_eq!(e.read(&mut [0]).unwrap(), 0);
-        assert_eq!(e.read(&mut [0; 1024]).unwrap(), 0);
-        assert_eq!(e.by_ref().read(&mut [0; 1024]).unwrap(), 0);
-    }
-
-    #[test]
-    fn repeat_repeats() {
-        let mut r = repeat(4);
-        let mut b = [0; 1024];
-        assert_eq!(r.read(&mut b).unwrap(), 1024);
-        assert!(b.iter().all(|b| *b == 4));
-    }
-
-    #[test]
-    fn take_some_bytes() {
-        assert_eq!(repeat(4).take(100).bytes().count(), 100);
-        assert_eq!(repeat(4).take(100).bytes().next().unwrap().unwrap(), 4);
-        assert_eq!(repeat(1).take(10).chain(repeat(2).take(10)).bytes().count(), 20);
-    }
-}
diff --git a/src/system/memchr.rs b/src/system/memchr.rs
deleted file mode 100644
index 210ba80..0000000
--- a/src/system/memchr.rs
+++ /dev/null
@@ -1,397 +0,0 @@
-// 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-//
-// Original implementation taken from rust-memchr
-// Copyright 2015 Andrew Gallant, bluss and Nicolas Koch
-
-
-
-/// A safe interface to `memchr`.
-///
-/// Returns the index corresponding to the first occurrence of `needle` in
-/// `haystack`, or `None` if one is not found.
-///
-/// memchr reduces to super-optimized machine code at around an order of
-/// magnitude faster than `haystack.iter().position(|&b| b == needle)`.
-/// (See benchmarks.)
-///
-/// # Example
-///
-/// This shows how to find the first position of a byte in a byte string.
-///
-/// ```rust,ignore
-/// use memchr::memchr;
-///
-/// let haystack = b"the quick brown fox";
-/// assert_eq!(memchr(b'k', haystack), Some(8));
-/// ```
-pub fn memchr(needle: u8, haystack: &[u8]) -> Option<usize> {
-    fn memchr_specific(needle: u8, haystack: &[u8]) -> Option<usize> {
-        use libctru::libc;
-
-        let p = unsafe {
-            libc::memchr(haystack.as_ptr() as *const libc::c_void,
-                         needle as libc::c_int,
-                         haystack.len() as libc::size_t)
-        };
-        if p.is_null() {
-            None
-        } else {
-            Some(p as usize - (haystack.as_ptr() as usize))
-        }
-    }
-    memchr_specific(needle, haystack)
-}
-
-/// A safe interface to `memrchr`.
-///
-/// Returns the index corresponding to the last occurrence of `needle` in
-/// `haystack`, or `None` if one is not found.
-///
-/// # Example
-///
-/// This shows how to find the last position of a byte in a byte string.
-///
-/// ```rust,ignore
-/// use memchr::memrchr;
-///
-/// let haystack = b"the quick brown fox";
-/// assert_eq!(memrchr(b'o', haystack), Some(17));
-/// ```
-pub fn memrchr(needle: u8, haystack: &[u8]) -> Option<usize> {
-    fn memrchr_specific(needle: u8, haystack: &[u8]) -> Option<usize> {
-        use libctru::libc;
-
-        // GNU's memrchr() will - unlike memchr() - error if haystack is empty.
-        if haystack.is_empty() {
-            return None;
-        }
-        let p = unsafe {
-            libc::memrchr(haystack.as_ptr() as *const libc::c_void,
-                          needle as libc::c_int,
-                          haystack.len() as libc::size_t)
-        };
-        if p.is_null() {
-            None
-        } else {
-            Some(p as usize - (haystack.as_ptr() as usize))
-        }
-    }
-    memrchr_specific(needle, haystack)
-}
-
-#[allow(dead_code)]
-mod fallback {
-    use core::cmp;
-    use core::mem;
-
-    const LO_U64: u64 = 0x0101010101010101;
-    const HI_U64: u64 = 0x8080808080808080;
-
-    // use truncation
-    const LO_USIZE: usize = LO_U64 as usize;
-    const HI_USIZE: usize = HI_U64 as usize;
-
-    /// Return `true` if `x` contains any zero byte.
-    ///
-    /// From *Matters Computational*, J. Arndt
-    ///
-    /// "The idea is to subtract one from each of the bytes and then look for
-    /// bytes where the borrow propagated all the way to the most significant
-    /// bit."
-    #[inline]
-    fn contains_zero_byte(x: usize) -> bool {
-        x.wrapping_sub(LO_USIZE) & !x & HI_USIZE != 0
-    }
-
-    #[cfg(target_pointer_width = "32")]
-    #[inline]
-    fn repeat_byte(b: u8) -> usize {
-        let mut rep = (b as usize) << 8 | b as usize;
-        rep = rep << 16 | rep;
-        rep
-    }
-
-    #[cfg(target_pointer_width = "64")]
-    #[inline]
-    fn repeat_byte(b: u8) -> usize {
-        let mut rep = (b as usize) << 8 | b as usize;
-        rep = rep << 16 | rep;
-        rep = rep << 32 | rep;
-        rep
-    }
-
-    /// Return the first index matching the byte `a` in `text`.
-    pub fn memchr(x: u8, text: &[u8]) -> Option<usize> {
-        // Scan for a single byte value by reading two `usize` words at a time.
-        //
-        // Split `text` in three parts
-        // - unaligned initial part, before the first word aligned address in text
-        // - body, scan by 2 words at a time
-        // - the last remaining part, < 2 word size
-        let len = text.len();
-        let ptr = text.as_ptr();
-        let usize_bytes = mem::size_of::<usize>();
-
-        // search up to an aligned boundary
-        let align = (ptr as usize) & (usize_bytes - 1);
-        let mut offset;
-        if align > 0 {
-            offset = cmp::min(usize_bytes - align, len);
-            if let Some(index) = text[..offset].iter().position(|elt| *elt == x) {
-                return Some(index);
-            }
-        } else {
-            offset = 0;
-        }
-
-        // search the body of the text
-        let repeated_x = repeat_byte(x);
-
-        if len >= 2 * usize_bytes {
-            while offset <= len - 2 * usize_bytes {
-                unsafe {
-                    let u = *(ptr.offset(offset as isize) as *const usize);
-                    let v = *(ptr.offset((offset + usize_bytes) as isize) as *const usize);
-
-                    // break if there is a matching byte
-                    let zu = contains_zero_byte(u ^ repeated_x);
-                    let zv = contains_zero_byte(v ^ repeated_x);
-                    if zu || zv {
-                        break;
-                    }
-                }
-                offset += usize_bytes * 2;
-            }
-        }
-
-        // find the byte after the point the body loop stopped
-        text[offset..].iter().position(|elt| *elt == x).map(|i| offset + i)
-    }
-
-    /// Return the last index matching the byte `a` in `text`.
-    pub fn memrchr(x: u8, text: &[u8]) -> Option<usize> {
-        // Scan for a single byte value by reading two `usize` words at a time.
-        //
-        // Split `text` in three parts
-        // - unaligned tail, after the last word aligned address in text
-        // - body, scan by 2 words at a time
-        // - the first remaining bytes, < 2 word size
-        let len = text.len();
-        let ptr = text.as_ptr();
-        let usize_bytes = mem::size_of::<usize>();
-
-        // search to an aligned boundary
-        let end_align = (ptr as usize + len) & (usize_bytes - 1);
-        let mut offset;
-        if end_align > 0 {
-            offset = if end_align >= len {
-                0
-            } else {
-                len - end_align
-            };
-            if let Some(index) = text[offset..].iter().rposition(|elt| *elt == x) {
-                return Some(offset + index);
-            }
-        } else {
-            offset = len;
-        }
-
-        // search the body of the text
-        let repeated_x = repeat_byte(x);
-
-        while offset >= 2 * usize_bytes {
-            unsafe {
-                let u = *(ptr.offset(offset as isize - 2 * usize_bytes as isize) as *const usize);
-                let v = *(ptr.offset(offset as isize - usize_bytes as isize) as *const usize);
-
-                // break if there is a matching byte
-                let zu = contains_zero_byte(u ^ repeated_x);
-                let zv = contains_zero_byte(v ^ repeated_x);
-                if zu || zv {
-                    break;
-                }
-            }
-            offset -= 2 * usize_bytes;
-        }
-
-        // find the byte before the point the body loop stopped
-        text[..offset].iter().rposition(|elt| *elt == x)
-    }
-
-    // test fallback implementations on all platforms
-    #[test]
-    fn matches_one() {
-        assert_eq!(Some(0), memchr(b'a', b"a"));
-    }
-
-    #[test]
-    fn matches_begin() {
-        assert_eq!(Some(0), memchr(b'a', b"aaaa"));
-    }
-
-    #[test]
-    fn matches_end() {
-        assert_eq!(Some(4), memchr(b'z', b"aaaaz"));
-    }
-
-    #[test]
-    fn matches_nul() {
-        assert_eq!(Some(4), memchr(b'\x00', b"aaaa\x00"));
-    }
-
-    #[test]
-    fn matches_past_nul() {
-        assert_eq!(Some(5), memchr(b'z', b"aaaa\x00z"));
-    }
-
-    #[test]
-    fn no_match_empty() {
-        assert_eq!(None, memchr(b'a', b""));
-    }
-
-    #[test]
-    fn no_match() {
-        assert_eq!(None, memchr(b'a', b"xyz"));
-    }
-
-    #[test]
-    fn matches_one_reversed() {
-        assert_eq!(Some(0), memrchr(b'a', b"a"));
-    }
-
-    #[test]
-    fn matches_begin_reversed() {
-        assert_eq!(Some(3), memrchr(b'a', b"aaaa"));
-    }
-
-    #[test]
-    fn matches_end_reversed() {
-        assert_eq!(Some(0), memrchr(b'z', b"zaaaa"));
-    }
-
-    #[test]
-    fn matches_nul_reversed() {
-        assert_eq!(Some(4), memrchr(b'\x00', b"aaaa\x00"));
-    }
-
-    #[test]
-    fn matches_past_nul_reversed() {
-        assert_eq!(Some(0), memrchr(b'z', b"z\x00aaaa"));
-    }
-
-    #[test]
-    fn no_match_empty_reversed() {
-        assert_eq!(None, memrchr(b'a', b""));
-    }
-
-    #[test]
-    fn no_match_reversed() {
-        assert_eq!(None, memrchr(b'a', b"xyz"));
-    }
-
-    #[test]
-    fn each_alignment_reversed() {
-        let mut data = [1u8; 64];
-        let needle = 2;
-        let pos = 40;
-        data[pos] = needle;
-        for start in 0..16 {
-            assert_eq!(Some(pos - start), memrchr(needle, &data[start..]));
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    // test the implementations for the current plattform
-    use super::{memchr, memrchr};
-
-    #[test]
-    fn matches_one() {
-        assert_eq!(Some(0), memchr(b'a', b"a"));
-    }
-
-    #[test]
-    fn matches_begin() {
-        assert_eq!(Some(0), memchr(b'a', b"aaaa"));
-    }
-
-    #[test]
-    fn matches_end() {
-        assert_eq!(Some(4), memchr(b'z', b"aaaaz"));
-    }
-
-    #[test]
-    fn matches_nul() {
-        assert_eq!(Some(4), memchr(b'\x00', b"aaaa\x00"));
-    }
-
-    #[test]
-    fn matches_past_nul() {
-        assert_eq!(Some(5), memchr(b'z', b"aaaa\x00z"));
-    }
-
-    #[test]
-    fn no_match_empty() {
-        assert_eq!(None, memchr(b'a', b""));
-    }
-
-    #[test]
-    fn no_match() {
-        assert_eq!(None, memchr(b'a', b"xyz"));
-    }
-
-    #[test]
-    fn matches_one_reversed() {
-        assert_eq!(Some(0), memrchr(b'a', b"a"));
-    }
-
-    #[test]
-    fn matches_begin_reversed() {
-        assert_eq!(Some(3), memrchr(b'a', b"aaaa"));
-    }
-
-    #[test]
-    fn matches_end_reversed() {
-        assert_eq!(Some(0), memrchr(b'z', b"zaaaa"));
-    }
-
-    #[test]
-    fn matches_nul_reversed() {
-        assert_eq!(Some(4), memrchr(b'\x00', b"aaaa\x00"));
-    }
-
-    #[test]
-    fn matches_past_nul_reversed() {
-        assert_eq!(Some(0), memrchr(b'z', b"z\x00aaaa"));
-    }
-
-    #[test]
-    fn no_match_empty_reversed() {
-        assert_eq!(None, memrchr(b'a', b""));
-    }
-
-    #[test]
-    fn no_match_reversed() {
-        assert_eq!(None, memrchr(b'a', b"xyz"));
-    }
-
-    #[test]
-    fn each_alignment() {
-        let mut data = [1u8; 64];
-        let needle = 2;
-        let pos = 40;
-        data[pos] = needle;
-        for start in 0..16 {
-            assert_eq!(Some(pos - start), memchr(needle, &data[start..]));
-        }
-    }
-}
diff --git a/src/system/mod.rs b/src/system/mod.rs
deleted file mode 100644
index 637a484..0000000
--- a/src/system/mod.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-pub mod ascii;
-pub mod error;
-pub mod ffi;
-pub mod io;
-pub mod memchr;
-pub mod panicking;
-pub mod path;
-pub mod rt;
-mod sys;
diff --git a/src/system/panicking.rs b/src/system/panicking.rs
deleted file mode 100644
index 9fb3e82..0000000
--- a/src/system/panicking.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright 2014 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Implementation of various bits and pieces of the `panic!` macro and
-//! associated runtime pieces.
-
-use core::fmt::{self, Display, Write};
-use core::any::Any;
-
-use collections::String;
-use collections::boxed::Box;
-
-///The compiler wants this to be here. Otherwise it won't be happy. And we like happy compilers.
-#[lang = "eh_personality"]
-extern fn eh_personality() {}
-
-/// Entry point of panic from the libcore crate.
-#[lang = "panic_fmt"]
-extern fn panic_fmt(msg: fmt::Arguments, file: &'static str, line: u32) -> ! {
-    begin_panic_fmt(&msg, &(file, line))
-}
-
-/// The entry point for panicking with a formatted message.
-///
-/// This is designed to reduce the amount of code required at the call
-/// site as much as possible (so that `panic!()` has as low an impact
-/// on (e.g.) the inlining of other functions as possible), by moving
-/// the actual formatting into this shared place.
-#[inline(never)]
-#[cold]
-pub fn begin_panic_fmt(msg: &fmt::Arguments, file_line: &(&'static str, u32)) -> ! {
-    let mut s = String::new();
-    let _ = s.write_fmt(*msg);
-    begin_panic(s, file_line);
-}
-
-/// This is where the main panic logic happens.
-#[inline(never)]
-#[cold]
-pub fn begin_panic<M: Any + Send + Display>(msg: M, file_line: &(&'static str, u32)) -> ! {
-    use gfx::Screen;
-    use console::Console;
-
-    let msg = Box::new(msg);
-    let (file, line) = *file_line;
-
-    let mut error_top = Console::init(Screen::Top);
-    let mut error_bottom = Console::init(Screen::Bottom);
-
-    write!(error_top, "--------------------------------------------------").unwrap();
-    writeln!(error_top, "PANIC in {} at line {}:", file, line).unwrap();
-    writeln!(error_top, "    {}", msg).unwrap();
-    write!(error_top, "\x1b[29;00H--------------------------------------------------").unwrap();
-
-    write!(error_bottom, "").unwrap();     
-
-    loop {}
-}
diff --git a/src/system/path.rs b/src/system/path.rs
deleted file mode 100644
index 4894756..0000000
--- a/src/system/path.rs
+++ /dev/null
@@ -1,3281 +0,0 @@
-// 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Cross-platform path manipulation.
-//!
-//! This module provides two types, `PathBuf` and `Path` (akin to `String` and
-//! `str`), for working with paths abstractly. These types are thin wrappers
-//! around `OsString` and `OsStr` respectively, meaning that they work directly
-//! on strings according to the local platform's path syntax.
-//!
-//! ## Simple usage
-//!
-//! Path manipulation includes both parsing components from slices and building
-//! new owned paths.
-//!
-//! To parse a path, you can create a `Path` slice from a `str`
-//! slice and start asking questions:
-//!
-//! ```rust
-//! use std::path::Path;
-//!
-//! let path = Path::new("/tmp/foo/bar.txt");
-//! let file = path.file_name();
-//! let extension = path.extension();
-//! let parent_dir = path.parent();
-//! ```
-//!
-//! To build or modify paths, use `PathBuf`:
-//!
-//! ```rust
-//! use std::path::PathBuf;
-//!
-//! let mut path = PathBuf::from("c:\\");
-//! path.push("windows");
-//! path.push("system32");
-//! path.set_extension("dll");
-//! ```
-//!
-//! ## Path components and normalization
-//!
-//! The path APIs are built around the notion of "components", which roughly
-//! correspond to the substrings between path separators (`/` and, on Windows,
-//! `\`). The APIs for path parsing are largely specified in terms of the path's
-//! components, so it's important to clearly understand how those are
-//! determined.
-//!
-//! A path can always be reconstructed into an *equivalent* path by
-//! putting together its components via `push`. Syntactically, the
-//! paths may differ by the normalization described below.
-//!
-//! ### Component types
-//!
-//! Components come in several types:
-//!
-//! * Normal components are the default: standard references to files or
-//! directories. The path `a/b` has two normal components, `a` and `b`.
-//!
-//! * Current directory components represent the `.` character. For example,
-//! `./a` has a current directory component and a normal component `a`.
-//!
-//! * The root directory component represents a separator that designates
-//!   starting from root. For example, `/a/b` has a root directory component
-//!   followed by normal components `a` and `b`.
-//!
-//! On Windows, an additional component type comes into play:
-//!
-//! * Prefix components, of which there is a large variety. For example, `C:`
-//! and `\\server\share` are prefixes. The path `C:windows` has a prefix
-//! component `C:` and a normal component `windows`; the path `C:\windows` has a
-//! prefix component `C:`, a root directory component, and a normal component
-//! `windows`.
-//!
-//! ### Normalization
-//!
-//! Aside from splitting on the separator(s), there is a small amount of
-//! "normalization":
-//!
-//! * Repeated separators are ignored: `a/b` and `a//b` both have components `a`
-//!   and `b`.
-//!
-//! * Occurrences of `.` are normalized away, *except* if they are at
-//! the beginning of the path (in which case they are often meaningful
-//! in terms of path searching). So, for example, `a/./b`, `a/b/`,
-//! `/a/b/.` and `a/b` all have components `a` and `b`, but `./a/b`
-//! has a leading current directory component.
-//!
-//! No other normalization takes place by default. In particular,
-//! `a/c` and `a/b/../c` are distinct, to account for the possibility
-//! that `b` is a symbolic link (so its parent isn't `a`). Further
-//! normalization is possible to build on top of the components APIs,
-//! and will be included in this library in the near future.
-
-use std::ascii::*;
-use std::borrow::{Borrow, ToOwned, Cow};
-use std::cmp;
-//use error::Error;
-use std::fmt;
-//use fs;
-use std::hash::{Hash, Hasher};
-//use io;
-use std::mem;
-use std::ops::{self, Deref};
-use std::iter;
-
-use std::ffi::{OsStr, OsString};
-
-use self::platform::{is_sep_byte, is_verbatim_sep, MAIN_SEP_STR, parse_prefix};
-
-////////////////////////////////////////////////////////////////////////////////
-// GENERAL NOTES
-////////////////////////////////////////////////////////////////////////////////
-//
-// Parsing in this module is done by directly transmuting OsStr to [u8] slices,
-// taking advantage of the fact that OsStr always encodes ASCII characters
-// as-is.  Eventually, this transmutation should be replaced by direct uses of
-// OsStr APIs for parsing, but it will take a while for those to become
-// available.
-
-////////////////////////////////////////////////////////////////////////////////
-// Platform-specific definitions
-////////////////////////////////////////////////////////////////////////////////
-
-// The following modules give the most basic tools for parsing paths on various
-// platforms. The bulk of the code is devoted to parsing prefixes on Windows.
-
-mod platform {
-    use super::Prefix;
-    use std::ffi::OsStr;
-
-    #[inline]
-    pub fn is_sep_byte(b: u8) -> bool {
-        b == b'/'
-    }
-
-    #[inline]
-    pub fn is_verbatim_sep(b: u8) -> bool {
-        b == b'/'
-    }
-
-    pub fn parse_prefix(_: &OsStr) -> Option<Prefix> {
-        None
-    }
-
-    pub const MAIN_SEP_STR: &'static str = "/";
-    pub const MAIN_SEP: char = '/';
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Windows Prefixes
-////////////////////////////////////////////////////////////////////////////////
-
-/// Path prefixes (Windows only).
-///
-/// Windows uses a variety of path styles, including references to drive
-/// volumes (like `C:`), network shared folders (like `\\server\share`) and
-/// others. In addition, some path prefixes are "verbatim", in which case
-/// `/` is *not* treated as a separator and essentially no normalization is
-/// performed.
-#[derive(Copy, Clone, Debug, Hash, PartialOrd, Ord, PartialEq, Eq)]
-pub enum Prefix<'a> {
-    /// Prefix `\\?\`, together with the given component immediately following it.
-    Verbatim(&'a OsStr),
-    /// Prefix `\\?\UNC\`, with the "server" and "share" components following it.
-    VerbatimUNC(
-        &'a OsStr,
-        &'a OsStr,
-    ),
-
-    /// Prefix like `\\?\C:\`, for the given drive letter
-    VerbatimDisk(u8),
-
-    /// Prefix `\\.\`, together with the given component immediately following it.
-    DeviceNS(&'a OsStr),
-
-    /// Prefix `\\server\share`, with the given "server" and "share" components.
-    UNC(
-        &'a OsStr,
-        &'a OsStr,
-    ),
-
-    /// Prefix `C:` for the given disk drive.
-    Disk(u8),
-}
-
-impl<'a> Prefix<'a> {
-    #[inline]
-    fn len(&self) -> usize {
-        use self::Prefix::*;
-        fn os_str_len(s: &OsStr) -> usize {
-            os_str_as_u8_slice(s).len()
-        }
-        match *self {
-            Verbatim(x) => 4 + os_str_len(x),
-            VerbatimUNC(x, y) => {
-                8 + os_str_len(x) +
-                if os_str_len(y) > 0 {
-                    1 + os_str_len(y)
-                } else {
-                    0
-                }
-            },
-            VerbatimDisk(_) => 6,
-            UNC(x, y) => {
-                2 + os_str_len(x) +
-                if os_str_len(y) > 0 {
-                    1 + os_str_len(y)
-                } else {
-                    0
-                }
-            },
-            DeviceNS(x) => 4 + os_str_len(x),
-            Disk(_) => 2,
-        }
-
-    }
-
-    /// Determines if the prefix is verbatim, i.e. begins with `\\?\`.
-    #[inline]
-    pub fn is_verbatim(&self) -> bool {
-        use self::Prefix::*;
-        match *self {
-            Verbatim(_) | VerbatimDisk(_) | VerbatimUNC(_, _) => true,
-            _ => false,
-        }
-    }
-
-    #[inline]
-    fn is_drive(&self) -> bool {
-        match *self {
-            Prefix::Disk(_) => true,
-            _ => false,
-        }
-    }
-
-    #[inline]
-    fn has_implicit_root(&self) -> bool {
-        !self.is_drive()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Exposed parsing helpers
-////////////////////////////////////////////////////////////////////////////////
-
-/// Determines whether the character is one of the permitted path
-/// separators for the current platform.
-///
-/// # Examples
-///
-/// ```
-/// use std::path;
-///
-/// assert!(path::is_separator('/'));
-/// assert!(!path::is_separator('❤'));
-/// ```
-pub fn is_separator(c: char) -> bool {
-    c.is_ascii() && is_sep_byte(c as u8)
-}
-
-/// The primary separator for the current platform
-pub const MAIN_SEPARATOR: char = platform::MAIN_SEP;
-
-////////////////////////////////////////////////////////////////////////////////
-// Misc helpers
-////////////////////////////////////////////////////////////////////////////////
-
-// Iterate through `iter` while it matches `prefix`; return `None` if `prefix`
-// is not a prefix of `iter`, otherwise return `Some(iter_after_prefix)` giving
-// `iter` after having exhausted `prefix`.
-fn iter_after<A, I, J>(mut iter: I, mut prefix: J) -> Option<I>
-    where I: Iterator<Item = A> + Clone,
-          J: Iterator<Item = A>,
-          A: PartialEq
-{
-    loop {
-        let mut iter_next = iter.clone();
-        match (iter_next.next(), prefix.next()) {
-            (Some(ref x), Some(ref y)) if x == y => (),
-            (Some(_), Some(_)) => return None,
-            (Some(_), None) => return Some(iter),
-            (None, None) => return Some(iter),
-            (None, Some(_)) => return None,
-        }
-        iter = iter_next;
-    }
-}
-
-// See note at the top of this module to understand why these are used:
-fn os_str_as_u8_slice(s: &OsStr) -> &[u8] {
-    unsafe { mem::transmute(s) }
-}
-unsafe fn u8_slice_as_os_str(s: &[u8]) -> &OsStr {
-    mem::transmute(s)
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Cross-platform, iterator-independent parsing
-////////////////////////////////////////////////////////////////////////////////
-
-/// Says whether the first byte after the prefix is a separator.
-fn has_physical_root(s: &[u8], prefix: Option<Prefix>) -> bool {
-    let path = if let Some(p) = prefix {
-        &s[p.len()..]
-    } else {
-        s
-    };
-    !path.is_empty() && is_sep_byte(path[0])
-}
-
-// basic workhorse for splitting stem and extension
-fn split_file_at_dot(file: &OsStr) -> (Option<&OsStr>, Option<&OsStr>) {
-    unsafe {
-        if os_str_as_u8_slice(file) == b".." {
-            return (Some(file), None);
-        }
-
-        // The unsafety here stems from converting between &OsStr and &[u8]
-        // and back. This is safe to do because (1) we only look at ASCII
-        // contents of the encoding and (2) new &OsStr values are produced
-        // only from ASCII-bounded slices of existing &OsStr values.
-
-        let mut iter = os_str_as_u8_slice(file).rsplitn(2, |b| *b == b'.');
-        let after = iter.next();
-        let before = iter.next();
-        if before == Some(b"") {
-            (Some(file), None)
-        } else {
-            (before.map(|s| u8_slice_as_os_str(s)),
-             after.map(|s| u8_slice_as_os_str(s)))
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// The core iterators
-////////////////////////////////////////////////////////////////////////////////
-
-/// Component parsing works by a double-ended state machine; the cursors at the
-/// front and back of the path each keep track of what parts of the path have
-/// been consumed so far.
-///
-/// Going front to back, a path is made up of a prefix, a starting
-/// directory component, and a body (of normal components)
-#[derive(Copy, Clone, PartialEq, PartialOrd, Debug)]
-enum State {
-    Prefix = 0,         // c:
-    StartDir = 1,       // / or . or nothing
-    Body = 2,           // foo/bar/baz
-    Done = 3,
-}
-
-/// A Windows path prefix, e.g. `C:` or `\\server\share`.
-///
-/// Does not occur on Unix.
-#[derive(Copy, Clone, Eq, Debug)]
-pub struct PrefixComponent<'a> {
-    /// The prefix as an unparsed `OsStr` slice.
-    raw: &'a OsStr,
-
-    /// The parsed prefix data.
-    parsed: Prefix<'a>,
-}
-
-impl<'a> PrefixComponent<'a> {
-    /// The parsed prefix data.
-    pub fn kind(&self) -> Prefix<'a> {
-        self.parsed
-    }
-
-    /// The raw `OsStr` slice for this prefix.
-    pub fn as_os_str(&self) -> &'a OsStr {
-        self.raw
-    }
-}
-
-impl<'a> cmp::PartialEq for PrefixComponent<'a> {
-    fn eq(&self, other: &PrefixComponent<'a>) -> bool {
-        cmp::PartialEq::eq(&self.parsed, &other.parsed)
-    }
-}
-
-impl<'a> cmp::PartialOrd for PrefixComponent<'a> {
-    fn partial_cmp(&self, other: &PrefixComponent<'a>) -> Option<cmp::Ordering> {
-        cmp::PartialOrd::partial_cmp(&self.parsed, &other.parsed)
-    }
-}
-
-impl<'a> cmp::Ord for PrefixComponent<'a> {
-    fn cmp(&self, other: &PrefixComponent<'a>) -> cmp::Ordering {
-        cmp::Ord::cmp(&self.parsed, &other.parsed)
-    }
-}
-
-impl<'a> Hash for PrefixComponent<'a> {
-    fn hash<H: Hasher>(&self, h: &mut H) {
-        self.parsed.hash(h);
-    }
-}
-
-/// A single component of a path.
-///
-/// See the module documentation for an in-depth explanation of components and
-/// their role in the API.
-///
-/// This `enum` is created from iterating over the [`path::Components`]
-/// `struct`.
-///
-/// # Examples
-///
-/// ```rust
-/// use std::path::{Component, Path};
-///
-/// let path = Path::new("/tmp/foo/bar.txt");
-/// let components = path.components().collect::<Vec<_>>();
-/// assert_eq!(&components, &[
-///     Component::RootDir,
-///     Component::Normal("tmp".as_ref()),
-///     Component::Normal("foo".as_ref()),
-///     Component::Normal("bar.txt".as_ref()),
-/// ]);
-/// ```
-///
-/// [`path::Components`]: struct.Components.html
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
-pub enum Component<'a> {
-    /// A Windows path prefix, e.g. `C:` or `\\server\share`.
-    ///
-    /// Does not occur on Unix.
-    Prefix(
-        PrefixComponent<'a>
-    ),
-
-    /// The root directory component, appears after any prefix and before anything else
-    RootDir,
-
-    /// A reference to the current directory, i.e. `.`
-    CurDir,
-
-    /// A reference to the parent directory, i.e. `..`
-    ParentDir,
-
-    /// A normal component, i.e. `a` and `b` in `a/b`
-    Normal(&'a OsStr),
-}
-
-impl<'a> Component<'a> {
-    /// Extracts the underlying `OsStr` slice
-    pub fn as_os_str(self) -> &'a OsStr {
-        match self {
-            Component::Prefix(p) => p.as_os_str(),
-            Component::RootDir => OsStr::new(MAIN_SEP_STR),
-            Component::CurDir => OsStr::new("."),
-            Component::ParentDir => OsStr::new(".."),
-            Component::Normal(path) => path,
-        }
-    }
-}
-
-impl<'a> AsRef<OsStr> for Component<'a> {
-    fn as_ref(&self) -> &OsStr {
-        self.as_os_str()
-    }
-}
-
-/// The core iterator giving the components of a path.
-///
-/// See the module documentation for an in-depth explanation of components and
-/// their role in the API.
-///
-/// This `struct` is created by the [`path::Path::components`] method.
-///
-/// # Examples
-///
-/// ```
-/// use std::path::Path;
-///
-/// let path = Path::new("/tmp/foo/bar.txt");
-///
-/// for component in path.components() {
-///     println!("{:?}", component);
-/// }
-/// ```
-///
-/// [`path::Path::components`]: struct.Path.html#method.components
-#[derive(Clone)]
-pub struct Components<'a> {
-    // The path left to parse components from
-    path: &'a [u8],
-
-    // The prefix as it was originally parsed, if any
-    prefix: Option<Prefix<'a>>,
-
-    // true if path *physically* has a root separator; for most Windows
-    // prefixes, it may have a "logical" rootseparator for the purposes of
-    // normalization, e.g.  \\server\share == \\server\share\.
-    has_physical_root: bool,
-
-    // The iterator is double-ended, and these two states keep track of what has
-    // been produced from either end
-    front: State,
-    back: State,
-}
-
-/// An iterator over the components of a path, as `OsStr` slices.
-#[derive(Clone)]
-pub struct Iter<'a> {
-    inner: Components<'a>,
-}
-
-impl<'a> Components<'a> {
-    // how long is the prefix, if any?
-    #[inline]
-    fn prefix_len(&self) -> usize {
-        self.prefix.as_ref().map(Prefix::len).unwrap_or(0)
-    }
-
-    #[inline]
-    fn prefix_verbatim(&self) -> bool {
-        self.prefix.as_ref().map(Prefix::is_verbatim).unwrap_or(false)
-    }
-
-    /// how much of the prefix is left from the point of view of iteration?
-    #[inline]
-    fn prefix_remaining(&self) -> usize {
-        if self.front == State::Prefix {
-            self.prefix_len()
-        } else {
-            0
-        }
-    }
-
-    // Given the iteration so far, how much of the pre-State::Body path is left?
-    #[inline]
-    fn len_before_body(&self) -> usize {
-        let root = if self.front <= State::StartDir && self.has_physical_root {
-            1
-        } else {
-            0
-        };
-        let cur_dir = if self.front <= State::StartDir && self.include_cur_dir() {
-            1
-        } else {
-            0
-        };
-        self.prefix_remaining() + root + cur_dir
-    }
-
-    // is the iteration complete?
-    #[inline]
-    fn finished(&self) -> bool {
-        self.front == State::Done || self.back == State::Done || self.front > self.back
-    }
-
-    #[inline]
-    fn is_sep_byte(&self, b: u8) -> bool {
-        if self.prefix_verbatim() {
-            is_verbatim_sep(b)
-        } else {
-            is_sep_byte(b)
-        }
-    }
-
-    /// Extracts a slice corresponding to the portion of the path remaining for iteration.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::Path;
-    ///
-    /// let mut components = Path::new("/tmp/foo/bar.txt").components();
-    /// components.next();
-    /// components.next();
-    ///
-    /// assert_eq!(Path::new("foo/bar.txt"), components.as_path());
-    /// ```
-    pub fn as_path(&self) -> &'a Path {
-        let mut comps = self.clone();
-        if comps.front == State::Body {
-            comps.trim_left();
-        }
-        if comps.back == State::Body {
-            comps.trim_right();
-        }
-        unsafe { Path::from_u8_slice(comps.path) }
-    }
-
-    /// Is the *original* path rooted?
-    fn has_root(&self) -> bool {
-        if self.has_physical_root {
-            return true;
-        }
-        if let Some(p) = self.prefix {
-            if p.has_implicit_root() {
-                return true;
-            }
-        }
-        false
-    }
-
-    /// Should the normalized path include a leading . ?
-    fn include_cur_dir(&self) -> bool {
-        if self.has_root() {
-            return false;
-        }
-        let mut iter = self.path[self.prefix_len()..].iter();
-        match (iter.next(), iter.next()) {
-            (Some(&b'.'), None) => true,
-            (Some(&b'.'), Some(&b)) => self.is_sep_byte(b),
-            _ => false,
-        }
-    }
-
-    // parse a given byte sequence into the corresponding path component
-    fn parse_single_component<'b>(&self, comp: &'b [u8]) -> Option<Component<'b>> {
-        match comp {
-            b"." if self.prefix_verbatim() => Some(Component::CurDir),
-            b"." => None, // . components are normalized away, except at
-                          // the beginning of a path, which is treated
-                          // separately via `include_cur_dir`
-            b".." => Some(Component::ParentDir),
-            b"" => None,
-            _ => Some(Component::Normal(unsafe { u8_slice_as_os_str(comp) })),
-        }
-    }
-
-    // parse a component from the left, saying how many bytes to consume to
-    // remove the component
-    fn parse_next_component(&self) -> (usize, Option<Component<'a>>) {
-        debug_assert!(self.front == State::Body);
-        let (extra, comp) = match self.path.iter().position(|b| self.is_sep_byte(*b)) {
-            None => (0, self.path),
-            Some(i) => (1, &self.path[..i]),
-        };
-        (comp.len() + extra, self.parse_single_component(comp))
-    }
-
-    // parse a component from the right, saying how many bytes to consume to
-    // remove the component
-    fn parse_next_component_back(&self) -> (usize, Option<Component<'a>>) {
-        debug_assert!(self.back == State::Body);
-        let start = self.len_before_body();
-        let (extra, comp) = match self.path[start..].iter().rposition(|b| self.is_sep_byte(*b)) {
-            None => (0, &self.path[start..]),
-            Some(i) => (1, &self.path[start + i + 1..]),
-        };
-        (comp.len() + extra, self.parse_single_component(comp))
-    }
-
-    // trim away repeated separators (i.e. empty components) on the left
-    fn trim_left(&mut self) {
-        while !self.path.is_empty() {
-            let (size, comp) = self.parse_next_component();
-            if comp.is_some() {
-                return;
-            } else {
-                self.path = &self.path[size..];
-            }
-        }
-    }
-
-    // trim away repeated separators (i.e. empty components) on the right
-    fn trim_right(&mut self) {
-        while self.path.len() > self.len_before_body() {
-            let (size, comp) = self.parse_next_component_back();
-            if comp.is_some() {
-                return;
-            } else {
-                self.path = &self.path[..self.path.len() - size];
-            }
-        }
-    }
-}
-
-impl<'a> AsRef<Path> for Components<'a> {
-    fn as_ref(&self) -> &Path {
-        self.as_path()
-    }
-}
-
-impl<'a> AsRef<OsStr> for Components<'a> {
-    fn as_ref(&self) -> &OsStr {
-        self.as_path().as_os_str()
-    }
-}
-
-impl<'a> Iter<'a> {
-    /// Extracts a slice corresponding to the portion of the path remaining for iteration.
-    pub fn as_path(&self) -> &'a Path {
-        self.inner.as_path()
-    }
-}
-
-impl<'a> AsRef<Path> for Iter<'a> {
-    fn as_ref(&self) -> &Path {
-        self.as_path()
-    }
-}
-
-impl<'a> AsRef<OsStr> for Iter<'a> {
-    fn as_ref(&self) -> &OsStr {
-        self.as_path().as_os_str()
-    }
-}
-
-impl<'a> Iterator for Iter<'a> {
-    type Item = &'a OsStr;
-
-    fn next(&mut self) -> Option<&'a OsStr> {
-        self.inner.next().map(Component::as_os_str)
-    }
-}
-
-impl<'a> DoubleEndedIterator for Iter<'a> {
-    fn next_back(&mut self) -> Option<&'a OsStr> {
-        self.inner.next_back().map(Component::as_os_str)
-    }
-}
-
-impl<'a> Iterator for Components<'a> {
-    type Item = Component<'a>;
-
-    fn next(&mut self) -> Option<Component<'a>> {
-        while !self.finished() {
-            match self.front {
-                State::Prefix if self.prefix_len() > 0 => {
-                    self.front = State::StartDir;
-                    debug_assert!(self.prefix_len() <= self.path.len());
-                    let raw = &self.path[..self.prefix_len()];
-                    self.path = &self.path[self.prefix_len()..];
-                    return Some(Component::Prefix(PrefixComponent {
-                        raw: unsafe { u8_slice_as_os_str(raw) },
-                        parsed: self.prefix.unwrap(),
-                    }));
-                }
-                State::Prefix => {
-                    self.front = State::StartDir;
-                }
-                State::StartDir => {
-                    self.front = State::Body;
-                    if self.has_physical_root {
-                        debug_assert!(!self.path.is_empty());
-                        self.path = &self.path[1..];
-                        return Some(Component::RootDir);
-                    } else if let Some(p) = self.prefix {
-                        if p.has_implicit_root() && !p.is_verbatim() {
-                            return Some(Component::RootDir);
-                        }
-                    } else if self.include_cur_dir() {
-                        debug_assert!(!self.path.is_empty());
-                        self.path = &self.path[1..];
-                        return Some(Component::CurDir);
-                    }
-                }
-                State::Body if !self.path.is_empty() => {
-                    let (size, comp) = self.parse_next_component();
-                    self.path = &self.path[size..];
-                    if comp.is_some() {
-                        return comp;
-                    }
-                }
-                State::Body => {
-                    self.front = State::Done;
-                }
-                State::Done => unreachable!(),
-            }
-        }
-        None
-    }
-}
-
-impl<'a> DoubleEndedIterator for Components<'a> {
-    fn next_back(&mut self) -> Option<Component<'a>> {
-        while !self.finished() {
-            match self.back {
-                State::Body if self.path.len() > self.len_before_body() => {
-                    let (size, comp) = self.parse_next_component_back();
-                    self.path = &self.path[..self.path.len() - size];
-                    if comp.is_some() {
-                        return comp;
-                    }
-                }
-                State::Body => {
-                    self.back = State::StartDir;
-                }
-                State::StartDir => {
-                    self.back = State::Prefix;
-                    if self.has_physical_root {
-                        self.path = &self.path[..self.path.len() - 1];
-                        return Some(Component::RootDir);
-                    } else if let Some(p) = self.prefix {
-                        if p.has_implicit_root() && !p.is_verbatim() {
-                            return Some(Component::RootDir);
-                        }
-                    } else if self.include_cur_dir() {
-                        self.path = &self.path[..self.path.len() - 1];
-                        return Some(Component::CurDir);
-                    }
-                }
-                State::Prefix if self.prefix_len() > 0 => {
-                    self.back = State::Done;
-                    return Some(Component::Prefix(PrefixComponent {
-                        raw: unsafe { u8_slice_as_os_str(self.path) },
-                        parsed: self.prefix.unwrap(),
-                    }));
-                }
-                State::Prefix => {
-                    self.back = State::Done;
-                    return None;
-                }
-                State::Done => unreachable!(),
-            }
-        }
-        None
-    }
-}
-
-impl<'a> cmp::PartialEq for Components<'a> {
-    fn eq(&self, other: &Components<'a>) -> bool {
-        Iterator::eq(self.clone(), other.clone())
-    }
-}
-
-impl<'a> cmp::Eq for Components<'a> {}
-
-impl<'a> cmp::PartialOrd for Components<'a> {
-    fn partial_cmp(&self, other: &Components<'a>) -> Option<cmp::Ordering> {
-        Iterator::partial_cmp(self.clone(), other.clone())
-    }
-}
-
-impl<'a> cmp::Ord for Components<'a> {
-    fn cmp(&self, other: &Components<'a>) -> cmp::Ordering {
-        Iterator::cmp(self.clone(), other.clone())
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Basic types and traits
-////////////////////////////////////////////////////////////////////////////////
-
-/// An owned, mutable path (akin to `String`).
-///
-/// This type provides methods like `push` and `set_extension` that mutate the
-/// path in place. It also implements `Deref` to `Path`, meaning that all
-/// methods on `Path` slices are available on `PathBuf` values as well.
-///
-/// More details about the overall approach can be found in
-/// the module documentation.
-///
-/// # Examples
-///
-/// ```
-/// use std::path::PathBuf;
-///
-/// let mut path = PathBuf::from("c:\\");
-/// path.push("windows");
-/// path.push("system32");
-/// path.set_extension("dll");
-/// ```
-#[derive(Clone)]
-pub struct PathBuf {
-    inner: OsString,
-}
-
-impl PathBuf {
-    fn as_mut_vec(&mut self) -> &mut Vec<u8> {
-        unsafe { &mut *(self as *mut PathBuf as *mut Vec<u8>) }
-    }
-
-    /// Allocates an empty `PathBuf`.
-    pub fn new() -> PathBuf {
-        PathBuf { inner: OsString::new() }
-    }
-
-    /// Coerces to a `Path` slice.
-    pub fn as_path(&self) -> &Path {
-        self
-    }
-
-    /// Extends `self` with `path`.
-    ///
-    /// If `path` is absolute, it replaces the current path.
-    ///
-    /// On Windows:
-    ///
-    /// * if `path` has a root but no prefix (e.g. `\windows`), it
-    ///   replaces everything except for the prefix (if any) of `self`.
-    /// * if `path` has a prefix but no root, it replaces `self`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::PathBuf;
-    ///
-    /// let mut path = PathBuf::new();
-    /// path.push("/tmp");
-    /// path.push("file.bk");
-    /// assert_eq!(path, PathBuf::from("/tmp/file.bk"));
-    ///
-    /// // Pushing an absolute path replaces the current path
-    /// path.push("/etc/passwd");
-    /// assert_eq!(path, PathBuf::from("/etc/passwd"));
-    /// ```
-    pub fn push<P: AsRef<Path>>(&mut self, path: P) {
-        self._push(path.as_ref())
-    }
-
-    fn _push(&mut self, path: &Path) {
-        // in general, a separator is needed if the rightmost byte is not a separator
-        let mut need_sep = self.as_mut_vec().last().map(|c| !is_sep_byte(*c)).unwrap_or(false);
-
-        // in the special case of `C:` on Windows, do *not* add a separator
-        {
-            let comps = self.components();
-            if comps.prefix_len() > 0 && comps.prefix_len() == comps.path.len() &&
-               comps.prefix.unwrap().is_drive() {
-                need_sep = false
-            }
-        }
-
-        // absolute `path` replaces `self`
-        if path.is_absolute() || path.prefix().is_some() {
-            self.as_mut_vec().truncate(0);
-
-        // `path` has a root but no prefix, e.g. `\windows` (Windows only)
-        } else if path.has_root() {
-            let prefix_len = self.components().prefix_remaining();
-            self.as_mut_vec().truncate(prefix_len);
-
-        // `path` is a pure relative path
-        } else if need_sep {
-            self.inner.push(MAIN_SEP_STR);
-        }
-
-        self.inner.push(path);
-    }
-
-    /// Truncate `self` to `self.parent()`.
-    ///
-    /// Returns false and does nothing if `self.file_name()` is `None`.
-    /// Otherwise, returns `true`.
-    pub fn pop(&mut self) -> bool {
-        match self.parent().map(|p| p.as_u8_slice().len()) {
-            Some(len) => {
-                self.as_mut_vec().truncate(len);
-                true
-            }
-            None => false,
-        }
-    }
-
-    /// Updates `self.file_name()` to `file_name`.
-    ///
-    /// If `self.file_name()` was `None`, this is equivalent to pushing
-    /// `file_name`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::PathBuf;
-    ///
-    /// let mut buf = PathBuf::from("/");
-    /// assert!(buf.file_name() == None);
-    /// buf.set_file_name("bar");
-    /// assert!(buf == PathBuf::from("/bar"));
-    /// assert!(buf.file_name().is_some());
-    /// buf.set_file_name("baz.txt");
-    /// assert!(buf == PathBuf::from("/baz.txt"));
-    /// ```
-    pub fn set_file_name<S: AsRef<OsStr>>(&mut self, file_name: S) {
-        self._set_file_name(file_name.as_ref())
-    }
-
-    fn _set_file_name(&mut self, file_name: &OsStr) {
-        if self.file_name().is_some() {
-            let popped = self.pop();
-            debug_assert!(popped);
-        }
-        self.push(file_name);
-    }
-
-    /// Updates `self.extension()` to `extension`.
-    ///
-    /// If `self.file_name()` is `None`, does nothing and returns `false`.
-    ///
-    /// Otherwise, returns `true`; if `self.extension()` is `None`, the extension
-    /// is added; otherwise it is replaced.
-    pub fn set_extension<S: AsRef<OsStr>>(&mut self, extension: S) -> bool {
-        self._set_extension(extension.as_ref())
-    }
-
-    fn _set_extension(&mut self, extension: &OsStr) -> bool {
-        if self.file_name().is_none() {
-            return false;
-        }
-
-        let mut stem = match self.file_stem() {
-            Some(stem) => stem.to_os_string(),
-            None => OsString::new(),
-        };
-
-        if !os_str_as_u8_slice(extension).is_empty() {
-            stem.push(".");
-            stem.push(extension);
-        }
-        self.set_file_name(&stem);
-
-        true
-    }
-
-    /// Consumes the `PathBuf`, yielding its internal `OsString` storage.
-    pub fn into_os_string(self) -> OsString {
-        self.inner
-    }
-}
-
-impl<'a, T: ?Sized + AsRef<OsStr>> From<&'a T> for PathBuf {
-    fn from(s: &'a T) -> PathBuf {
-        PathBuf::from(s.as_ref().to_os_string())
-    }
-}
-
-impl From<OsString> for PathBuf {
-    fn from(s: OsString) -> PathBuf {
-        PathBuf { inner: s }
-    }
-}
-
-impl From<String> for PathBuf {
-    fn from(s: String) -> PathBuf {
-        PathBuf::from(OsString::from(s))
-    }
-}
-
-impl<P: AsRef<Path>> iter::FromIterator<P> for PathBuf {
-    fn from_iter<I: IntoIterator<Item = P>>(iter: I) -> PathBuf {
-        let mut buf = PathBuf::new();
-        buf.extend(iter);
-        buf
-    }
-}
-
-impl<P: AsRef<Path>> iter::Extend<P> for PathBuf {
-    fn extend<I: IntoIterator<Item = P>>(&mut self, iter: I) {
-        for p in iter {
-            self.push(p.as_ref())
-        }
-    }
-}
-
-impl fmt::Debug for PathBuf {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        fmt::Debug::fmt(&**self, formatter)
-    }
-}
-
-impl ops::Deref for PathBuf {
-    type Target = Path;
-
-    fn deref(&self) -> &Path {
-        Path::new(&self.inner)
-    }
-}
-
-impl Borrow<Path> for PathBuf {
-    fn borrow(&self) -> &Path {
-        self.deref()
-    }
-}
-
-impl<'a> From<&'a Path> for Cow<'a, Path> {
-    #[inline]
-    fn from(s: &'a Path) -> Cow<'a, Path> {
-        Cow::Borrowed(s)
-    }
-}
-
-impl<'a> From<PathBuf> for Cow<'a, Path> {
-    #[inline]
-    fn from(s: PathBuf) -> Cow<'a, Path> {
-        Cow::Owned(s)
-    }
-}
-
-impl ToOwned for Path {
-    type Owned = PathBuf;
-    fn to_owned(&self) -> PathBuf {
-        self.to_path_buf()
-    }
-}
-
-impl cmp::PartialEq for PathBuf {
-    fn eq(&self, other: &PathBuf) -> bool {
-        self.components() == other.components()
-    }
-}
-
-impl Hash for PathBuf {
-    fn hash<H: Hasher>(&self, h: &mut H) {
-        self.as_path().hash(h)
-    }
-}
-
-impl cmp::Eq for PathBuf {}
-
-impl cmp::PartialOrd for PathBuf {
-    fn partial_cmp(&self, other: &PathBuf) -> Option<cmp::Ordering> {
-        self.components().partial_cmp(other.components())
-    }
-}
-
-impl cmp::Ord for PathBuf {
-    fn cmp(&self, other: &PathBuf) -> cmp::Ordering {
-        self.components().cmp(other.components())
-    }
-}
-
-impl AsRef<OsStr> for PathBuf {
-    fn as_ref(&self) -> &OsStr {
-        &self.inner[..]
-    }
-}
-
-impl Into<OsString> for PathBuf {
-    fn into(self) -> OsString {
-        self.inner
-    }
-}
-
-/// A slice of a path (akin to `str`).
-///
-/// This type supports a number of operations for inspecting a path, including
-/// breaking the path into its components (separated by `/` or `\`, depending on
-/// the platform), extracting the file name, determining whether the path is
-/// absolute, and so on. More details about the overall approach can be found in
-/// the module documentation.
-///
-/// This is an *unsized* type, meaning that it must always be used behind a
-/// pointer like `&` or `Box`.
-///
-/// # Examples
-///
-/// ```
-/// use std::path::Path;
-///
-/// let path = Path::new("/tmp/foo/bar.txt");
-/// let file = path.file_name();
-/// let extension = path.extension();
-/// let parent_dir = path.parent();
-/// ```
-///
-pub struct Path {
-    inner: OsStr,
-}
-
-/// An error returned from the `Path::strip_prefix` method indicating that the
-/// prefix was not found in `self`.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct StripPrefixError(());
-
-impl Path {
-    // The following (private!) function allows construction of a path from a u8
-    // slice, which is only safe when it is known to follow the OsStr encoding.
-    unsafe fn from_u8_slice(s: &[u8]) -> &Path {
-        Path::new(u8_slice_as_os_str(s))
-    }
-    // The following (private!) function reveals the byte encoding used for OsStr.
-    fn as_u8_slice(&self) -> &[u8] {
-        os_str_as_u8_slice(&self.inner)
-    }
-
-    /// Directly wrap a string slice as a `Path` slice.
-    ///
-    /// This is a cost-free conversion.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::Path;
-    ///
-    /// Path::new("foo.txt");
-    /// ```
-    ///
-    /// You can create `Path`s from `String`s, or even other `Path`s:
-    ///
-    /// ```
-    /// use std::path::Path;
-    ///
-    /// let string = String::from("foo.txt");
-    /// let from_string = Path::new(&string);
-    /// let from_path = Path::new(&from_string);
-    /// assert_eq!(from_string, from_path);
-    /// ```
-    pub fn new<S: AsRef<OsStr> + ?Sized>(s: &S) -> &Path {
-        unsafe { mem::transmute(s.as_ref()) }
-    }
-
-    /// Yields the underlying `OsStr` slice.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::Path;
-    ///
-    /// let os_str = Path::new("foo.txt").as_os_str();
-    /// assert_eq!(os_str, std::ffi::OsStr::new("foo.txt"));
-    /// ```
-    pub fn as_os_str(&self) -> &OsStr {
-        &self.inner
-    }
-
-    /// Yields a `&str` slice if the `Path` is valid unicode.
-    ///
-    /// This conversion may entail doing a check for UTF-8 validity.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::Path;
-    ///
-    /// let path_str = Path::new("foo.txt").to_str();
-    /// assert_eq!(path_str, Some("foo.txt"));
-    /// ```
-    pub fn to_str(&self) -> Option<&str> {
-        self.inner.to_str()
-    }
-
-    /// Converts a `Path` to a `Cow<str>`.
-    ///
-    /// Any non-Unicode sequences are replaced with U+FFFD REPLACEMENT CHARACTER.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::Path;
-    ///
-    /// let path_str = Path::new("foo.txt").to_string_lossy();
-    /// assert_eq!(path_str, "foo.txt");
-    /// ```
-    pub fn to_string_lossy(&self) -> Cow<str> {
-        self.inner.to_string_lossy()
-    }
-
-    /// Converts a `Path` to an owned `PathBuf`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::Path;
-    ///
-    /// let path_buf = Path::new("foo.txt").to_path_buf();
-    /// assert_eq!(path_buf, std::path::PathBuf::from("foo.txt"));
-    /// ```
-    pub fn to_path_buf(&self) -> PathBuf {
-        PathBuf::from(self.inner.to_os_string())
-    }
-
-    /// A path is *absolute* if it is independent of the current directory.
-    ///
-    /// * On Unix, a path is absolute if it starts with the root, so
-    /// `is_absolute` and `has_root` are equivalent.
-    ///
-    /// * On Windows, a path is absolute if it has a prefix and starts with the
-    /// root: `c:\windows` is absolute, while `c:temp` and `\temp` are not.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::Path;
-    ///
-    /// assert!(!Path::new("foo.txt").is_absolute());
-    /// ```
-    #[allow(deprecated)]
-    pub fn is_absolute(&self) -> bool {
-        self.has_root() && (cfg!(unix) || self.prefix().is_some())
-    }
-
-    /// A path is *relative* if it is not absolute.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::Path;
-    ///
-    /// assert!(Path::new("foo.txt").is_relative());
-    /// ```
-    pub fn is_relative(&self) -> bool {
-        !self.is_absolute()
-    }
-
-    fn prefix(&self) -> Option<Prefix> {
-        self.components().prefix
-    }
-
-    /// A path has a root if the body of the path begins with the directory separator.
-    ///
-    /// * On Unix, a path has a root if it begins with `/`.
-    ///
-    /// * On Windows, a path has a root if it:
-    ///     * has no prefix and begins with a separator, e.g. `\\windows`
-    ///     * has a prefix followed by a separator, e.g. `c:\windows` but not `c:windows`
-    ///     * has any non-disk prefix, e.g. `\\server\share`
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::Path;
-    ///
-    /// assert!(Path::new("/etc/passwd").has_root());
-    /// ```
-    pub fn has_root(&self) -> bool {
-        self.components().has_root()
-    }
-
-    /// The path without its final component, if any.
-    ///
-    /// Returns `None` if the path terminates in a root or prefix.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::Path;
-    ///
-    /// let path = Path::new("/foo/bar");
-    /// let parent = path.parent().unwrap();
-    /// assert_eq!(parent, Path::new("/foo"));
-    ///
-    /// let grand_parent = parent.parent().unwrap();
-    /// assert_eq!(grand_parent, Path::new("/"));
-    /// assert_eq!(grand_parent.parent(), None);
-    /// ```
-    pub fn parent(&self) -> Option<&Path> {
-        let mut comps = self.components();
-        let comp = comps.next_back();
-        comp.and_then(|p| {
-            match p {
-                Component::Normal(_) |
-                Component::CurDir |
-                Component::ParentDir => Some(comps.as_path()),
-                _ => None,
-            }
-        })
-    }
-
-    /// The final component of the path, if it is a normal file.
-    ///
-    /// If the path terminates in `..`, `file_name` will return `None`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::Path;
-    /// use std::ffi::OsStr;
-    ///
-    /// let path = Path::new("foo.txt");
-    /// let os_str = OsStr::new("foo.txt");
-    ///
-    /// assert_eq!(Some(os_str), path.file_name());
-    /// ```
-    ///
-    /// # Other examples
-    ///
-    /// ```
-    /// use std::path::Path;
-    /// use std::ffi::OsStr;
-    ///
-    /// assert_eq!(Some(OsStr::new("foo.txt")), Path::new("foo.txt/.").file_name());
-    /// assert_eq!(Some(OsStr::new("foo.txt")), Path::new("foo.txt/.//").file_name());
-    /// assert_eq!(None, Path::new("foo.txt/..").file_name());
-    /// ```
-    pub fn file_name(&self) -> Option<&OsStr> {
-        self.components().next_back().and_then(|p| {
-            match p {
-                Component::Normal(p) => Some(p.as_ref()),
-                _ => None,
-            }
-        })
-    }
-
-    /// Returns a path that, when joined onto `base`, yields `self`.
-    ///
-    /// # Errors
-    ///
-    /// If `base` is not a prefix of `self` (i.e. `starts_with`
-    /// returns `false`), returns `Err`.
-    pub fn strip_prefix<'a, P: ?Sized>(&'a self, base: &'a P)
-                                       -> Result<&'a Path, StripPrefixError>
-        where P: AsRef<Path>
-    {
-        self._strip_prefix(base.as_ref())
-    }
-
-    fn _strip_prefix<'a>(&'a self, base: &'a Path)
-                         -> Result<&'a Path, StripPrefixError> {
-        iter_after(self.components(), base.components())
-            .map(|c| c.as_path())
-            .ok_or(StripPrefixError(()))
-    }
-
-    /// Determines whether `base` is a prefix of `self`.
-    ///
-    /// Only considers whole path components to match.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::Path;
-    ///
-    /// let path = Path::new("/etc/passwd");
-    ///
-    /// assert!(path.starts_with("/etc"));
-    ///
-    /// assert!(!path.starts_with("/e"));
-    /// ```
-    pub fn starts_with<P: AsRef<Path>>(&self, base: P) -> bool {
-        self._starts_with(base.as_ref())
-    }
-
-    fn _starts_with(&self, base: &Path) -> bool {
-        iter_after(self.components(), base.components()).is_some()
-    }
-
-    /// Determines whether `child` is a suffix of `self`.
-    ///
-    /// Only considers whole path components to match.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::Path;
-    ///
-    /// let path = Path::new("/etc/passwd");
-    ///
-    /// assert!(path.ends_with("passwd"));
-    /// ```
-    pub fn ends_with<P: AsRef<Path>>(&self, child: P) -> bool {
-        self._ends_with(child.as_ref())
-    }
-
-    fn _ends_with(&self, child: &Path) -> bool {
-        iter_after(self.components().rev(), child.components().rev()).is_some()
-    }
-
-    /// Extracts the stem (non-extension) portion of `self.file_name()`.
-    ///
-    /// The stem is:
-    ///
-    /// * None, if there is no file name;
-    /// * The entire file name if there is no embedded `.`;
-    /// * The entire file name if the file name begins with `.` and has no other `.`s within;
-    /// * Otherwise, the portion of the file name before the final `.`
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::Path;
-    ///
-    /// let path = Path::new("foo.rs");
-    ///
-    /// assert_eq!("foo", path.file_stem().unwrap());
-    /// ```
-    pub fn file_stem(&self) -> Option<&OsStr> {
-        self.file_name().map(split_file_at_dot).and_then(|(before, after)| before.or(after))
-    }
-
-    /// Extracts the extension of `self.file_name()`, if possible.
-    ///
-    /// The extension is:
-    ///
-    /// * None, if there is no file name;
-    /// * None, if there is no embedded `.`;
-    /// * None, if the file name begins with `.` and has no other `.`s within;
-    /// * Otherwise, the portion of the file name after the final `.`
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::Path;
-    ///
-    /// let path = Path::new("foo.rs");
-    ///
-    /// assert_eq!("rs", path.extension().unwrap());
-    /// ```
-    pub fn extension(&self) -> Option<&OsStr> {
-        self.file_name().map(split_file_at_dot).and_then(|(before, after)| before.and(after))
-    }
-
-    /// Creates an owned `PathBuf` with `path` adjoined to `self`.
-    ///
-    /// See `PathBuf::push` for more details on what it means to adjoin a path.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::{Path, PathBuf};
-    ///
-    /// assert_eq!(Path::new("/etc").join("passwd"), PathBuf::from("/etc/passwd"));
-    /// ```
-    pub fn join<P: AsRef<Path>>(&self, path: P) -> PathBuf {
-        self._join(path.as_ref())
-    }
-
-    fn _join(&self, path: &Path) -> PathBuf {
-        let mut buf = self.to_path_buf();
-        buf.push(path);
-        buf
-    }
-
-    /// Creates an owned `PathBuf` like `self` but with the given file name.
-    ///
-    /// See `PathBuf::set_file_name` for more details.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::{Path, PathBuf};
-    ///
-    /// let path = Path::new("/tmp/foo.txt");
-    /// assert_eq!(path.with_file_name("bar.txt"), PathBuf::from("/tmp/bar.txt"));
-    /// ```
-    pub fn with_file_name<S: AsRef<OsStr>>(&self, file_name: S) -> PathBuf {
-        self._with_file_name(file_name.as_ref())
-    }
-
-    fn _with_file_name(&self, file_name: &OsStr) -> PathBuf {
-        let mut buf = self.to_path_buf();
-        buf.set_file_name(file_name);
-        buf
-    }
-
-    /// Creates an owned `PathBuf` like `self` but with the given extension.
-    ///
-    /// See `PathBuf::set_extension` for more details.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::{Path, PathBuf};
-    ///
-    /// let path = Path::new("foo.rs");
-    /// assert_eq!(path.with_extension("txt"), PathBuf::from("foo.txt"));
-    /// ```
-    pub fn with_extension<S: AsRef<OsStr>>(&self, extension: S) -> PathBuf {
-        self._with_extension(extension.as_ref())
-    }
-
-    fn _with_extension(&self, extension: &OsStr) -> PathBuf {
-        let mut buf = self.to_path_buf();
-        buf.set_extension(extension);
-        buf
-    }
-
-    /// Produce an iterator over the components of the path.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::{Path, Component};
-    /// use std::ffi::OsStr;
-    ///
-    /// let mut components = Path::new("/tmp/foo.txt").components();
-    ///
-    /// assert_eq!(components.next(), Some(Component::RootDir));
-    /// assert_eq!(components.next(), Some(Component::Normal(OsStr::new("tmp"))));
-    /// assert_eq!(components.next(), Some(Component::Normal(OsStr::new("foo.txt"))));
-    /// assert_eq!(components.next(), None)
-    /// ```
-    pub fn components(&self) -> Components {
-        let prefix = parse_prefix(self.as_os_str());
-        Components {
-            path: self.as_u8_slice(),
-            prefix: prefix,
-            has_physical_root: has_physical_root(self.as_u8_slice(), prefix),
-            front: State::Prefix,
-            back: State::Body,
-        }
-    }
-
-    /// Produce an iterator over the path's components viewed as `OsStr` slices.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::{self, Path};
-    /// use std::ffi::OsStr;
-    ///
-    /// let mut it = Path::new("/tmp/foo.txt").iter();
-    /// assert_eq!(it.next(), Some(OsStr::new(&path::MAIN_SEPARATOR.to_string())));
-    /// assert_eq!(it.next(), Some(OsStr::new("tmp")));
-    /// assert_eq!(it.next(), Some(OsStr::new("foo.txt")));
-    /// assert_eq!(it.next(), None)
-    /// ```
-    pub fn iter(&self) -> Iter {
-        Iter { inner: self.components() }
-    }
-
-    /// Returns an object that implements `Display` for safely printing paths
-    /// that may contain non-Unicode data.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::Path;
-    ///
-    /// let path = Path::new("/tmp/foo.rs");
-    ///
-    /// println!("{}", path.display());
-    /// ```
-    pub fn display(&self) -> Display {
-        Display { path: self }
-    }
-
-
-    //NOTE: The following functions rely on filesystem functionality that
-    //probably have to be implemented in ctru-rs instead of this library,
-    //and thus are commented out
-
-    /*
-    /// Query the file system to get information about a file, directory, etc.
-    ///
-    /// This function will traverse symbolic links to query information about the
-    /// destination file.
-    ///
-    /// This is an alias to [`fs::metadata`].
-    ///
-    /// [`fs::metadata`]: ../fs/fn.metadata.html
-    pub fn metadata(&self) -> io::Result<fs::Metadata> {
-        fs::metadata(self)
-    }
-
-    /// Query the metadata about a file without following symlinks.
-    ///
-    /// This is an alias to [`fs::symlink_metadata`].
-    ///
-    /// [`fs::symlink_metadata`]: ../fs/fn.symlink_metadata.html
-
-    pub fn symlink_metadata(&self) -> io::Result<fs::Metadata> {
-        fs::symlink_metadata(self)
-    }
-
-
-    /// Returns the canonical form of the path with all intermediate components
-    /// normalized and symbolic links resolved.
-    ///
-    /// This is an alias to [`fs::canonicalize`].
-    ///
-    /// [`fs::canonicalize`]: ../fs/fn.canonicalize.html
-
-    pub fn canonicalize(&self) -> io::Result<PathBuf> {
-        fs::canonicalize(self)
-    }
-
-
-    /// Reads a symbolic link, returning the file that the link points to.
-    ///
-    /// This is an alias to [`fs::read_link`].
-    ///
-    /// [`fs::read_link`]: ../fs/fn.read_link.html
-
-    pub fn read_link(&self) -> io::Result<PathBuf> {
-        fs::read_link(self)
-    }
-
-
-    /// Returns an iterator over the entries within a directory.
-    ///
-    /// The iterator will yield instances of `io::Result<DirEntry>`. New errors may
-    /// be encountered after an iterator is initially constructed.
-    ///
-    /// This is an alias to [`fs::read_dir`].
-    ///
-    /// [`fs::read_dir`]: ../fs/fn.read_dir.html
-
-    pub fn read_dir(&self) -> io::Result<fs::ReadDir> {
-        fs::read_dir(self)
-    }
-
-
-    /// Returns whether the path points at an existing entity.
-    ///
-    /// This function will traverse symbolic links to query information about the
-    /// destination file. In case of broken symbolic links this will return `false`.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::path::Path;
-    /// assert_eq!(Path::new("does_not_exist.txt").exists(), false);
-    /// ```
-
-    pub fn exists(&self) -> bool {
-        fs::metadata(self).is_ok()
-    }
-
-
-    /// Returns whether the path is pointing at a regular file.
-    ///
-    /// This function will traverse symbolic links to query information about the
-    /// destination file. In case of broken symbolic links this will return `false`.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::path::Path;
-    /// assert_eq!(Path::new("./is_a_directory/").is_file(), false);
-    /// assert_eq!(Path::new("a_file.txt").is_file(), true);
-    /// ```
-
-    pub fn is_file(&self) -> bool {
-        fs::metadata(self).map(|m| m.is_file()).unwrap_or(false)
-    }
-
-
-    /// Returns whether the path is pointing at a directory.
-    ///
-    /// This function will traverse symbolic links to query information about the
-    /// destination file. In case of broken symbolic links this will return `false`.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::path::Path;
-    /// assert_eq!(Path::new("./is_a_directory/").is_dir(), true);
-    /// assert_eq!(Path::new("a_file.txt").is_dir(), false);
-    /// ```
-
-    pub fn is_dir(&self) -> bool {
-        fs::metadata(self).map(|m| m.is_dir()).unwrap_or(false)
-    }
-    */
-}
-
-impl AsRef<OsStr> for Path {
-    fn as_ref(&self) -> &OsStr {
-        &self.inner
-    }
-}
-
-impl fmt::Debug for Path {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        self.inner.fmt(formatter)
-    }
-}
-
-/// Helper struct for safely printing paths with `format!()` and `{}`
-pub struct Display<'a> {
-    path: &'a Path,
-}
-
-impl<'a> fmt::Debug for Display<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&self.path.to_string_lossy(), f)
-    }
-}
-
-impl<'a> fmt::Display for Display<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(&self.path.to_string_lossy(), f)
-    }
-}
-
-impl cmp::PartialEq for Path {
-    fn eq(&self, other: &Path) -> bool {
-        self.components().eq(other.components())
-    }
-}
-
-impl Hash for Path {
-    fn hash<H: Hasher>(&self, h: &mut H) {
-        for component in self.components() {
-            component.hash(h);
-        }
-    }
-}
-
-impl cmp::Eq for Path {}
-
-impl cmp::PartialOrd for Path {
-    fn partial_cmp(&self, other: &Path) -> Option<cmp::Ordering> {
-        self.components().partial_cmp(other.components())
-    }
-}
-
-impl cmp::Ord for Path {
-    fn cmp(&self, other: &Path) -> cmp::Ordering {
-        self.components().cmp(other.components())
-    }
-}
-
-impl AsRef<Path> for Path {
-    fn as_ref(&self) -> &Path {
-        self
-    }
-}
-
-impl AsRef<Path> for OsStr {
-    fn as_ref(&self) -> &Path {
-        Path::new(self)
-    }
-}
-
-impl<'a> AsRef<Path> for Cow<'a, OsStr> {
-    fn as_ref(&self) -> &Path {
-        Path::new(self)
-    }
-}
-
-impl AsRef<Path> for OsString {
-    fn as_ref(&self) -> &Path {
-        Path::new(self)
-    }
-}
-
-impl AsRef<Path> for str {
-    fn as_ref(&self) -> &Path {
-        Path::new(self)
-    }
-}
-
-impl AsRef<Path> for String {
-    fn as_ref(&self) -> &Path {
-        Path::new(self)
-    }
-}
-
-impl AsRef<Path> for PathBuf {
-    fn as_ref(&self) -> &Path {
-        self
-    }
-}
-
-impl<'a> IntoIterator for &'a PathBuf {
-    type Item = &'a OsStr;
-    type IntoIter = Iter<'a>;
-    fn into_iter(self) -> Iter<'a> { self.iter() }
-}
-
-impl<'a> IntoIterator for &'a Path {
-    type Item = &'a OsStr;
-    type IntoIter = Iter<'a>;
-    fn into_iter(self) -> Iter<'a> { self.iter() }
-}
-
-macro_rules! impl_cmp {
-    ($lhs:ty, $rhs: ty) => {
-        impl<'a, 'b> PartialEq<$rhs> for $lhs {
-            #[inline]
-            fn eq(&self, other: &$rhs) -> bool { <Path as PartialEq>::eq(self, other) }
-        }
-
-        impl<'a, 'b> PartialEq<$lhs> for $rhs {
-            #[inline]
-            fn eq(&self, other: &$lhs) -> bool { <Path as PartialEq>::eq(self, other) }
-        }
-
-        impl<'a, 'b> PartialOrd<$rhs> for $lhs {
-            #[inline]
-            fn partial_cmp(&self, other: &$rhs) -> Option<cmp::Ordering> {
-                <Path as PartialOrd>::partial_cmp(self, other)
-            }
-        }
-
-        impl<'a, 'b> PartialOrd<$lhs> for $rhs {
-            #[inline]
-            fn partial_cmp(&self, other: &$lhs) -> Option<cmp::Ordering> {
-                <Path as PartialOrd>::partial_cmp(self, other)
-            }
-        }
-    }
-}
-
-impl_cmp!(PathBuf, Path);
-impl_cmp!(PathBuf, &'a Path);
-impl_cmp!(Cow<'a, Path>, Path);
-impl_cmp!(Cow<'a, Path>, &'b Path);
-impl_cmp!(Cow<'a, Path>, PathBuf);
-
-macro_rules! impl_cmp_os_str {
-    ($lhs:ty, $rhs: ty) => {
-        impl<'a, 'b> PartialEq<$rhs> for $lhs {
-            #[inline]
-            fn eq(&self, other: &$rhs) -> bool { <Path as PartialEq>::eq(self, other.as_ref()) }
-        }
-
-        impl<'a, 'b> PartialEq<$lhs> for $rhs {
-            #[inline]
-            fn eq(&self, other: &$lhs) -> bool { <Path as PartialEq>::eq(self.as_ref(), other) }
-        }
-
-        impl<'a, 'b> PartialOrd<$rhs> for $lhs {
-            #[inline]
-            fn partial_cmp(&self, other: &$rhs) -> Option<cmp::Ordering> {
-                <Path as PartialOrd>::partial_cmp(self, other.as_ref())
-            }
-        }
-
-        impl<'a, 'b> PartialOrd<$lhs> for $rhs {
-            #[inline]
-            fn partial_cmp(&self, other: &$lhs) -> Option<cmp::Ordering> {
-                <Path as PartialOrd>::partial_cmp(self.as_ref(), other)
-            }
-        }
-    }
-}
-
-impl_cmp_os_str!(PathBuf, OsStr);
-impl_cmp_os_str!(PathBuf, &'a OsStr);
-impl_cmp_os_str!(PathBuf, Cow<'a, OsStr>);
-impl_cmp_os_str!(PathBuf, OsString);
-impl_cmp_os_str!(Path, OsStr);
-impl_cmp_os_str!(Path, &'a OsStr);
-impl_cmp_os_str!(Path, Cow<'a, OsStr>);
-impl_cmp_os_str!(Path, OsString);
-impl_cmp_os_str!(&'a Path, OsStr);
-impl_cmp_os_str!(&'a Path, Cow<'b, OsStr>);
-impl_cmp_os_str!(&'a Path, OsString);
-impl_cmp_os_str!(Cow<'a, Path>, OsStr);
-impl_cmp_os_str!(Cow<'a, Path>, &'b OsStr);
-impl_cmp_os_str!(Cow<'a, Path>, OsString);
-
-/*
-impl fmt::Display for StripPrefixError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.description().fmt(f)
-    }
-}
-*/
-
-/*
-impl Error for StripPrefixError {
-    fn description(&self) -> &str { "prefix not found" }
-}
-*/
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use collections::string::{ToString, String};
-    use collections::borrow;
-    use collections::Vec;
-
-    macro_rules! t(
-        ($path:expr, iter: $iter:expr) => (
-            {
-                let path = Path::new($path);
-
-                // Forward iteration
-                let comps = path.iter()
-                    .map(|p| p.to_string_lossy().into_owned())
-                    .collect::<Vec<String>>();
-                let exp: &[&str] = &$iter;
-                let exps = exp.iter().map(|s| s.to_string()).collect::<Vec<String>>();
-                assert!(comps == exps, "iter: Expected {:?}, found {:?}",
-                        exps, comps);
-
-                // Reverse iteration
-                let comps = Path::new($path).iter().rev()
-                    .map(|p| p.to_string_lossy().into_owned())
-                    .collect::<Vec<String>>();
-                let exps = exps.into_iter().rev().collect::<Vec<String>>();
-                assert!(comps == exps, "iter().rev(): Expected {:?}, found {:?}",
-                        exps, comps);
-            }
-        );
-
-        ($path:expr, has_root: $has_root:expr, is_absolute: $is_absolute:expr) => (
-            {
-                let path = Path::new($path);
-
-                let act_root = path.has_root();
-                assert!(act_root == $has_root, "has_root: Expected {:?}, found {:?}",
-                        $has_root, act_root);
-
-                let act_abs = path.is_absolute();
-                assert!(act_abs == $is_absolute, "is_absolute: Expected {:?}, found {:?}",
-                        $is_absolute, act_abs);
-            }
-        );
-
-        ($path:expr, parent: $parent:expr, file_name: $file:expr) => (
-            {
-                let path = Path::new($path);
-
-                let parent = path.parent().map(|p| p.to_str().unwrap());
-                let exp_parent: Option<&str> = $parent;
-                assert!(parent == exp_parent, "parent: Expected {:?}, found {:?}",
-                        exp_parent, parent);
-
-                let file = path.file_name().map(|p| p.to_str().unwrap());
-                let exp_file: Option<&str> = $file;
-                assert!(file == exp_file, "file_name: Expected {:?}, found {:?}",
-                        exp_file, file);
-            }
-        );
-
-        ($path:expr, file_stem: $file_stem:expr, extension: $extension:expr) => (
-            {
-                let path = Path::new($path);
-
-                let stem = path.file_stem().map(|p| p.to_str().unwrap());
-                let exp_stem: Option<&str> = $file_stem;
-                assert!(stem == exp_stem, "file_stem: Expected {:?}, found {:?}",
-                        exp_stem, stem);
-
-                let ext = path.extension().map(|p| p.to_str().unwrap());
-                let exp_ext: Option<&str> = $extension;
-                assert!(ext == exp_ext, "extension: Expected {:?}, found {:?}",
-                        exp_ext, ext);
-            }
-        );
-
-        ($path:expr, iter: $iter:expr,
-                     has_root: $has_root:expr, is_absolute: $is_absolute:expr,
-                     parent: $parent:expr, file_name: $file:expr,
-                     file_stem: $file_stem:expr, extension: $extension:expr) => (
-            {
-                t!($path, iter: $iter);
-                t!($path, has_root: $has_root, is_absolute: $is_absolute);
-                t!($path, parent: $parent, file_name: $file);
-                t!($path, file_stem: $file_stem, extension: $extension);
-            }
-        );
-    );
-
-    #[test]
-    fn into() {
-        use collections::borrow::Cow;
-
-        let static_path = Path::new("/home/foo");
-        let static_cow_path: Cow<'static, Path> = static_path.into();
-        let pathbuf = PathBuf::from("/home/foo");
-
-        {
-            let path: &Path = &pathbuf;
-            let borrowed_cow_path: Cow<Path> = path.into();
-
-            assert_eq!(static_cow_path, borrowed_cow_path);
-        }
-
-        let owned_cow_path: Cow<'static, Path> = pathbuf.into();
-
-        assert_eq!(static_cow_path, owned_cow_path);
-    }
-
-    #[test]
-    #[cfg(unix)]
-    pub fn test_decompositions_unix() {
-        t!("",
-           iter: [],
-           has_root: false,
-           is_absolute: false,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("foo",
-           iter: ["foo"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
-
-        t!("/",
-           iter: ["/"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("/foo",
-           iter: ["/", "foo"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("/"),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
-
-        t!("foo/",
-           iter: ["foo"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
-
-        t!("/foo/",
-           iter: ["/", "foo"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("/"),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
-
-        t!("foo/bar",
-           iter: ["foo", "bar"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("foo"),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
-
-        t!("/foo/bar",
-           iter: ["/", "foo", "bar"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("/foo"),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
-
-        t!("///foo///",
-           iter: ["/", "foo"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("/"),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
-
-        t!("///foo///bar",
-           iter: ["/", "foo", "bar"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("///foo"),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
-
-        t!("./.",
-           iter: ["."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("/..",
-           iter: ["/", ".."],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("/"),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("../",
-           iter: [".."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("foo/.",
-           iter: ["foo"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
-
-        t!("foo/..",
-           iter: ["foo", ".."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("foo"),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("foo/./",
-           iter: ["foo"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
-
-        t!("foo/./bar",
-           iter: ["foo", "bar"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("foo"),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
-
-        t!("foo/../",
-           iter: ["foo", ".."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("foo"),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("foo/../bar",
-           iter: ["foo", "..", "bar"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("foo/.."),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
-
-        t!("./a",
-           iter: [".", "a"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("."),
-           file_name: Some("a"),
-           file_stem: Some("a"),
-           extension: None
-           );
-
-        t!(".",
-           iter: ["."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("./",
-           iter: ["."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("a/b",
-           iter: ["a", "b"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("a"),
-           file_name: Some("b"),
-           file_stem: Some("b"),
-           extension: None
-           );
-
-        t!("a//b",
-           iter: ["a", "b"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("a"),
-           file_name: Some("b"),
-           file_stem: Some("b"),
-           extension: None
-           );
-
-        t!("a/./b",
-           iter: ["a", "b"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("a"),
-           file_name: Some("b"),
-           file_stem: Some("b"),
-           extension: None
-           );
-
-        t!("a/b/c",
-           iter: ["a", "b", "c"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("a/b"),
-           file_name: Some("c"),
-           file_stem: Some("c"),
-           extension: None
-           );
-
-        t!(".foo",
-           iter: [".foo"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: Some(".foo"),
-           file_stem: Some(".foo"),
-           extension: None
-           );
-    }
-
-    #[test]
-    #[cfg(windows)]
-    pub fn test_decompositions_windows() {
-        t!("",
-           iter: [],
-           has_root: false,
-           is_absolute: false,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("foo",
-           iter: ["foo"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
-
-        t!("/",
-           iter: ["\\"],
-           has_root: true,
-           is_absolute: false,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("\\",
-           iter: ["\\"],
-           has_root: true,
-           is_absolute: false,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("c:",
-           iter: ["c:"],
-           has_root: false,
-           is_absolute: false,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("c:\\",
-           iter: ["c:", "\\"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("c:/",
-           iter: ["c:", "\\"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("/foo",
-           iter: ["\\", "foo"],
-           has_root: true,
-           is_absolute: false,
-           parent: Some("/"),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
-
-        t!("foo/",
-           iter: ["foo"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
-
-        t!("/foo/",
-           iter: ["\\", "foo"],
-           has_root: true,
-           is_absolute: false,
-           parent: Some("/"),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
-
-        t!("foo/bar",
-           iter: ["foo", "bar"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("foo"),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
-
-        t!("/foo/bar",
-           iter: ["\\", "foo", "bar"],
-           has_root: true,
-           is_absolute: false,
-           parent: Some("/foo"),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
-
-        t!("///foo///",
-           iter: ["\\", "foo"],
-           has_root: true,
-           is_absolute: false,
-           parent: Some("/"),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
-
-        t!("///foo///bar",
-           iter: ["\\", "foo", "bar"],
-           has_root: true,
-           is_absolute: false,
-           parent: Some("///foo"),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
-
-        t!("./.",
-           iter: ["."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("/..",
-           iter: ["\\", ".."],
-           has_root: true,
-           is_absolute: false,
-           parent: Some("/"),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("../",
-           iter: [".."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("foo/.",
-           iter: ["foo"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
-
-        t!("foo/..",
-           iter: ["foo", ".."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("foo"),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("foo/./",
-           iter: ["foo"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: Some("foo"),
-           file_stem: Some("foo"),
-           extension: None
-           );
-
-        t!("foo/./bar",
-           iter: ["foo", "bar"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("foo"),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
-
-        t!("foo/../",
-           iter: ["foo", ".."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("foo"),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("foo/../bar",
-           iter: ["foo", "..", "bar"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("foo/.."),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
-
-        t!("./a",
-           iter: [".", "a"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("."),
-           file_name: Some("a"),
-           file_stem: Some("a"),
-           extension: None
-           );
-
-        t!(".",
-           iter: ["."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("./",
-           iter: ["."],
-           has_root: false,
-           is_absolute: false,
-           parent: Some(""),
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("a/b",
-           iter: ["a", "b"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("a"),
-           file_name: Some("b"),
-           file_stem: Some("b"),
-           extension: None
-           );
-
-        t!("a//b",
-           iter: ["a", "b"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("a"),
-           file_name: Some("b"),
-           file_stem: Some("b"),
-           extension: None
-           );
-
-        t!("a/./b",
-           iter: ["a", "b"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("a"),
-           file_name: Some("b"),
-           file_stem: Some("b"),
-           extension: None
-           );
-
-        t!("a/b/c",
-           iter: ["a", "b", "c"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("a/b"),
-           file_name: Some("c"),
-           file_stem: Some("c"),
-           extension: None);
-
-        t!("a\\b\\c",
-           iter: ["a", "b", "c"],
-           has_root: false,
-           is_absolute: false,
-           parent: Some("a\\b"),
-           file_name: Some("c"),
-           file_stem: Some("c"),
-           extension: None
-           );
-
-        t!("\\a",
-           iter: ["\\", "a"],
-           has_root: true,
-           is_absolute: false,
-           parent: Some("\\"),
-           file_name: Some("a"),
-           file_stem: Some("a"),
-           extension: None
-           );
-
-        t!("c:\\foo.txt",
-           iter: ["c:", "\\", "foo.txt"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("c:\\"),
-           file_name: Some("foo.txt"),
-           file_stem: Some("foo"),
-           extension: Some("txt")
-           );
-
-        t!("\\\\server\\share\\foo.txt",
-           iter: ["\\\\server\\share", "\\", "foo.txt"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("\\\\server\\share\\"),
-           file_name: Some("foo.txt"),
-           file_stem: Some("foo"),
-           extension: Some("txt")
-           );
-
-        t!("\\\\server\\share",
-           iter: ["\\\\server\\share", "\\"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("\\\\server",
-           iter: ["\\", "server"],
-           has_root: true,
-           is_absolute: false,
-           parent: Some("\\"),
-           file_name: Some("server"),
-           file_stem: Some("server"),
-           extension: None
-           );
-
-        t!("\\\\?\\bar\\foo.txt",
-           iter: ["\\\\?\\bar", "\\", "foo.txt"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("\\\\?\\bar\\"),
-           file_name: Some("foo.txt"),
-           file_stem: Some("foo"),
-           extension: Some("txt")
-           );
-
-        t!("\\\\?\\bar",
-           iter: ["\\\\?\\bar"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("\\\\?\\",
-           iter: ["\\\\?\\"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("\\\\?\\UNC\\server\\share\\foo.txt",
-           iter: ["\\\\?\\UNC\\server\\share", "\\", "foo.txt"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("\\\\?\\UNC\\server\\share\\"),
-           file_name: Some("foo.txt"),
-           file_stem: Some("foo"),
-           extension: Some("txt")
-           );
-
-        t!("\\\\?\\UNC\\server",
-           iter: ["\\\\?\\UNC\\server"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("\\\\?\\UNC\\",
-           iter: ["\\\\?\\UNC\\"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("\\\\?\\C:\\foo.txt",
-           iter: ["\\\\?\\C:", "\\", "foo.txt"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("\\\\?\\C:\\"),
-           file_name: Some("foo.txt"),
-           file_stem: Some("foo"),
-           extension: Some("txt")
-           );
-
-
-        t!("\\\\?\\C:\\",
-           iter: ["\\\\?\\C:", "\\"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-
-        t!("\\\\?\\C:",
-           iter: ["\\\\?\\C:"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-
-        t!("\\\\?\\foo/bar",
-           iter: ["\\\\?\\foo/bar"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-
-        t!("\\\\?\\C:/foo",
-           iter: ["\\\\?\\C:/foo"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-
-        t!("\\\\.\\foo\\bar",
-           iter: ["\\\\.\\foo", "\\", "bar"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("\\\\.\\foo\\"),
-           file_name: Some("bar"),
-           file_stem: Some("bar"),
-           extension: None
-           );
-
-
-        t!("\\\\.\\foo",
-           iter: ["\\\\.\\foo", "\\"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-
-        t!("\\\\.\\foo/bar",
-           iter: ["\\\\.\\foo/bar", "\\"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-
-        t!("\\\\.\\foo\\bar/baz",
-           iter: ["\\\\.\\foo", "\\", "bar", "baz"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("\\\\.\\foo\\bar"),
-           file_name: Some("baz"),
-           file_stem: Some("baz"),
-           extension: None
-           );
-
-
-        t!("\\\\.\\",
-           iter: ["\\\\.\\", "\\"],
-           has_root: true,
-           is_absolute: true,
-           parent: None,
-           file_name: None,
-           file_stem: None,
-           extension: None
-           );
-
-        t!("\\\\?\\a\\b\\",
-           iter: ["\\\\?\\a", "\\", "b"],
-           has_root: true,
-           is_absolute: true,
-           parent: Some("\\\\?\\a\\"),
-           file_name: Some("b"),
-           file_stem: Some("b"),
-           extension: None
-           );
-    }
-
-    #[test]
-    pub fn test_stem_ext() {
-        t!("foo",
-           file_stem: Some("foo"),
-           extension: None
-           );
-
-        t!("foo.",
-           file_stem: Some("foo"),
-           extension: Some("")
-           );
-
-        t!(".foo",
-           file_stem: Some(".foo"),
-           extension: None
-           );
-
-        t!("foo.txt",
-           file_stem: Some("foo"),
-           extension: Some("txt")
-           );
-
-        t!("foo.bar.txt",
-           file_stem: Some("foo.bar"),
-           extension: Some("txt")
-           );
-
-        t!("foo.bar.",
-           file_stem: Some("foo.bar"),
-           extension: Some("")
-           );
-
-        t!(".",
-           file_stem: None,
-           extension: None
-           );
-
-        t!("..",
-           file_stem: None,
-           extension: None
-           );
-
-        t!("",
-           file_stem: None,
-           extension: None
-           );
-    }
-
-    #[test]
-    pub fn test_push() {
-        macro_rules! tp(
-            ($path:expr, $push:expr, $expected:expr) => ( {
-                let mut actual = PathBuf::from($path);
-                actual.push($push);
-                assert!(actual.to_str() == Some($expected),
-                        "pushing {:?} onto {:?}: Expected {:?}, got {:?}",
-                        $push, $path, $expected, actual.to_str().unwrap());
-            });
-        );
-
-        if cfg!(unix) {
-            tp!("", "foo", "foo");
-            tp!("foo", "bar", "foo/bar");
-            tp!("foo/", "bar", "foo/bar");
-            tp!("foo//", "bar", "foo//bar");
-            tp!("foo/.", "bar", "foo/./bar");
-            tp!("foo./.", "bar", "foo././bar");
-            tp!("foo", "", "foo/");
-            tp!("foo", ".", "foo/.");
-            tp!("foo", "..", "foo/..");
-            tp!("foo", "/", "/");
-            tp!("/foo/bar", "/", "/");
-            tp!("/foo/bar", "/baz", "/baz");
-            tp!("/foo/bar", "./baz", "/foo/bar/./baz");
-        } else {
-            tp!("", "foo", "foo");
-            tp!("foo", "bar", r"foo\bar");
-            tp!("foo/", "bar", r"foo/bar");
-            tp!(r"foo\", "bar", r"foo\bar");
-            tp!("foo//", "bar", r"foo//bar");
-            tp!(r"foo\\", "bar", r"foo\\bar");
-            tp!("foo/.", "bar", r"foo/.\bar");
-            tp!("foo./.", "bar", r"foo./.\bar");
-            tp!(r"foo\.", "bar", r"foo\.\bar");
-            tp!(r"foo.\.", "bar", r"foo.\.\bar");
-            tp!("foo", "", "foo\\");
-            tp!("foo", ".", r"foo\.");
-            tp!("foo", "..", r"foo\..");
-            tp!("foo", "/", "/");
-            tp!("foo", r"\", r"\");
-            tp!("/foo/bar", "/", "/");
-            tp!(r"\foo\bar", r"\", r"\");
-            tp!("/foo/bar", "/baz", "/baz");
-            tp!("/foo/bar", r"\baz", r"\baz");
-            tp!("/foo/bar", "./baz", r"/foo/bar\./baz");
-            tp!("/foo/bar", r".\baz", r"/foo/bar\.\baz");
-
-            tp!("c:\\", "windows", "c:\\windows");
-            tp!("c:", "windows", "c:windows");
-
-            tp!("a\\b\\c", "d", "a\\b\\c\\d");
-            tp!("\\a\\b\\c", "d", "\\a\\b\\c\\d");
-            tp!("a\\b", "c\\d", "a\\b\\c\\d");
-            tp!("a\\b", "\\c\\d", "\\c\\d");
-            tp!("a\\b", ".", "a\\b\\.");
-            tp!("a\\b", "..\\c", "a\\b\\..\\c");
-            tp!("a\\b", "C:a.txt", "C:a.txt");
-            tp!("a\\b", "C:\\a.txt", "C:\\a.txt");
-            tp!("C:\\a", "C:\\b.txt", "C:\\b.txt");
-            tp!("C:\\a\\b\\c", "C:d", "C:d");
-            tp!("C:a\\b\\c", "C:d", "C:d");
-            tp!("C:", r"a\b\c", r"C:a\b\c");
-            tp!("C:", r"..\a", r"C:..\a");
-            tp!("\\\\server\\share\\foo",
-                "bar",
-                "\\\\server\\share\\foo\\bar");
-            tp!("\\\\server\\share\\foo", "C:baz", "C:baz");
-            tp!("\\\\?\\C:\\a\\b", "C:c\\d", "C:c\\d");
-            tp!("\\\\?\\C:a\\b", "C:c\\d", "C:c\\d");
-            tp!("\\\\?\\C:\\a\\b", "C:\\c\\d", "C:\\c\\d");
-            tp!("\\\\?\\foo\\bar", "baz", "\\\\?\\foo\\bar\\baz");
-            tp!("\\\\?\\UNC\\server\\share\\foo",
-                "bar",
-                "\\\\?\\UNC\\server\\share\\foo\\bar");
-            tp!("\\\\?\\UNC\\server\\share", "C:\\a", "C:\\a");
-            tp!("\\\\?\\UNC\\server\\share", "C:a", "C:a");
-
-            // Note: modified from old path API
-            tp!("\\\\?\\UNC\\server", "foo", "\\\\?\\UNC\\server\\foo");
-
-            tp!("C:\\a",
-                "\\\\?\\UNC\\server\\share",
-                "\\\\?\\UNC\\server\\share");
-            tp!("\\\\.\\foo\\bar", "baz", "\\\\.\\foo\\bar\\baz");
-            tp!("\\\\.\\foo\\bar", "C:a", "C:a");
-            // again, not sure about the following, but I'm assuming \\.\ should be verbatim
-            tp!("\\\\.\\foo", "..\\bar", "\\\\.\\foo\\..\\bar");
-
-            tp!("\\\\?\\C:", "foo", "\\\\?\\C:\\foo"); // this is a weird one
-        }
-    }
-
-    #[test]
-    pub fn test_pop() {
-        macro_rules! tp(
-            ($path:expr, $expected:expr, $output:expr) => ( {
-                let mut actual = PathBuf::from($path);
-                let output = actual.pop();
-                assert!(actual.to_str() == Some($expected) && output == $output,
-                        "popping from {:?}: Expected {:?}/{:?}, got {:?}/{:?}",
-                        $path, $expected, $output,
-                        actual.to_str().unwrap(), output);
-            });
-        );
-
-        tp!("", "", false);
-        tp!("/", "/", false);
-        tp!("foo", "", true);
-        tp!(".", "", true);
-        tp!("/foo", "/", true);
-        tp!("/foo/bar", "/foo", true);
-        tp!("foo/bar", "foo", true);
-        tp!("foo/.", "", true);
-        tp!("foo//bar", "foo", true);
-
-        if cfg!(windows) {
-            tp!("a\\b\\c", "a\\b", true);
-            tp!("\\a", "\\", true);
-            tp!("\\", "\\", false);
-
-            tp!("C:\\a\\b", "C:\\a", true);
-            tp!("C:\\a", "C:\\", true);
-            tp!("C:\\", "C:\\", false);
-            tp!("C:a\\b", "C:a", true);
-            tp!("C:a", "C:", true);
-            tp!("C:", "C:", false);
-            tp!("\\\\server\\share\\a\\b", "\\\\server\\share\\a", true);
-            tp!("\\\\server\\share\\a", "\\\\server\\share\\", true);
-            tp!("\\\\server\\share", "\\\\server\\share", false);
-            tp!("\\\\?\\a\\b\\c", "\\\\?\\a\\b", true);
-            tp!("\\\\?\\a\\b", "\\\\?\\a\\", true);
-            tp!("\\\\?\\a", "\\\\?\\a", false);
-            tp!("\\\\?\\C:\\a\\b", "\\\\?\\C:\\a", true);
-            tp!("\\\\?\\C:\\a", "\\\\?\\C:\\", true);
-            tp!("\\\\?\\C:\\", "\\\\?\\C:\\", false);
-            tp!("\\\\?\\UNC\\server\\share\\a\\b",
-                "\\\\?\\UNC\\server\\share\\a",
-                true);
-            tp!("\\\\?\\UNC\\server\\share\\a",
-                "\\\\?\\UNC\\server\\share\\",
-                true);
-            tp!("\\\\?\\UNC\\server\\share",
-                "\\\\?\\UNC\\server\\share",
-                false);
-            tp!("\\\\.\\a\\b\\c", "\\\\.\\a\\b", true);
-            tp!("\\\\.\\a\\b", "\\\\.\\a\\", true);
-            tp!("\\\\.\\a", "\\\\.\\a", false);
-
-            tp!("\\\\?\\a\\b\\", "\\\\?\\a\\", true);
-        }
-    }
-
-    #[test]
-    pub fn test_set_file_name() {
-        macro_rules! tfn(
-                ($path:expr, $file:expr, $expected:expr) => ( {
-                let mut p = PathBuf::from($path);
-                p.set_file_name($file);
-                assert!(p.to_str() == Some($expected),
-                        "setting file name of {:?} to {:?}: Expected {:?}, got {:?}",
-                        $path, $file, $expected,
-                        p.to_str().unwrap());
-            });
-        );
-
-        tfn!("foo", "foo", "foo");
-        tfn!("foo", "bar", "bar");
-        tfn!("foo", "", "");
-        tfn!("", "foo", "foo");
-        if cfg!(unix) {
-            tfn!(".", "foo", "./foo");
-            tfn!("foo/", "bar", "bar");
-            tfn!("foo/.", "bar", "bar");
-            tfn!("..", "foo", "../foo");
-            tfn!("foo/..", "bar", "foo/../bar");
-            tfn!("/", "foo", "/foo");
-        } else {
-            tfn!(".", "foo", r".\foo");
-            tfn!(r"foo\", "bar", r"bar");
-            tfn!(r"foo\.", "bar", r"bar");
-            tfn!("..", "foo", r"..\foo");
-            tfn!(r"foo\..", "bar", r"foo\..\bar");
-            tfn!(r"\", "foo", r"\foo");
-        }
-    }
-
-    #[test]
-    pub fn test_set_extension() {
-        macro_rules! tfe(
-                ($path:expr, $ext:expr, $expected:expr, $output:expr) => ( {
-                let mut p = PathBuf::from($path);
-                let output = p.set_extension($ext);
-                assert!(p.to_str() == Some($expected) && output == $output,
-                        "setting extension of {:?} to {:?}: Expected {:?}/{:?}, got {:?}/{:?}",
-                        $path, $ext, $expected, $output,
-                        p.to_str().unwrap(), output);
-            });
-        );
-
-        tfe!("foo", "txt", "foo.txt", true);
-        tfe!("foo.bar", "txt", "foo.txt", true);
-        tfe!("foo.bar.baz", "txt", "foo.bar.txt", true);
-        tfe!(".test", "txt", ".test.txt", true);
-        tfe!("foo.txt", "", "foo", true);
-        tfe!("foo", "", "foo", true);
-        tfe!("", "foo", "", false);
-        tfe!(".", "foo", ".", false);
-        tfe!("foo/", "bar", "foo.bar", true);
-        tfe!("foo/.", "bar", "foo.bar", true);
-        tfe!("..", "foo", "..", false);
-        tfe!("foo/..", "bar", "foo/..", false);
-        tfe!("/", "foo", "/", false);
-    }
-
-    #[test]
-    fn test_eq_recievers() {
-        use collections::borrow::Cow;
-
-        let borrowed: &Path = Path::new("foo/bar");
-        let mut owned: PathBuf = PathBuf::new();
-        owned.push("foo");
-        owned.push("bar");
-        let borrowed_cow: Cow<Path> = borrowed.into();
-        let owned_cow: Cow<Path> = owned.clone().into();
-
-        macro_rules! t {
-            ($($current:expr),+) => {
-                $(
-                    assert_eq!($current, borrowed);
-                    assert_eq!($current, owned);
-                    assert_eq!($current, borrowed_cow);
-                    assert_eq!($current, owned_cow);
-                )+
-            }
-        }
-
-        t!(borrowed, owned, borrowed_cow, owned_cow);
-    }
-
-    #[test]
-    pub fn test_compare() {
-        use core::hash::{Hash, Hasher, SipHasher};
-
-        fn hash<T: Hash>(t: T) -> u64 {
-            let mut s = SipHasher::new_with_keys(0, 0);
-            t.hash(&mut s);
-            s.finish()
-        }
-
-        macro_rules! tc(
-            ($path1:expr, $path2:expr, eq: $eq:expr,
-             starts_with: $starts_with:expr, ends_with: $ends_with:expr,
-             relative_from: $relative_from:expr) => ({
-                 let path1 = Path::new($path1);
-                 let path2 = Path::new($path2);
-
-                 let eq = path1 == path2;
-                 assert!(eq == $eq, "{:?} == {:?}, expected {:?}, got {:?}",
-                         $path1, $path2, $eq, eq);
-                 assert!($eq == (hash(path1) == hash(path2)),
-                         "{:?} == {:?}, expected {:?}, got {} and {}",
-                         $path1, $path2, $eq, hash(path1), hash(path2));
-
-                 let starts_with = path1.starts_with(path2);
-                 assert!(starts_with == $starts_with,
-                         "{:?}.starts_with({:?}), expected {:?}, got {:?}", $path1, $path2,
-                         $starts_with, starts_with);
-
-                 let ends_with = path1.ends_with(path2);
-                 assert!(ends_with == $ends_with,
-                         "{:?}.ends_with({:?}), expected {:?}, got {:?}", $path1, $path2,
-                         $ends_with, ends_with);
-
-                 let relative_from = path1.strip_prefix(path2)
-                                          .map(|p| p.to_str().unwrap())
-                                          .ok();
-                 let exp: Option<&str> = $relative_from;
-                 assert!(relative_from == exp,
-                         "{:?}.strip_prefix({:?}), expected {:?}, got {:?}",
-                         $path1, $path2, exp, relative_from);
-            });
-        );
-
-        tc!("", "",
-            eq: true,
-            starts_with: true,
-            ends_with: true,
-            relative_from: Some("")
-            );
-
-        tc!("foo", "",
-            eq: false,
-            starts_with: true,
-            ends_with: true,
-            relative_from: Some("foo")
-            );
-
-        tc!("", "foo",
-            eq: false,
-            starts_with: false,
-            ends_with: false,
-            relative_from: None
-            );
-
-        tc!("foo", "foo",
-            eq: true,
-            starts_with: true,
-            ends_with: true,
-            relative_from: Some("")
-            );
-
-        tc!("foo/", "foo",
-            eq: true,
-            starts_with: true,
-            ends_with: true,
-            relative_from: Some("")
-            );
-
-        tc!("foo/bar", "foo",
-            eq: false,
-            starts_with: true,
-            ends_with: false,
-            relative_from: Some("bar")
-            );
-
-        tc!("foo/bar/baz", "foo/bar",
-            eq: false,
-            starts_with: true,
-            ends_with: false,
-            relative_from: Some("baz")
-            );
-
-        tc!("foo/bar", "foo/bar/baz",
-            eq: false,
-            starts_with: false,
-            ends_with: false,
-            relative_from: None
-            );
-
-        tc!("./foo/bar/", ".",
-            eq: false,
-            starts_with: true,
-            ends_with: false,
-            relative_from: Some("foo/bar")
-            );
-
-        if cfg!(windows) {
-            tc!(r"C:\src\rust\cargo-test\test\Cargo.toml",
-                r"c:\src\rust\cargo-test\test",
-                eq: false,
-                starts_with: true,
-                ends_with: false,
-                relative_from: Some("Cargo.toml")
-                );
-
-            tc!(r"c:\foo", r"C:\foo",
-                eq: true,
-                starts_with: true,
-                ends_with: true,
-                relative_from: Some("")
-                );
-        }
-    }
-}
diff --git a/src/system/rt.rs b/src/system/rt.rs
deleted file mode 100644
index e9514f5..0000000
--- a/src/system/rt.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-use std::mem;
-
-//TODO: Handle argc/argv arguments
-#[lang = "start"]
-#[allow(unused_variables)]
-fn lang_start(main: *const u8, argc: isize, argv: *const *const u8) -> isize {
-    unsafe { mem::transmute::<_, fn()>(main)(); }
-    0
-}
diff --git a/src/system/sys/mod.rs b/src/system/sys/mod.rs
deleted file mode 100644
index 86f49e5..0000000
--- a/src/system/sys/mod.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-/// A trait for viewing representations from std types
-#[doc(hidden)]
-pub trait AsInner<Inner: ?Sized> {
-    fn as_inner(&self) -> &Inner;
-}
-
-/// A trait for viewing representations from std types
-#[doc(hidden)]
-pub trait AsInnerMut<Inner: ?Sized> {
-    fn as_inner_mut(&mut self) -> &mut Inner;
-}
-
-/// A trait for extracting representations from std types
-#[doc(hidden)]
-pub trait IntoInner<Inner> {
-    fn into_inner(self) -> Inner;
-}
-
-/// A trait for creating std types from internal representations
-#[doc(hidden)]
-pub trait FromInner<Inner> {
-    fn from_inner(inner: Inner) -> Self;
-}
-
-pub mod wtf8;
diff --git a/src/system/sys/wtf8.rs b/src/system/sys/wtf8.rs
deleted file mode 100644
index 0bbae42..0000000
--- a/src/system/sys/wtf8.rs
+++ /dev/null
@@ -1,1204 +0,0 @@
-// 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Implementation of [the WTF-8 encoding](https://simonsapin.github.io/wtf-8/).
-//!
-//! This library uses Rust’s type system to maintain
-//! [well-formedness](https://simonsapin.github.io/wtf-8/#well-formed),
-//! like the `String` and `&str` types do for UTF-8.
-//!
-//! Since [WTF-8 must not be used
-//! for interchange](https://simonsapin.github.io/wtf-8/#intended-audience),
-//! this library deliberately does not provide access to the underlying bytes
-//! of WTF-8 strings,
-//! nor can it decode WTF-8 from arbitrary bytes.
-//! WTF-8 strings can be obtained from UTF-8, UTF-16, or code points.
-
-// this module is imported from @SimonSapin's repo and has tons of dead code on
-// unix (it's mostly used on windows), so don't worry about dead code here.
-#![allow(dead_code)]
-
-use core::str::next_code_point;
-
-use std::ascii::*;
-use std::borrow::Cow;
-use rustc_unicode::char;
-use std::fmt;
-use std::hash::{Hash, Hasher};
-use std::iter::FromIterator;
-use std::mem;
-use std::ops;
-use std::slice;
-use std::str;
-use super::AsInner;
-
-const UTF8_REPLACEMENT_CHARACTER: &'static [u8] = b"\xEF\xBF\xBD";
-
-/// A Unicode code point: from U+0000 to U+10FFFF.
-///
-/// Compare with the `char` type,
-/// which represents a Unicode scalar value:
-/// a code point that is not a surrogate (U+D800 to U+DFFF).
-#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy)]
-pub struct CodePoint {
-    value: u32,
-}
-
-/// Format the code point as `U+` followed by four to six hexadecimal digits.
-/// Example: `U+1F4A9`
-impl fmt::Debug for CodePoint {
-    #[inline]
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        write!(formatter, "U+{:04X}", self.value)
-    }
-}
-
-impl CodePoint {
-    /// Unsafely creates a new `CodePoint` without checking the value.
-    ///
-    /// Only use when `value` is known to be less than or equal to 0x10FFFF.
-    #[inline]
-    pub unsafe fn from_u32_unchecked(value: u32) -> CodePoint {
-        CodePoint { value: value }
-    }
-
-    /// Creates a new `CodePoint` if the value is a valid code point.
-    ///
-    /// Returns `None` if `value` is above 0x10FFFF.
-    #[inline]
-    pub fn from_u32(value: u32) -> Option<CodePoint> {
-        match value {
-            0...0x10FFFF => Some(CodePoint { value: value }),
-            _ => None,
-        }
-    }
-
-    /// Creates a new `CodePoint` from a `char`.
-    ///
-    /// Since all Unicode scalar values are code points, this always succeeds.
-    #[inline]
-    pub fn from_char(value: char) -> CodePoint {
-        CodePoint { value: value as u32 }
-    }
-
-    /// Returns the numeric value of the code point.
-    #[inline]
-    pub fn to_u32(&self) -> u32 {
-        self.value
-    }
-
-    /// Optionally returns a Unicode scalar value for the code point.
-    ///
-    /// Returns `None` if the code point is a surrogate (from U+D800 to U+DFFF).
-    #[inline]
-    pub fn to_char(&self) -> Option<char> {
-        match self.value {
-            0xD800...0xDFFF => None,
-            _ => Some(unsafe { char::from_u32_unchecked(self.value) }),
-        }
-    }
-
-    /// Returns a Unicode scalar value for the code point.
-    ///
-    /// Returns `'\u{FFFD}'` (the replacement character “�”)
-    /// if the code point is a surrogate (from U+D800 to U+DFFF).
-    #[inline]
-    pub fn to_char_lossy(&self) -> char {
-        self.to_char().unwrap_or('\u{FFFD}')
-    }
-}
-
-/// An owned, growable string of well-formed WTF-8 data.
-///
-/// Similar to `String`, but can additionally contain surrogate code points
-/// if they’re not in a surrogate pair.
-#[derive(Eq, PartialEq, Ord, PartialOrd, Clone)]
-pub struct Wtf8Buf {
-    bytes: Vec<u8>,
-}
-
-impl ops::Deref for Wtf8Buf {
-    type Target = Wtf8;
-
-    fn deref(&self) -> &Wtf8 {
-        self.as_slice()
-    }
-}
-
-/// Format the string with double quotes,
-/// and surrogates as `\u` followed by four hexadecimal digits.
-/// Example: `"a\u{D800}"` for a string with code points [U+0061, U+D800]
-impl fmt::Debug for Wtf8Buf {
-    #[inline]
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        fmt::Debug::fmt(&**self, formatter)
-    }
-}
-
-impl Wtf8Buf {
-    /// Creates a new, empty WTF-8 string.
-    #[inline]
-    pub fn new() -> Wtf8Buf {
-        Wtf8Buf { bytes: Vec::new() }
-    }
-
-    /// Creates a new, empty WTF-8 string with pre-allocated capacity for `n` bytes.
-    #[inline]
-    pub fn with_capacity(n: usize) -> Wtf8Buf {
-        Wtf8Buf { bytes: Vec::with_capacity(n) }
-    }
-
-    /// Creates a WTF-8 string from a UTF-8 `String`.
-    ///
-    /// This takes ownership of the `String` and does not copy.
-    ///
-    /// Since WTF-8 is a superset of UTF-8, this always succeeds.
-    #[inline]
-    pub fn from_string(string: String) -> Wtf8Buf {
-        Wtf8Buf { bytes: string.into_bytes() }
-    }
-
-    /// Creates a WTF-8 string from a 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()) }
-    }
-
-    pub fn clear(&mut self) {
-        self.bytes.clear()
-    }
-
-    /// Creates 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
-    /// will always return the original code units.
-    pub fn from_wide(v: &[u16]) -> Wtf8Buf {
-        let mut string = Wtf8Buf::with_capacity(v.len());
-        for item in char::decode_utf16(v.iter().cloned()) {
-            match item {
-                Ok(ch) => string.push_char(ch),
-                Err(surrogate) => {
-                    let surrogate = surrogate.unpaired_surrogate();
-                    // Surrogates are known to be in the code point range.
-                    let code_point = unsafe { CodePoint::from_u32_unchecked(surrogate as u32) };
-                    // Skip the WTF-8 concatenation check,
-                    // surrogate pairs are already decoded by decode_utf16
-                    string.push_code_point_unchecked(code_point)
-                }
-            }
-        }
-        string
-    }
-
-    /// Copied from String::push
-    /// This does **not** include the WTF-8 concatenation check.
-    fn push_code_point_unchecked(&mut self, code_point: CodePoint) {
-        let c = unsafe {
-            char::from_u32_unchecked(code_point.value)
-        };
-        let mut bytes = [0; 4];
-        let bytes = c.encode_utf8(&mut bytes).as_bytes();
-        self.bytes.extend_from_slice(bytes)
-    }
-
-    #[inline]
-    pub fn as_slice(&self) -> &Wtf8 {
-        unsafe { Wtf8::from_bytes_unchecked(&self.bytes) }
-    }
-
-    /// Reserves capacity for at least `additional` more bytes to be inserted
-    /// in the given `Wtf8Buf`.
-    /// The collection may reserve more space to avoid frequent reallocations.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the new capacity overflows `usize`.
-    #[inline]
-    pub fn reserve(&mut self, additional: usize) {
-        self.bytes.reserve(additional)
-    }
-
-    #[inline]
-    pub fn reserve_exact(&mut self, additional: usize) {
-        self.bytes.reserve_exact(additional)
-    }
-
-    /// Returns the number of bytes that this string buffer can hold without reallocating.
-    #[inline]
-    pub fn capacity(&self) -> usize {
-        self.bytes.capacity()
-    }
-
-    /// Append a UTF-8 slice at the end of the string.
-    #[inline]
-    pub fn push_str(&mut self, other: &str) {
-        self.bytes.extend_from_slice(other.as_bytes())
-    }
-
-    /// Append a WTF-8 slice at the end of the string.
-    ///
-    /// This replaces newly paired surrogates at the boundary
-    /// with a supplementary code point,
-    /// like concatenating ill-formed UTF-16 strings effectively would.
-    #[inline]
-    pub fn push_wtf8(&mut self, other: &Wtf8) {
-        match ((&*self).final_lead_surrogate(), other.initial_trail_surrogate()) {
-            // Replace newly paired surrogates by a supplementary code point.
-            (Some(lead), Some(trail)) => {
-                let len_without_lead_surrogate = self.len() - 3;
-                self.bytes.truncate(len_without_lead_surrogate);
-                let other_without_trail_surrogate = &other.bytes[3..];
-                // 4 bytes for the supplementary code point
-                self.bytes.reserve(4 + other_without_trail_surrogate.len());
-                self.push_char(decode_surrogate_pair(lead, trail));
-                self.bytes.extend_from_slice(other_without_trail_surrogate);
-            }
-            _ => self.bytes.extend_from_slice(&other.bytes),
-        }
-    }
-
-    /// Append a Unicode scalar value at the end of the string.
-    #[inline]
-    pub fn push_char(&mut self, c: char) {
-        self.push_code_point_unchecked(CodePoint::from_char(c))
-    }
-
-    /// Append a code point at the end of the string.
-    ///
-    /// This replaces newly paired surrogates at the boundary
-    /// with a supplementary code point,
-    /// like concatenating ill-formed UTF-16 strings effectively would.
-    #[inline]
-    pub fn push(&mut self, code_point: CodePoint) {
-        if let trail @ 0xDC00...0xDFFF = code_point.to_u32() {
-            if let Some(lead) = (&*self).final_lead_surrogate() {
-                let len_without_lead_surrogate = self.len() - 3;
-                self.bytes.truncate(len_without_lead_surrogate);
-                self.push_char(decode_surrogate_pair(lead, trail as u16));
-                return;
-            }
-        }
-
-        // No newly paired surrogates at the boundary.
-        self.push_code_point_unchecked(code_point)
-    }
-
-    /// Shortens a string to the specified length.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `new_len` > current length,
-    /// or if `new_len` is not a code point boundary.
-    #[inline]
-    pub fn truncate(&mut self, new_len: usize) {
-        assert!(is_code_point_boundary(self, new_len));
-        self.bytes.truncate(new_len)
-    }
-
-    /// Consumes the WTF-8 string and tries to convert it to UTF-8.
-    ///
-    /// This does not copy the data.
-    ///
-    /// If the contents are not well-formed UTF-8
-    /// (that is, if the string contains surrogates),
-    /// the original WTF-8 string is returned instead.
-    pub fn into_string(self) -> Result<String, Wtf8Buf> {
-        match self.next_surrogate(0) {
-            None => Ok(unsafe { String::from_utf8_unchecked(self.bytes) }),
-            Some(_) => Err(self),
-        }
-    }
-
-    /// Consumes the WTF-8 string and converts it lossily to UTF-8.
-    ///
-    /// This does not copy the data (but may overwrite parts of it in place).
-    ///
-    /// Surrogates are replaced with `"\u{FFFD}"` (the replacement character “�”)
-    pub fn into_string_lossy(mut self) -> String {
-        let mut pos = 0;
-        loop {
-            match self.next_surrogate(pos) {
-                Some((surrogate_pos, _)) => {
-                    pos = surrogate_pos + 3;
-                    self.bytes[surrogate_pos..pos].copy_from_slice(UTF8_REPLACEMENT_CHARACTER);
-                }
-                None => return unsafe { String::from_utf8_unchecked(self.bytes) },
-            }
-        }
-    }
-}
-
-/// Create a new WTF-8 string from an iterator of code points.
-///
-/// This replaces surrogate code point pairs with supplementary code points,
-/// like concatenating ill-formed UTF-16 strings effectively would.
-impl FromIterator<CodePoint> for Wtf8Buf {
-    fn from_iter<T: IntoIterator<Item = CodePoint>>(iter: T) -> Wtf8Buf {
-        let mut string = Wtf8Buf::new();
-        string.extend(iter);
-        string
-    }
-}
-
-/// Append code points from an iterator to the string.
-///
-/// This replaces surrogate code point pairs with supplementary code points,
-/// like concatenating ill-formed UTF-16 strings effectively would.
-impl Extend<CodePoint> for Wtf8Buf {
-    fn extend<T: IntoIterator<Item = CodePoint>>(&mut self, iter: T) {
-        let iterator = iter.into_iter();
-        let (low, _high) = iterator.size_hint();
-        // Lower bound of one byte per code point (ASCII only)
-        self.bytes.reserve(low);
-        for code_point in iterator {
-            self.push(code_point);
-        }
-    }
-}
-
-/// A borrowed slice of well-formed WTF-8 data.
-///
-/// Similar to `&str`, but can additionally contain surrogate code points
-/// if they’re not in a surrogate pair.
-#[derive(Eq, Ord, PartialEq, PartialOrd)]
-pub struct Wtf8 {
-    bytes: [u8],
-}
-
-impl AsInner<[u8]> for Wtf8 {
-    fn as_inner(&self) -> &[u8] {
-        &self.bytes
-    }
-}
-
-/// Format the slice with double quotes,
-/// and surrogates as `\u` followed by four hexadecimal digits.
-/// Example: `"a\u{D800}"` for a slice with code points [U+0061, U+D800]
-impl fmt::Debug for Wtf8 {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        fn write_str_escaped(f: &mut fmt::Formatter, s: &str) -> fmt::Result {
-            use core::fmt::Write;
-            for c in s.chars().flat_map(|c| c.escape_debug()) {
-                f.write_char(c)?
-            }
-            Ok(())
-        }
-
-        formatter.write_str("\"")?;
-        let mut pos = 0;
-        loop {
-            match self.next_surrogate(pos) {
-                None => break,
-                Some((surrogate_pos, surrogate)) => {
-                    write_str_escaped(formatter, unsafe {
-                            str::from_utf8_unchecked(&self.bytes[pos..surrogate_pos])
-                        })
-                        ?;
-                    write!(formatter, "\\u{{{:x}}}", surrogate)?;
-                    pos = surrogate_pos + 3;
-                }
-            }
-        }
-        write_str_escaped(formatter,
-                          unsafe { str::from_utf8_unchecked(&self.bytes[pos..]) })
-            ?;
-        formatter.write_str("\"")
-    }
-}
-
-impl Wtf8 {
-    /// Creates a WTF-8 slice from a UTF-8 `&str` slice.
-    ///
-    /// Since WTF-8 is a superset of UTF-8, this always succeeds.
-    #[inline]
-    pub fn from_str(value: &str) -> &Wtf8 {
-        unsafe { Wtf8::from_bytes_unchecked(value.as_bytes()) }
-    }
-
-    /// Creates a WTF-8 slice from a WTF-8 byte slice.
-    ///
-    /// Since the byte slice is not checked for valid WTF-8, this functions is
-    /// marked unsafe.
-    #[inline]
-    unsafe fn from_bytes_unchecked(value: &[u8]) -> &Wtf8 {
-        mem::transmute(value)
-    }
-
-    /// Returns the length, in WTF-8 bytes.
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.bytes.len()
-    }
-
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.bytes.is_empty()
-    }
-
-    /// Returns the code point at `position` if it is in the ASCII range,
-    /// or `b'\xFF' otherwise.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `position` is beyond the end of the string.
-    #[inline]
-    pub fn ascii_byte_at(&self, position: usize) -> u8 {
-        match self.bytes[position] {
-            ascii_byte @ 0x00...0x7F => ascii_byte,
-            _ => 0xFF,
-        }
-    }
-
-    /// Returns an iterator for the string’s code points.
-    #[inline]
-    pub fn code_points(&self) -> Wtf8CodePoints {
-        Wtf8CodePoints { bytes: self.bytes.iter() }
-    }
-
-    /// Tries to convert the string to UTF-8 and return a `&str` slice.
-    ///
-    /// Returns `None` if the string contains surrogates.
-    ///
-    /// This does not copy the data.
-    #[inline]
-    pub fn as_str(&self) -> Option<&str> {
-        // Well-formed WTF-8 is also well-formed UTF-8
-        // if and only if it contains no surrogate.
-        match self.next_surrogate(0) {
-            None => Some(unsafe { str::from_utf8_unchecked(&self.bytes) }),
-            Some(_) => None,
-        }
-    }
-
-    /// Lossily converts the string to UTF-8.
-    /// Returns a UTF-8 `&str` slice if the contents are well-formed in UTF-8.
-    ///
-    /// Surrogates are replaced with `"\u{FFFD}"` (the replacement character “�”).
-    ///
-    /// This only copies the data if necessary (if it contains any surrogate).
-    pub fn to_string_lossy(&self) -> Cow<str> {
-        let surrogate_pos = match self.next_surrogate(0) {
-            None => return Cow::Borrowed(unsafe { str::from_utf8_unchecked(&self.bytes) }),
-            Some((pos, _)) => pos,
-        };
-        let wtf8_bytes = &self.bytes;
-        let mut utf8_bytes = Vec::with_capacity(self.len());
-        utf8_bytes.extend_from_slice(&wtf8_bytes[..surrogate_pos]);
-        utf8_bytes.extend_from_slice(UTF8_REPLACEMENT_CHARACTER);
-        let mut pos = surrogate_pos + 3;
-        loop {
-            match self.next_surrogate(pos) {
-                Some((surrogate_pos, _)) => {
-                    utf8_bytes.extend_from_slice(&wtf8_bytes[pos..surrogate_pos]);
-                    utf8_bytes.extend_from_slice(UTF8_REPLACEMENT_CHARACTER);
-                    pos = surrogate_pos + 3;
-                }
-                None => {
-                    utf8_bytes.extend_from_slice(&wtf8_bytes[pos..]);
-                    return Cow::Owned(unsafe { String::from_utf8_unchecked(utf8_bytes) });
-                }
-            }
-        }
-    }
-
-    /// Converts the WTF-8 string to potentially ill-formed UTF-16
-    /// and return an iterator of 16-bit code units.
-    ///
-    /// This is lossless:
-    /// calling `Wtf8Buf::from_ill_formed_utf16` on the resulting code units
-    /// would always return the original WTF-8 string.
-    #[inline]
-    pub fn encode_wide(&self) -> EncodeWide {
-        EncodeWide {
-            code_points: self.code_points(),
-            extra: 0,
-        }
-    }
-
-    #[inline]
-    fn next_surrogate(&self, mut pos: usize) -> Option<(usize, u16)> {
-        let mut iter = self.bytes[pos..].iter();
-        loop {
-            let b = match iter.next() {
-                None => return None,
-                Some(&b) => b,
-            };
-            if b < 0x80 {
-                pos += 1;
-            } else if b < 0xE0 {
-                iter.next();
-                pos += 2;
-            } else if b == 0xED {
-                match (iter.next(), iter.next()) {
-                    (Some(&b2), Some(&b3)) if b2 >= 0xA0 => {
-                        return Some((pos, decode_surrogate(b2, b3)))
-                    }
-                    _ => pos += 3,
-                }
-            } else if b < 0xF0 {
-                iter.next();
-                iter.next();
-                pos += 3;
-            } else {
-                iter.next();
-                iter.next();
-                iter.next();
-                pos += 4;
-            }
-        }
-    }
-
-    #[inline]
-    fn final_lead_surrogate(&self) -> Option<u16> {
-        let len = self.len();
-        if len < 3 {
-            return None;
-        }
-        match &self.bytes[(len - 3)..] {
-            &[0xED, b2 @ 0xA0...0xAF, b3] => Some(decode_surrogate(b2, b3)),
-            _ => None,
-        }
-    }
-
-    #[inline]
-    fn initial_trail_surrogate(&self) -> Option<u16> {
-        let len = self.len();
-        if len < 3 {
-            return None;
-        }
-        match &self.bytes[..3] {
-            &[0xED, b2 @ 0xB0...0xBF, b3] => Some(decode_surrogate(b2, b3)),
-            _ => None,
-        }
-    }
-}
-
-
-/// Return a slice of the given string for the byte range [`begin`..`end`).
-///
-/// # Panics
-///
-/// Panics when `begin` and `end` do not point to code point boundaries,
-/// or point beyond the end of the string.
-impl ops::Index<ops::Range<usize>> for Wtf8 {
-    type Output = Wtf8;
-
-    #[inline]
-    fn index(&self, range: ops::Range<usize>) -> &Wtf8 {
-        // is_code_point_boundary checks that the index is in [0, .len()]
-        if range.start <= range.end && is_code_point_boundary(self, range.start) &&
-           is_code_point_boundary(self, range.end) {
-            unsafe { slice_unchecked(self, range.start, range.end) }
-        } else {
-            slice_error_fail(self, range.start, range.end)
-        }
-    }
-}
-
-/// Return a slice of the given string from byte `begin` to its end.
-///
-/// # Panics
-///
-/// Panics when `begin` is not at a code point boundary,
-/// or is beyond the end of the string.
-impl ops::Index<ops::RangeFrom<usize>> for Wtf8 {
-    type Output = Wtf8;
-
-    #[inline]
-    fn index(&self, range: ops::RangeFrom<usize>) -> &Wtf8 {
-        // is_code_point_boundary checks that the index is in [0, .len()]
-        if is_code_point_boundary(self, range.start) {
-            unsafe { slice_unchecked(self, range.start, self.len()) }
-        } else {
-            slice_error_fail(self, range.start, self.len())
-        }
-    }
-}
-
-/// Return a slice of the given string from its beginning to byte `end`.
-///
-/// # Panics
-///
-/// Panics when `end` is not at a code point boundary,
-/// or is beyond the end of the string.
-impl ops::Index<ops::RangeTo<usize>> for Wtf8 {
-    type Output = Wtf8;
-
-    #[inline]
-    fn index(&self, range: ops::RangeTo<usize>) -> &Wtf8 {
-        // is_code_point_boundary checks that the index is in [0, .len()]
-        if is_code_point_boundary(self, range.end) {
-            unsafe { slice_unchecked(self, 0, range.end) }
-        } else {
-            slice_error_fail(self, 0, range.end)
-        }
-    }
-}
-
-impl ops::Index<ops::RangeFull> for Wtf8 {
-    type Output = Wtf8;
-
-    #[inline]
-    fn index(&self, _range: ops::RangeFull) -> &Wtf8 {
-        self
-    }
-}
-
-#[inline]
-fn decode_surrogate(second_byte: u8, third_byte: u8) -> u16 {
-    // The first byte is assumed to be 0xED
-    0xD800 | (second_byte as u16 & 0x3F) << 6 | third_byte as u16 & 0x3F
-}
-
-#[inline]
-fn decode_surrogate_pair(lead: u16, trail: u16) -> char {
-    let code_point = 0x10000 + ((((lead - 0xD800) as u32) << 10) | (trail - 0xDC00) as u32);
-    unsafe { char::from_u32_unchecked(code_point) }
-}
-
-/// Copied from core::str::StrPrelude::is_char_boundary
-#[inline]
-pub fn is_code_point_boundary(slice: &Wtf8, index: usize) -> bool {
-    if index == slice.len() {
-        return true;
-    }
-    match slice.bytes.get(index) {
-        None => false,
-        Some(&b) => b < 128 || b >= 192,
-    }
-}
-
-/// Copied from core::str::raw::slice_unchecked
-#[inline]
-pub unsafe fn slice_unchecked(s: &Wtf8, begin: usize, end: usize) -> &Wtf8 {
-    // memory layout of an &[u8] and &Wtf8 are the same
-    Wtf8::from_bytes_unchecked(slice::from_raw_parts(s.bytes.as_ptr().offset(begin as isize),
-                                                     end - begin))
-}
-
-/// Copied from core::str::raw::slice_error_fail
-#[inline(never)]
-pub fn slice_error_fail(s: &Wtf8, begin: usize, end: usize) -> ! {
-    assert!(begin <= end);
-    panic!("index {} and/or {} in `{:?}` do not lie on character boundary",
-           begin,
-           end,
-           s);
-}
-
-/// Iterator for the code points of a WTF-8 string.
-///
-/// Created with the method `.code_points()`.
-#[derive(Clone)]
-pub struct Wtf8CodePoints<'a> {
-    bytes: slice::Iter<'a, u8>,
-}
-
-impl<'a> Iterator for Wtf8CodePoints<'a> {
-    type Item = CodePoint;
-
-    #[inline]
-    fn next(&mut self) -> Option<CodePoint> {
-        next_code_point(&mut self.bytes).map(|c| CodePoint { value: c })
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let len = self.bytes.len();
-        (len.saturating_add(3) / 4, Some(len))
-    }
-}
-
-#[derive(Clone)]
-pub struct EncodeWide<'a> {
-    code_points: Wtf8CodePoints<'a>,
-    extra: u16,
-}
-
-// Copied from libunicode/u_str.rs
-impl<'a> Iterator for EncodeWide<'a> {
-    type Item = u16;
-
-    #[inline]
-    fn next(&mut self) -> Option<u16> {
-        if self.extra != 0 {
-            let tmp = self.extra;
-            self.extra = 0;
-            return Some(tmp);
-        }
-
-        let mut buf = [0; 2];
-        self.code_points.next().map(|code_point| {
-            let c = unsafe {
-                char::from_u32_unchecked(code_point.value)
-            };
-            let n = c.encode_utf16(&mut buf).len();
-            if n == 2 {
-                self.extra = buf[1];
-            }
-            buf[0]
-        })
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let (low, high) = self.code_points.size_hint();
-        // every code point gets either one u16 or two u16,
-        // so this iterator is between 1 or 2 times as
-        // long as the underlying iterator.
-        (low, high.and_then(|n| n.checked_mul(2)))
-    }
-}
-
-impl Hash for CodePoint {
-    #[inline]
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.value.hash(state)
-    }
-}
-
-impl Hash for Wtf8Buf {
-    #[inline]
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        state.write(&self.bytes);
-        0xfeu8.hash(state)
-    }
-}
-
-impl Hash for Wtf8 {
-    #[inline]
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        state.write(&self.bytes);
-        0xfeu8.hash(state)
-    }
-}
-
-impl AsciiExt for Wtf8 {
-    type Owned = Wtf8Buf;
-
-    fn is_ascii(&self) -> bool {
-        self.bytes.is_ascii()
-    }
-    fn to_ascii_uppercase(&self) -> Wtf8Buf {
-        Wtf8Buf { bytes: self.bytes.to_ascii_uppercase() }
-    }
-    fn to_ascii_lowercase(&self) -> Wtf8Buf {
-        Wtf8Buf { bytes: self.bytes.to_ascii_lowercase() }
-    }
-    fn eq_ignore_ascii_case(&self, other: &Wtf8) -> bool {
-        self.bytes.eq_ignore_ascii_case(&other.bytes)
-    }
-
-    fn make_ascii_uppercase(&mut self) {
-        self.bytes.make_ascii_uppercase()
-    }
-    fn make_ascii_lowercase(&mut self) {
-        self.bytes.make_ascii_lowercase()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use collections::borrow::Cow;
-    use collections::{String, Vec};
-    use super::*;
-
-    #[test]
-    fn code_point_from_u32() {
-        assert!(CodePoint::from_u32(0).is_some());
-        assert!(CodePoint::from_u32(0xD800).is_some());
-        assert!(CodePoint::from_u32(0x10FFFF).is_some());
-        assert!(CodePoint::from_u32(0x110000).is_none());
-    }
-
-    #[test]
-    fn code_point_to_u32() {
-        fn c(value: u32) -> CodePoint {
-            CodePoint::from_u32(value).unwrap()
-        }
-        assert_eq!(c(0).to_u32(), 0);
-        assert_eq!(c(0xD800).to_u32(), 0xD800);
-        assert_eq!(c(0x10FFFF).to_u32(), 0x10FFFF);
-    }
-
-    #[test]
-    fn code_point_from_char() {
-        assert_eq!(CodePoint::from_char('a').to_u32(), 0x61);
-        assert_eq!(CodePoint::from_char('💩').to_u32(), 0x1F4A9);
-    }
-
-    #[test]
-    fn code_point_to_string() {
-        assert_eq!(format!("{:?}", CodePoint::from_char('a')), "U+0061");
-        assert_eq!(format!("{:?}", CodePoint::from_char('💩')), "U+1F4A9");
-    }
-
-    #[test]
-    fn code_point_to_char() {
-        fn c(value: u32) -> CodePoint {
-            CodePoint::from_u32(value).unwrap()
-        }
-        assert_eq!(c(0x61).to_char(), Some('a'));
-        assert_eq!(c(0x1F4A9).to_char(), Some('💩'));
-        assert_eq!(c(0xD800).to_char(), None);
-    }
-
-    #[test]
-    fn code_point_to_char_lossy() {
-        fn c(value: u32) -> CodePoint {
-            CodePoint::from_u32(value).unwrap()
-        }
-        assert_eq!(c(0x61).to_char_lossy(), 'a');
-        assert_eq!(c(0x1F4A9).to_char_lossy(), '💩');
-        assert_eq!(c(0xD800).to_char_lossy(), '\u{FFFD}');
-    }
-
-    #[test]
-    fn wtf8buf_new() {
-        assert_eq!(Wtf8Buf::new().bytes, b"");
-    }
-
-    #[test]
-    fn wtf8buf_from_str() {
-        assert_eq!(Wtf8Buf::from_str("").bytes, b"");
-        assert_eq!(Wtf8Buf::from_str("aé 💩").bytes,
-                   b"a\xC3\xA9 \xF0\x9F\x92\xA9");
-    }
-
-    #[test]
-    fn wtf8buf_from_string() {
-        assert_eq!(Wtf8Buf::from_string(String::from("")).bytes, b"");
-        assert_eq!(Wtf8Buf::from_string(String::from("aé 💩")).bytes,
-                   b"a\xC3\xA9 \xF0\x9F\x92\xA9");
-    }
-
-    #[test]
-    fn wtf8buf_from_wide() {
-        assert_eq!(Wtf8Buf::from_wide(&[]).bytes, b"");
-        assert_eq!(Wtf8Buf::from_wide(&[0x61, 0xE9, 0x20, 0xD83D, 0xD83D, 0xDCA9]).bytes,
-                   b"a\xC3\xA9 \xED\xA0\xBD\xF0\x9F\x92\xA9");
-    }
-
-    #[test]
-    fn wtf8buf_push_str() {
-        let mut string = Wtf8Buf::new();
-        assert_eq!(string.bytes, b"");
-        string.push_str("aé 💩");
-        assert_eq!(string.bytes, b"a\xC3\xA9 \xF0\x9F\x92\xA9");
-    }
-
-    #[test]
-    fn wtf8buf_push_char() {
-        let mut string = Wtf8Buf::from_str("aé ");
-        assert_eq!(string.bytes, b"a\xC3\xA9 ");
-        string.push_char('💩');
-        assert_eq!(string.bytes, b"a\xC3\xA9 \xF0\x9F\x92\xA9");
-    }
-
-    #[test]
-    fn wtf8buf_push() {
-        let mut string = Wtf8Buf::from_str("aé ");
-        assert_eq!(string.bytes, b"a\xC3\xA9 ");
-        string.push(CodePoint::from_char('💩'));
-        assert_eq!(string.bytes, b"a\xC3\xA9 \xF0\x9F\x92\xA9");
-
-        fn c(value: u32) -> CodePoint {
-            CodePoint::from_u32(value).unwrap()
-        }
-
-        let mut string = Wtf8Buf::new();
-        string.push(c(0xD83D));  // lead
-        string.push(c(0xDCA9));  // trail
-        assert_eq!(string.bytes, b"\xF0\x9F\x92\xA9");  // Magic!
-
-        let mut string = Wtf8Buf::new();
-        string.push(c(0xD83D));  // lead
-        string.push(c(0x20));  // not surrogate
-        string.push(c(0xDCA9));  // trail
-        assert_eq!(string.bytes, b"\xED\xA0\xBD \xED\xB2\xA9");
-
-        let mut string = Wtf8Buf::new();
-        string.push(c(0xD800));  // lead
-        string.push(c(0xDBFF));  // lead
-        assert_eq!(string.bytes, b"\xED\xA0\x80\xED\xAF\xBF");
-
-        let mut string = Wtf8Buf::new();
-        string.push(c(0xD800));  // lead
-        string.push(c(0xE000));  // not surrogate
-        assert_eq!(string.bytes, b"\xED\xA0\x80\xEE\x80\x80");
-
-        let mut string = Wtf8Buf::new();
-        string.push(c(0xD7FF));  // not surrogate
-        string.push(c(0xDC00));  // trail
-        assert_eq!(string.bytes, b"\xED\x9F\xBF\xED\xB0\x80");
-
-        let mut string = Wtf8Buf::new();
-        string.push(c(0x61));  // not surrogate, < 3 bytes
-        string.push(c(0xDC00));  // trail
-        assert_eq!(string.bytes, b"\x61\xED\xB0\x80");
-
-        let mut string = Wtf8Buf::new();
-        string.push(c(0xDC00));  // trail
-        assert_eq!(string.bytes, b"\xED\xB0\x80");
-    }
-
-    #[test]
-    fn wtf8buf_push_wtf8() {
-        let mut string = Wtf8Buf::from_str("aé");
-        assert_eq!(string.bytes, b"a\xC3\xA9");
-        string.push_wtf8(Wtf8::from_str(" 💩"));
-        assert_eq!(string.bytes, b"a\xC3\xA9 \xF0\x9F\x92\xA9");
-
-        fn w(v: &[u8]) -> &Wtf8 {
-            unsafe { Wtf8::from_bytes_unchecked(v) }
-        }
-
-        let mut string = Wtf8Buf::new();
-        string.push_wtf8(w(b"\xED\xA0\xBD"));  // lead
-        string.push_wtf8(w(b"\xED\xB2\xA9"));  // trail
-        assert_eq!(string.bytes, b"\xF0\x9F\x92\xA9");  // Magic!
-
-        let mut string = Wtf8Buf::new();
-        string.push_wtf8(w(b"\xED\xA0\xBD"));  // lead
-        string.push_wtf8(w(b" "));  // not surrogate
-        string.push_wtf8(w(b"\xED\xB2\xA9"));  // trail
-        assert_eq!(string.bytes, b"\xED\xA0\xBD \xED\xB2\xA9");
-
-        let mut string = Wtf8Buf::new();
-        string.push_wtf8(w(b"\xED\xA0\x80"));  // lead
-        string.push_wtf8(w(b"\xED\xAF\xBF"));  // lead
-        assert_eq!(string.bytes, b"\xED\xA0\x80\xED\xAF\xBF");
-
-        let mut string = Wtf8Buf::new();
-        string.push_wtf8(w(b"\xED\xA0\x80"));  // lead
-        string.push_wtf8(w(b"\xEE\x80\x80"));  // not surrogate
-        assert_eq!(string.bytes, b"\xED\xA0\x80\xEE\x80\x80");
-
-        let mut string = Wtf8Buf::new();
-        string.push_wtf8(w(b"\xED\x9F\xBF"));  // not surrogate
-        string.push_wtf8(w(b"\xED\xB0\x80"));  // trail
-        assert_eq!(string.bytes, b"\xED\x9F\xBF\xED\xB0\x80");
-
-        let mut string = Wtf8Buf::new();
-        string.push_wtf8(w(b"a"));  // not surrogate, < 3 bytes
-        string.push_wtf8(w(b"\xED\xB0\x80"));  // trail
-        assert_eq!(string.bytes, b"\x61\xED\xB0\x80");
-
-        let mut string = Wtf8Buf::new();
-        string.push_wtf8(w(b"\xED\xB0\x80"));  // trail
-        assert_eq!(string.bytes, b"\xED\xB0\x80");
-    }
-
-    #[test]
-    fn wtf8buf_truncate() {
-        let mut string = Wtf8Buf::from_str("aé");
-        string.truncate(1);
-        assert_eq!(string.bytes, b"a");
-    }
-
-    #[test]
-    #[should_panic]
-    fn wtf8buf_truncate_fail_code_point_boundary() {
-        let mut string = Wtf8Buf::from_str("aé");
-        string.truncate(2);
-    }
-
-    #[test]
-    #[should_panic]
-    fn wtf8buf_truncate_fail_longer() {
-        let mut string = Wtf8Buf::from_str("aé");
-        string.truncate(4);
-    }
-
-    #[test]
-    fn wtf8buf_into_string() {
-        let mut string = Wtf8Buf::from_str("aé 💩");
-        assert_eq!(string.clone().into_string(), Ok(String::from("aé 💩")));
-        string.push(CodePoint::from_u32(0xD800).unwrap());
-        assert_eq!(string.clone().into_string(), Err(string));
-    }
-
-    #[test]
-    fn wtf8buf_into_string_lossy() {
-        let mut string = Wtf8Buf::from_str("aé 💩");
-        assert_eq!(string.clone().into_string_lossy(), String::from("aé 💩"));
-        string.push(CodePoint::from_u32(0xD800).unwrap());
-        assert_eq!(string.clone().into_string_lossy(),
-                   String::from("aé 💩�"));
-    }
-
-    #[test]
-    fn wtf8buf_from_iterator() {
-        fn f(values: &[u32]) -> Wtf8Buf {
-            values.iter().map(|&c| CodePoint::from_u32(c).unwrap()).collect::<Wtf8Buf>()
-        }
-        assert_eq!(f(&[0x61, 0xE9, 0x20, 0x1F4A9]).bytes,
-                   b"a\xC3\xA9 \xF0\x9F\x92\xA9");
-
-        assert_eq!(f(&[0xD83D, 0xDCA9]).bytes, b"\xF0\x9F\x92\xA9");  // Magic!
-        assert_eq!(f(&[0xD83D, 0x20, 0xDCA9]).bytes,
-                   b"\xED\xA0\xBD \xED\xB2\xA9");
-        assert_eq!(f(&[0xD800, 0xDBFF]).bytes, b"\xED\xA0\x80\xED\xAF\xBF");
-        assert_eq!(f(&[0xD800, 0xE000]).bytes, b"\xED\xA0\x80\xEE\x80\x80");
-        assert_eq!(f(&[0xD7FF, 0xDC00]).bytes, b"\xED\x9F\xBF\xED\xB0\x80");
-        assert_eq!(f(&[0x61, 0xDC00]).bytes, b"\x61\xED\xB0\x80");
-        assert_eq!(f(&[0xDC00]).bytes, b"\xED\xB0\x80");
-    }
-
-    #[test]
-    fn wtf8buf_extend() {
-        fn e(initial: &[u32], extended: &[u32]) -> Wtf8Buf {
-            fn c(value: &u32) -> CodePoint {
-                CodePoint::from_u32(*value).unwrap()
-            }
-            let mut string = initial.iter().map(c).collect::<Wtf8Buf>();
-            string.extend(extended.iter().map(c));
-            string
-        }
-
-        assert_eq!(e(&[0x61, 0xE9], &[0x20, 0x1F4A9]).bytes,
-                   b"a\xC3\xA9 \xF0\x9F\x92\xA9");
-
-        assert_eq!(e(&[0xD83D], &[0xDCA9]).bytes, b"\xF0\x9F\x92\xA9");  // Magic!
-        assert_eq!(e(&[0xD83D, 0x20], &[0xDCA9]).bytes,
-                   b"\xED\xA0\xBD \xED\xB2\xA9");
-        assert_eq!(e(&[0xD800], &[0xDBFF]).bytes, b"\xED\xA0\x80\xED\xAF\xBF");
-        assert_eq!(e(&[0xD800], &[0xE000]).bytes, b"\xED\xA0\x80\xEE\x80\x80");
-        assert_eq!(e(&[0xD7FF], &[0xDC00]).bytes, b"\xED\x9F\xBF\xED\xB0\x80");
-        assert_eq!(e(&[0x61], &[0xDC00]).bytes, b"\x61\xED\xB0\x80");
-        assert_eq!(e(&[], &[0xDC00]).bytes, b"\xED\xB0\x80");
-    }
-
-    #[test]
-    fn wtf8buf_show() {
-        let mut string = Wtf8Buf::from_str("a\té \u{7f}💩\r");
-        string.push(CodePoint::from_u32(0xD800).unwrap());
-        assert_eq!(format!("{:?}", string),
-                   "\"a\\té \\u{7f}\u{1f4a9}\\r\\u{d800}\"");
-    }
-
-    #[test]
-    fn wtf8buf_as_slice() {
-        assert_eq!(Wtf8Buf::from_str("aé").as_slice(), Wtf8::from_str("aé"));
-    }
-
-    #[test]
-    fn wtf8buf_show_str() {
-        let text = "a\té 💩\r";
-        let string = Wtf8Buf::from_str(text);
-        assert_eq!(format!("{:?}", text), format!("{:?}", string));
-    }
-
-    #[test]
-    fn wtf8_from_str() {
-        assert_eq!(&Wtf8::from_str("").bytes, b"");
-        assert_eq!(&Wtf8::from_str("aé 💩").bytes,
-                   b"a\xC3\xA9 \xF0\x9F\x92\xA9");
-    }
-
-    #[test]
-    fn wtf8_len() {
-        assert_eq!(Wtf8::from_str("").len(), 0);
-        assert_eq!(Wtf8::from_str("aé 💩").len(), 8);
-    }
-
-    #[test]
-    fn wtf8_slice() {
-        assert_eq!(&Wtf8::from_str("aé 💩")[1..4].bytes, b"\xC3\xA9 ");
-    }
-
-    #[test]
-    #[should_panic]
-    fn wtf8_slice_not_code_point_boundary() {
-        &Wtf8::from_str("aé 💩")[2..4];
-    }
-
-    #[test]
-    fn wtf8_slice_from() {
-        assert_eq!(&Wtf8::from_str("aé 💩")[1..].bytes,
-                   b"\xC3\xA9 \xF0\x9F\x92\xA9");
-    }
-
-    #[test]
-    #[should_panic]
-    fn wtf8_slice_from_not_code_point_boundary() {
-        &Wtf8::from_str("aé 💩")[2..];
-    }
-
-    #[test]
-    fn wtf8_slice_to() {
-        assert_eq!(&Wtf8::from_str("aé 💩")[..4].bytes, b"a\xC3\xA9 ");
-    }
-
-    #[test]
-    #[should_panic]
-    fn wtf8_slice_to_not_code_point_boundary() {
-        &Wtf8::from_str("aé 💩")[5..];
-    }
-
-    #[test]
-    fn wtf8_ascii_byte_at() {
-        let slice = Wtf8::from_str("aé 💩");
-        assert_eq!(slice.ascii_byte_at(0), b'a');
-        assert_eq!(slice.ascii_byte_at(1), b'\xFF');
-        assert_eq!(slice.ascii_byte_at(2), b'\xFF');
-        assert_eq!(slice.ascii_byte_at(3), b' ');
-        assert_eq!(slice.ascii_byte_at(4), b'\xFF');
-    }
-
-    #[test]
-    fn wtf8_code_points() {
-        fn c(value: u32) -> CodePoint {
-            CodePoint::from_u32(value).unwrap()
-        }
-        fn cp(string: &Wtf8Buf) -> Vec<Option<char>> {
-            string.code_points().map(|c| c.to_char()).collect::<Vec<_>>()
-        }
-        let mut string = Wtf8Buf::from_str("é ");
-        assert_eq!(cp(&string), [Some('é'), Some(' ')]);
-        string.push(c(0xD83D));
-        assert_eq!(cp(&string), [Some('é'), Some(' '), None]);
-        string.push(c(0xDCA9));
-        assert_eq!(cp(&string), [Some('é'), Some(' '), Some('💩')]);
-    }
-
-    #[test]
-    fn wtf8_as_str() {
-        assert_eq!(Wtf8::from_str("").as_str(), Some(""));
-        assert_eq!(Wtf8::from_str("aé 💩").as_str(), Some("aé 💩"));
-        let mut string = Wtf8Buf::new();
-        string.push(CodePoint::from_u32(0xD800).unwrap());
-        assert_eq!(string.as_str(), None);
-    }
-
-    #[test]
-    fn wtf8_to_string_lossy() {
-        assert_eq!(Wtf8::from_str("").to_string_lossy(), Cow::Borrowed(""));
-        assert_eq!(Wtf8::from_str("aé 💩").to_string_lossy(),
-                   Cow::Borrowed("aé 💩"));
-        let mut string = Wtf8Buf::from_str("aé 💩");
-        string.push(CodePoint::from_u32(0xD800).unwrap());
-        let expected: Cow<str> = Cow::Owned(String::from("aé 💩�"));
-        assert_eq!(string.to_string_lossy(), expected);
-    }
-
-    #[test]
-    fn wtf8_encode_wide() {
-        let mut string = Wtf8Buf::from_str("aé ");
-        string.push(CodePoint::from_u32(0xD83D).unwrap());
-        string.push_char('💩');
-        assert_eq!(string.encode_wide().collect::<Vec<_>>(),
-                   vec![0x61, 0xE9, 0x20, 0xD83D, 0xD83D, 0xDCA9]);
-    }
-}