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, 21 insertions, 21 deletions

diff --git a/src/libstd/sys/unix/mutex.rs b/src/libstd/sys/unix/mutex.rs
index e4c231ff971..4e4abcfbeee 100644
--- a/src/libstd/sys/unix/mutex.rs
+++ b/src/libstd/sys/unix/mutex.rs
@@ -9,13 +9,13 @@
 // except according to those terms.
 
 use cell::UnsafeCell;
-use sys::sync as ffi;
+use libc;
 use mem;
 
-pub struct Mutex { inner: UnsafeCell<ffi::pthread_mutex_t> }
+pub struct Mutex { inner: UnsafeCell<libc::pthread_mutex_t> }
 
 #[inline]
-pub unsafe fn raw(m: &Mutex) -> *mut ffi::pthread_mutex_t {
+pub unsafe fn raw(m: &Mutex) -> *mut libc::pthread_mutex_t {
     m.inner.get()
 }
 
@@ -27,42 +27,42 @@ impl Mutex {
     pub const fn new() -> Mutex {
         // Might be moved and address is changing it is better to avoid
         // initialization of potentially opaque OS data before it landed
-        Mutex { inner: UnsafeCell::new(ffi::PTHREAD_MUTEX_INITIALIZER) }
+        Mutex { inner: UnsafeCell::new(libc::PTHREAD_MUTEX_INITIALIZER) }
     }
     #[inline]
     pub unsafe fn lock(&self) {
-        let r = ffi::pthread_mutex_lock(self.inner.get());
+        let r = libc::pthread_mutex_lock(self.inner.get());
         debug_assert_eq!(r, 0);
     }
     #[inline]
     pub unsafe fn unlock(&self) {
-        let r = ffi::pthread_mutex_unlock(self.inner.get());
+        let r = libc::pthread_mutex_unlock(self.inner.get());
         debug_assert_eq!(r, 0);
     }
     #[inline]
     pub unsafe fn try_lock(&self) -> bool {
-        ffi::pthread_mutex_trylock(self.inner.get()) == 0
+        libc::pthread_mutex_trylock(self.inner.get()) == 0
     }
     #[inline]
     #[cfg(not(target_os = "dragonfly"))]
     pub unsafe fn destroy(&self) {
-        let r = ffi::pthread_mutex_destroy(self.inner.get());
+        let r = libc::pthread_mutex_destroy(self.inner.get());
         debug_assert_eq!(r, 0);
     }
     #[inline]
     #[cfg(target_os = "dragonfly")]
     pub unsafe fn destroy(&self) {
         use libc;
-        let r = ffi::pthread_mutex_destroy(self.inner.get());
+        let r = libc::pthread_mutex_destroy(self.inner.get());
         // On DragonFly pthread_mutex_destroy() returns EINVAL if called on a
-        // mutex that was just initialized with ffi::PTHREAD_MUTEX_INITIALIZER.
+        // mutex that was just initialized with libc::PTHREAD_MUTEX_INITIALIZER.
         // Once it is used (locked/unlocked) or pthread_mutex_init() is called,
         // this behaviour no longer occurs.
         debug_assert!(r == 0 || r == libc::EINVAL);
     }
 }
 
-pub struct ReentrantMutex { inner: UnsafeCell<ffi::pthread_mutex_t> }
+pub struct ReentrantMutex { inner: UnsafeCell<libc::pthread_mutex_t> }
 
 unsafe impl Send for ReentrantMutex {}
 unsafe impl Sync for ReentrantMutex {}
@@ -73,35 +73,35 @@ impl ReentrantMutex {
     }
 
     pub unsafe fn init(&mut self) {
-        let mut attr: ffi::pthread_mutexattr_t = mem::uninitialized();
-        let result = ffi::pthread_mutexattr_init(&mut attr as *mut _);
+        let mut attr: libc::pthread_mutexattr_t = mem::uninitialized();
+        let result = libc::pthread_mutexattr_init(&mut attr as *mut _);
         debug_assert_eq!(result, 0);
-        let result = ffi::pthread_mutexattr_settype(&mut attr as *mut _,
-                                                    ffi::PTHREAD_MUTEX_RECURSIVE);
+        let result = libc::pthread_mutexattr_settype(&mut attr as *mut _,
+                                                    libc::PTHREAD_MUTEX_RECURSIVE);
         debug_assert_eq!(result, 0);
-        let result = ffi::pthread_mutex_init(self.inner.get(), &attr as *const _);
+        let result = libc::pthread_mutex_init(self.inner.get(), &attr as *const _);
         debug_assert_eq!(result, 0);
-        let result = ffi::pthread_mutexattr_destroy(&mut attr as *mut _);
+        let result = libc::pthread_mutexattr_destroy(&mut attr as *mut _);
         debug_assert_eq!(result, 0);
     }
 
     pub unsafe fn lock(&self) {
-        let result = ffi::pthread_mutex_lock(self.inner.get());
+        let result = libc::pthread_mutex_lock(self.inner.get());
         debug_assert_eq!(result, 0);
     }
 
     #[inline]
     pub unsafe fn try_lock(&self) -> bool {
-        ffi::pthread_mutex_trylock(self.inner.get()) == 0
+        libc::pthread_mutex_trylock(self.inner.get()) == 0
     }
 
     pub unsafe fn unlock(&self) {
-        let result = ffi::pthread_mutex_unlock(self.inner.get());
+        let result = libc::pthread_mutex_unlock(self.inner.get());
         debug_assert_eq!(result, 0);
     }
 
     pub unsafe fn destroy(&self) {
-        let result = ffi::pthread_mutex_destroy(self.inner.get());
+        let result = libc::pthread_mutex_destroy(self.inner.get());
         debug_assert_eq!(result, 0);
     }
 }