Second attempt to cut down on #[cfg] duplication

This time by exiling everything to an inline module. Kudos to Xion_ in
IRC for the idea.

Author: ctrlcctrlv

src/unistd.rs

@@ -20,6 +20,16 @@ pub use self::pivot_root::*;
 #[cfg(any(target_os = "android", target_os = "freebsd",
           target_os = "linux", target_os = "openbsd"))]
 pub use self::setres::*;
+#[cfg(not(any(target_os = "android", 
+              target_os = "ios", 
+              target_os = "macos", 
+              target_env = "musl",
+              target_arch = "mips",
+              target_arch = "mips64",
+              target_arch = "mips64el",
+              target_arch = "mipsel",
+              target_arch = "s390x")))] 
+pub use self::usergroupiter::*;
 
 /// User identifier
 ///
@@ -2555,145 +2565,144 @@ impl Queryable<GroupQuery> for Group {
     }
 }
 
-#[cfg_attr(any(target_os = "android", 
+#[cfg(not(any(target_os = "android", 
               target_os = "ios", 
               target_os = "macos", 
               target_env = "musl",
               target_arch = "mips",
               target_arch = "mips64",
               target_arch = "mips64el",
               target_arch = "mipsel",
-              target_arch = "s390x",
-              ), no_getpwent_r)] 
-
-#[cfg(not(no_getpwent_r))]
-/// This iterator can be used to get all of the users on the system. For example:
-///
-/// ```
-/// use nix::unistd::Users;
-/// eprintln!("Users on this system:\nname\tuid");
-/// Users::new()
-///     .map(|e|e.map(
-///         |pw| println!("{}\t{}",
-///                       pw.name,
-///                       pw.uid)))
-///     .collect::<Vec<_>>();
-/// 
-/// ```
-///
-/// This iterator should not be used in different threads without synchronization; while doing so
-/// will not cause undefined behavior, because modern systems lack re-entrant versions of
-/// `setpwent` and `endpwent`, it is very likely that iterators running in different threads will
-/// yield different numbers of items.
-#[derive(Debug)]
-pub struct Users(pub usize);
+              target_arch = "s390x")))] 
+mod usergroupiter {
+    use libc;
+    use libc::{c_char};
+    use Result;
+    use errno::Errno;
+    use super::{Error, User, Group, PWGRP_BUFSIZE};
+    use std::{mem, ptr};
 
-#[cfg(not(no_getpwent_r))]
-impl Users {
-    pub fn new() -> Self {
-        unsafe { libc::setpwent(); } 
-        Users(PWGRP_BUFSIZE)
-    }
+    /// This iterator can be used to get all of the users on the system. For example:
+    ///
+    /// ```
+    /// use nix::unistd::Users;
+    /// eprintln!("Users on this system:\nname\tuid");
+    /// Users::new()
+    ///     .map(|e|e.map(
+    ///         |pw| println!("{}\t{}",
+    ///                       pw.name,
+    ///                       pw.uid)))
+    ///     .collect::<Vec<_>>();
+    /// 
+    /// ```
+    ///
+    /// This iterator should not be used in different threads without synchronization; while doing so
+    /// will not cause undefined behavior, because modern systems lack re-entrant versions of
+    /// `setpwent` and `endpwent`, it is very likely that iterators running in different threads will
+    /// yield different numbers of items.
+    #[derive(Debug)]
+    pub struct Users(pub usize);
+
+    impl Users {
+        pub fn new() -> Self {
+            unsafe { libc::setpwent(); } 
+            Users(PWGRP_BUFSIZE)
+        }
 
-    pub fn with_bufsize(bufsize: usize) -> Self {
-        unsafe { libc::setpwent(); }
-        Users(bufsize)
+        pub fn with_bufsize(bufsize: usize) -> Self {
+            unsafe { libc::setpwent(); }
+            Users(bufsize)
+        }
     }
-}
 
-#[cfg(not(no_getpwent_r))]
-impl Iterator for Users {
-    type Item = Result<User>;
-    fn next(&mut self) -> Option<Result<User>> {
-        
-        let mut cbuf = vec![0 as c_char; self.0];
-        let mut pwd: libc::passwd =  unsafe { mem::zeroed() };
-        let mut res = ptr::null_mut();
-        
-        let i = unsafe { 
-            Errno::clear();
-            libc::getpwent_r(&mut pwd, cbuf.as_mut_ptr(), self.0, &mut res) 
-        };
-
-        match i {
-            0 if !res.is_null() => {
-                unsafe { Some(Ok(User::from(*res))) }
-            },
-            libc::ERANGE => { Some(Err(Error::Sys(Errno::last()))) },
-            _ => None
+    impl Iterator for Users {
+        type Item = Result<User>;
+        fn next(&mut self) -> Option<Result<User>> {
+            
+            let mut cbuf = vec![0 as c_char; self.0];
+            let mut pwd: libc::passwd =  unsafe { mem::zeroed() };
+            let mut res = ptr::null_mut();
+            
+            let i = unsafe { 
+                Errno::clear();
+                libc::getpwent_r(&mut pwd, cbuf.as_mut_ptr(), self.0, &mut res) 
+            };
+
+            match i {
+                0 if !res.is_null() => {
+                    unsafe { Some(Ok(User::from(*res))) }
+                },
+                libc::ERANGE => { Some(Err(Error::Sys(Errno::last()))) },
+                _ => None
+            }
         }
     }
-}
 
-#[cfg(not(no_getpwent_r))]
-impl Drop for Users {
-    fn drop(&mut self) {
-        unsafe { libc::endpwent() };
+    impl Drop for Users {
+        fn drop(&mut self) {
+            unsafe { libc::endpwent() };
+        }
     }
-}
 
-#[cfg(not(no_getpwent_r))]
-/// This iterator can be used to get all of the groups on the system. For example:
-///
-/// ```
-/// use nix::unistd::Groups;
-/// eprintln!("Groups on this system:\nname\tgid");
-/// Groups::new()
-///      .map(|e|e.map(
-///          |gr| println!("{}\t{}",
-///                        gr.name,
-///                        gr.gid)))
-///      .collect::<Vec<_>>();
-/// 
-/// ```
-///
-/// This iterator should not be used in different threads without synchronization; while doing so
-/// will not cause undefined behavior, because modern systems lack re-entrant versions of
-/// `setgrent` and `endgrent`, it is very likely that iterators running in different threads will
-/// yield different numbers of items.
-#[derive(Debug)]
-pub struct Groups(pub usize);
-
-#[cfg(not(no_getpwent_r))]
-impl Groups {
-    pub fn new() -> Self {
-        unsafe { libc::setgrent(); } 
-        Groups(PWGRP_BUFSIZE)
-    }
+    /// This iterator can be used to get all of the groups on the system. For example:
+    ///
+    /// ```
+    /// use nix::unistd::Groups;
+    /// eprintln!("Groups on this system:\nname\tgid");
+    /// Groups::new()
+    ///      .map(|e|e.map(
+    ///          |gr| println!("{}\t{}",
+    ///                        gr.name,
+    ///                        gr.gid)))
+    ///      .collect::<Vec<_>>();
+    /// 
+    /// ```
+    ///
+    /// This iterator should not be used in different threads without synchronization; while doing so
+    /// will not cause undefined behavior, because modern systems lack re-entrant versions of
+    /// `setgrent` and `endgrent`, it is very likely that iterators running in different threads will
+    /// yield different numbers of items.
+    #[derive(Debug)]
+    pub struct Groups(pub usize);
+
+    impl Groups {
+        pub fn new() -> Self {
+            unsafe { libc::setgrent(); } 
+            Groups(PWGRP_BUFSIZE)
+        }
 
-    pub fn with_bufsize(bufsize: usize) -> Self {
-        unsafe { libc::setgrent(); }
-        Groups(bufsize)
+        pub fn with_bufsize(bufsize: usize) -> Self {
+            unsafe { libc::setgrent(); }
+            Groups(bufsize)
+        }
     }
-}
-
-#[cfg(not(no_getpwent_r))]
-impl Iterator for Groups {
-    type Item = Result<Group>;
-    fn next(&mut self) -> Option<Result<Group>> {
-        
-        let mut cbuf = vec![0 as c_char; self.0];
-        let mut grp: libc::group =  unsafe { mem::zeroed() };
-        let mut res = ptr::null_mut();
-        
-        let i = unsafe { 
-            Errno::clear();
-            libc::getgrent_r(&mut grp, cbuf.as_mut_ptr(), self.0, &mut res) 
-        };
 
-        match i {
-            0 if !res.is_null() => {
-                unsafe { Some(Ok(Group::from(*res))) }
-            },
-            libc::ERANGE => { Some(Err(Error::Sys(Errno::last()))) },
-            _ => None
+    impl Iterator for Groups {
+        type Item = Result<Group>;
+        fn next(&mut self) -> Option<Result<Group>> {
+            
+            let mut cbuf = vec![0 as c_char; self.0];
+            let mut grp: libc::group =  unsafe { mem::zeroed() };
+            let mut res = ptr::null_mut();
+            
+            let i = unsafe { 
+                Errno::clear();
+                libc::getgrent_r(&mut grp, cbuf.as_mut_ptr(), self.0, &mut res) 
+            };
+
+            match i {
+                0 if !res.is_null() => {
+                    unsafe { Some(Ok(Group::from(*res))) }
+                },
+                libc::ERANGE => { Some(Err(Error::Sys(Errno::last()))) },
+                _ => None
+            }
         }
     }
-}
 
-#[cfg(not(no_getpwent_r))]
-impl Drop for Groups {
-    fn drop(&mut self) {
-        unsafe { libc::endgrent() };
+    impl Drop for Groups {
+        fn drop(&mut self) {
+            unsafe { libc::endgrent() };
+        }
     }
 }