std: Migrate to the new libc

* Delete `sys::unix::{c, sync}` as these are now all folded into libc itself
* Update all references to use `libc` as a result.
* Update all references to the new flat namespace.
* Moves all windows bindings into sys::c

1 files changed, 31 insertions, 37 deletions

diff --git a/src/libstd/sys/windows/process.rs b/src/libstd/sys/windows/process.rs
index e8cc160fde7..e0f8d6f9df9 100644
--- a/src/libstd/sys/windows/process.rs
+++ b/src/libstd/sys/windows/process.rs
@@ -19,13 +19,14 @@ use ffi::{OsString, OsStr};
 use fmt;
 use fs;
 use io::{self, Error};
-use libc::{self, c_void};
+use libc::c_void;
 use mem;
 use os::windows::ffi::OsStrExt;
 use path::Path;
 use ptr;
 use sync::StaticMutex;
 use sys::c;
+
 use sys::fs::{OpenOptions, File};
 use sys::handle::{Handle, RawHandle};
 use sys::stdio;
@@ -107,7 +108,7 @@ pub struct Process {
 pub enum Stdio {
     Inherit,
     None,
-    Raw(libc::HANDLE),
+    Raw(c::HANDLE),
 }
 
 pub type RawStdio = Handle;
@@ -118,9 +119,6 @@ impl Process {
                  out_handle: Stdio,
                  err_handle: Stdio) -> io::Result<Process>
     {
-        use libc::{TRUE, STARTF_USESTDHANDLES};
-        use libc::{DWORD, STARTUPINFO, CreateProcessW};
-
         // To have the spawning semantics of unix/windows stay the same, we need
         // to read the *child's* PATH if one is provided. See #15149 for more
         // details.
@@ -143,8 +141,8 @@ impl Process {
         });
 
         let mut si = zeroed_startupinfo();
-        si.cb = mem::size_of::<STARTUPINFO>() as DWORD;
-        si.dwFlags = STARTF_USESTDHANDLES;
+        si.cb = mem::size_of::<c::STARTUPINFO>() as c::DWORD;
+        si.dwFlags = c::STARTF_USESTDHANDLES;
 
         let stdin = try!(in_handle.to_handle(c::STD_INPUT_HANDLE));
         let stdout = try!(out_handle.to_handle(c::STD_OUTPUT_HANDLE));
@@ -159,9 +157,9 @@ impl Process {
         cmd_str.push(0); // add null terminator
 
         // stolen from the libuv code.
-        let mut flags = libc::CREATE_UNICODE_ENVIRONMENT;
+        let mut flags = c::CREATE_UNICODE_ENVIRONMENT;
         if cfg.detach {
-            flags |= libc::DETACHED_PROCESS | libc::CREATE_NEW_PROCESS_GROUP;
+            flags |= c::DETACHED_PROCESS | c::CREATE_NEW_PROCESS_GROUP;
         }
 
         let (envp, _data) = make_envp(cfg.env.as_ref());
@@ -173,12 +171,12 @@ impl Process {
             static CREATE_PROCESS_LOCK: StaticMutex = StaticMutex::new();
             let _lock = CREATE_PROCESS_LOCK.lock();
 
-            cvt(CreateProcessW(ptr::null(),
-                               cmd_str.as_mut_ptr(),
-                               ptr::null_mut(),
-                               ptr::null_mut(),
-                               TRUE, flags, envp, dirp,
-                               &mut si, &mut pi))
+            cvt(c::CreateProcessW(ptr::null(),
+                                  cmd_str.as_mut_ptr(),
+                                  ptr::null_mut(),
+                                  ptr::null_mut(),
+                                  c::TRUE, flags, envp, dirp,
+                                  &mut si, &mut pi))
         });
 
         // We close the thread handle because we don't care about keeping
@@ -190,7 +188,7 @@ impl Process {
     }
 
     pub unsafe fn kill(&self) -> io::Result<()> {
-        try!(cvt(libc::TerminateProcess(self.handle.raw(), 1)));
+        try!(cvt(c::TerminateProcess(self.handle.raw(), 1)));
         Ok(())
     }
 
@@ -201,15 +199,13 @@ impl Process {
     }
 
     pub fn wait(&self) -> io::Result<ExitStatus> {
-        use libc::{INFINITE, WAIT_OBJECT_0};
-        use libc::{GetExitCodeProcess, WaitForSingleObject};
-
         unsafe {
-            if WaitForSingleObject(self.handle.raw(), INFINITE) != WAIT_OBJECT_0 {
+            let res = c::WaitForSingleObject(self.handle.raw(), c::INFINITE);
+            if res != c::WAIT_OBJECT_0 {
                 return Err(Error::last_os_error())
             }
             let mut status = 0;
-            try!(cvt(GetExitCodeProcess(self.handle.raw(), &mut status)));
+            try!(cvt(c::GetExitCodeProcess(self.handle.raw(), &mut status)));
             Ok(ExitStatus(status))
         }
     }
@@ -220,7 +216,7 @@ impl Process {
 }
 
 #[derive(PartialEq, Eq, Clone, Copy, Debug)]
-pub struct ExitStatus(libc::DWORD);
+pub struct ExitStatus(c::DWORD);
 
 impl ExitStatus {
     pub fn success(&self) -> bool {
@@ -237,8 +233,8 @@ impl fmt::Display for ExitStatus {
     }
 }
 
-fn zeroed_startupinfo() -> libc::types::os::arch::extra::STARTUPINFO {
-    libc::types::os::arch::extra::STARTUPINFO {
+fn zeroed_startupinfo() -> c::STARTUPINFO {
+    c::STARTUPINFO {
         cb: 0,
         lpReserved: ptr::null_mut(),
         lpDesktop: ptr::null_mut(),
@@ -254,14 +250,14 @@ fn zeroed_startupinfo() -> libc::types::os::arch::extra::STARTUPINFO {
         wShowWindow: 0,
         cbReserved2: 0,
         lpReserved2: ptr::null_mut(),
-        hStdInput: libc::INVALID_HANDLE_VALUE,
-        hStdOutput: libc::INVALID_HANDLE_VALUE,
-        hStdError: libc::INVALID_HANDLE_VALUE,
+        hStdInput: c::INVALID_HANDLE_VALUE,
+        hStdOutput: c::INVALID_HANDLE_VALUE,
+        hStdError: c::INVALID_HANDLE_VALUE,
     }
 }
 
-fn zeroed_process_information() -> libc::types::os::arch::extra::PROCESS_INFORMATION {
-    libc::types::os::arch::extra::PROCESS_INFORMATION {
+fn zeroed_process_information() -> c::PROCESS_INFORMATION {
+    c::PROCESS_INFORMATION {
         hProcess: ptr::null_mut(),
         hThread: ptr::null_mut(),
         dwProcessId: 0,
@@ -353,17 +349,15 @@ fn make_dirp(d: Option<&OsString>) -> (*const u16, Vec<u16>) {
 }
 
 impl Stdio {
-    fn to_handle(&self, stdio_id: libc::DWORD) -> io::Result<Handle> {
-        use libc::DUPLICATE_SAME_ACCESS;
-
+    fn to_handle(&self, stdio_id: c::DWORD) -> io::Result<Handle> {
         match *self {
             Stdio::Inherit => {
                 stdio::get(stdio_id).and_then(|io| {
-                    io.handle().duplicate(0, true, DUPLICATE_SAME_ACCESS)
+                    io.handle().duplicate(0, true, c::DUPLICATE_SAME_ACCESS)
                 })
             }
             Stdio::Raw(handle) => {
-                RawHandle::new(handle).duplicate(0, true, DUPLICATE_SAME_ACCESS)
+                RawHandle::new(handle).duplicate(0, true, c::DUPLICATE_SAME_ACCESS)
             }
 
             // Similarly to unix, we don't actually leave holes for the
@@ -371,9 +365,9 @@ impl Stdio {
             // equivalents. These equivalents are drawn from libuv's
             // windows process spawning.
             Stdio::None => {
-                let size = mem::size_of::<libc::SECURITY_ATTRIBUTES>();
-                let mut sa = libc::SECURITY_ATTRIBUTES {
-                    nLength: size as libc::DWORD,
+                let size = mem::size_of::<c::SECURITY_ATTRIBUTES>();
+                let mut sa = c::SECURITY_ATTRIBUTES {
+                    nLength: size as c::DWORD,
                     lpSecurityDescriptor: ptr::null_mut(),
                     bInheritHandle: 1,
                 };