changed uint and int to usize and isize respectively

Author: rrichardson

src/errno.rs

@@ -25,8 +25,8 @@ impl SysError {
         SysError { kind: kind }
     }
 
-    pub fn errno(&self) -> uint {
-        self.kind as uint
+    pub fn errno(&self) -> usize {
+        self.kind as usize
     }
 
     pub fn desc(&self) -> &'static str {

src/features.rs

@@ -9,22 +9,22 @@ mod os {
     // * pipe2: 2.6.27
     // * accept4: 2.6.28
 
-    static VERS_UNKNOWN: uint = 1;
-    static VERS_2_6_18:  uint = 2;
-    static VERS_2_6_27:  uint = 3;
-    static VERS_2_6_28:  uint = 4;
-    static VERS_3:       uint = 5;
+    static VERS_UNKNOWN: usize = 1;
+    static VERS_2_6_18:  usize = 2;
+    static VERS_2_6_27:  usize = 3;
+    static VERS_2_6_28:  usize = 4;
+    static VERS_3:       usize = 5;
 
-    fn parse_kernel_version() -> uint {
+    fn parse_kernel_version() -> usize {
         let u = uname();
 
         #[inline]
-        fn digit(dst: &mut uint, b: u8) {
+        fn digit(dst: &mut usize, b: u8) {
             *dst *= 10;
-            *dst += (b - b'0') as uint;
+            *dst += (b - b'0') as usize;
         }
 
-        let mut curr = 0u;
+        let mut curr = 0us;
         let mut major = 0;
         let mut minor = 0;
         let mut patch = 0;
@@ -70,8 +70,8 @@ mod os {
         }
     }
 
-    fn kernel_version() -> uint {
-        static mut KERNEL_VERS: uint = 0;
+    fn kernel_version() -> usize {
+        static mut KERNEL_VERS: usize = 0;
 
         unsafe {
             if KERNEL_VERS == 0 {

src/lib.rs

@@ -1,7 +1,6 @@
 #![crate_name = "nix"]
 
 #![feature(linkage)]
-#![feature(int_uint)]
 #![allow(unstable)]
 #![allow(non_camel_case_types)]
 

src/sched.rs

@@ -31,38 +31,38 @@ pub static CLONE_IO:             CloneFlags = 0x80000000;
 #[cfg(target_arch = "x86_64")]
 mod cpuset_attribs {
     use super::CpuMask;
-    pub const CPU_SETSIZE:           uint = 1024u;
-    pub const CPU_MASK_BITS:         uint = 64u;
+    pub const CPU_SETSIZE:           usize = 1024us;
+    pub const CPU_MASK_BITS:         usize = 64us;
 
     #[inline]
-    pub fn set_cpu_mask_flag(cur: CpuMask, bit: uint) -> CpuMask {
+    pub fn set_cpu_mask_flag(cur: CpuMask, bit: usize) -> CpuMask {
         cur | (1u64 << bit)
     }
 
     #[inline]
-    pub fn clear_cpu_mask_flag(cur: CpuMask, bit: uint) -> CpuMask {
+    pub fn clear_cpu_mask_flag(cur: CpuMask, bit: usize) -> CpuMask {
         cur & !(1u64 << bit)
     }
 }
 
 #[cfg(target_arch = "x86")]
 mod cpuset_attribs {
     use super::CpuMask;
-    pub const CPU_SETSIZE:           uint = 1024u;
-    pub const CPU_MASK_BITS:         uint = 32u;
+    pub const CPU_SETSIZE:           usize = 1024us;
+    pub const CPU_MASK_BITS:         usize = 32us;
 
     #[inline]
-    pub fn set_cpu_mask_flag(cur: CpuMask, bit: uint) -> CpuMask {
+    pub fn set_cpu_mask_flag(cur: CpuMask, bit: usize) -> CpuMask {
         cur | (1u32 << bit)
     }
 
     #[inline]
-    pub fn clear_cpu_mask_flag(cur: CpuMask, bit: uint) -> CpuMask {
+    pub fn clear_cpu_mask_flag(cur: CpuMask, bit: usize) -> CpuMask {
         cur & !(1u32 << bit)
     }
 }
 
-pub type CloneCb<'a> = Box<FnMut() -> int + 'a>;
+pub type CloneCb<'a> = Box<FnMut() -> isize + 'a>;
 
 // A single CPU mask word
 pub type CpuMask = c_ulong;
@@ -81,14 +81,14 @@ impl CpuSet {
         }
     }
 
-    pub fn set(&mut self, field: uint) {
+    pub fn set(&mut self, field: usize) {
         let word = field / cpuset_attribs::CPU_MASK_BITS;
         let bit = field % cpuset_attribs::CPU_MASK_BITS;
 
         self.cpu_mask[word] = cpuset_attribs::set_cpu_mask_flag(self.cpu_mask[word], bit);
     }
 
-    pub fn unset(&mut self, field: uint) {
+    pub fn unset(&mut self, field: usize) {
         let word = field / cpuset_attribs::CPU_MASK_BITS;
         let bit = field % cpuset_attribs::CPU_MASK_BITS;
 
@@ -123,7 +123,7 @@ mod ffi {
     }
 }
 
-pub fn sched_setaffinity(pid: int, cpuset: &CpuSet) -> SysResult<()> {
+pub fn sched_setaffinity(pid: isize, cpuset: &CpuSet) -> SysResult<()> {
     use libc::{pid_t, size_t};
 
     let res = unsafe {
@@ -144,7 +144,7 @@ pub fn clone(mut cb: CloneCb, stack: &mut [u8], flags: CloneFlags) -> SysResult<
     }
 
     let res = unsafe {
-        let ptr = stack.as_mut_ptr().offset(stack.len() as int);
+        let ptr = stack.as_mut_ptr().offset(stack.len() as isize);
         ffi::clone(mem::transmute(callback), ptr as *mut c_void, flags, &mut cb)
     };
 

src/sys/epoll.rs

@@ -102,7 +102,7 @@ pub fn epoll_ctl(epfd: Fd, op: EpollOp, fd: Fd, event: &EpollEvent) -> SysResult
 }
 
 #[inline]
-pub fn epoll_wait(epfd: Fd, events: &mut [EpollEvent], timeout_ms: uint) -> SysResult<uint> {
+pub fn epoll_wait(epfd: Fd, events: &mut [EpollEvent], timeout_ms: usize) -> SysResult<usize> {
     let res = unsafe {
         ffi::epoll_wait(epfd, events.as_mut_ptr(), events.len() as c_int, timeout_ms as c_int)
     };
@@ -111,5 +111,5 @@ pub fn epoll_wait(epfd: Fd, events: &mut [EpollEvent], timeout_ms: uint) -> SysR
         return Err(SysError::last());
     }
 
-    Ok(res as uint)
+    Ok(res as usize)
 }

src/sys/event.rs

@@ -20,7 +20,7 @@ mod ffi {
         pub flags: EventFlag,       // 2
         pub fflags: FilterFlag,     // 4
         pub data: intptr_t,         // 8
-        pub udata: uint             // 8
+        pub udata: usize             // 8
     }
 
     // Bug in rustc, cannot determine that kevent is #[repr(C)]
@@ -171,7 +171,7 @@ pub fn kqueue() -> SysResult<Fd> {
 pub fn kevent(kq: Fd,
               changelist: &[KEvent],
               eventlist: &mut [KEvent],
-              timeout_ms: uint) -> SysResult<uint> {
+              timeout_ms: usize) -> SysResult<usize> {
 
     // Convert ms to timespec
     let timeout = timespec {
@@ -193,16 +193,16 @@ pub fn kevent(kq: Fd,
         return Err(SysError::last());
     }
 
-    return Ok(res as uint)
+    return Ok(res as usize)
 }
 
 #[inline]
 pub fn ev_set(ev: &mut KEvent,
-              ident: uint,
+              ident: usize,
               filter: EventFilter,
               flags: EventFlag,
               fflags: FilterFlag,
-              udata: uint) {
+              udata: usize) {
 
     ev.ident  = ident as uintptr_t;
     ev.filter = filter;

src/sys/eventfd.rs

@@ -11,7 +11,7 @@ bitflags!(
     }
 );
 
-pub fn eventfd(initval: uint, flags: EventFdFlag) -> SysResult<Fd> {
+pub fn eventfd(initval: usize, flags: EventFdFlag) -> SysResult<Fd> {
     type F = unsafe extern "C" fn(initval: c_uint, flags: c_int) -> c_int;
 
     extern {

src/sys/mman.rs

@@ -64,7 +64,7 @@ mod consts {
     pub const MS_SYNC  : MmapSync           = 4;
     pub const MS_INVALIDATE : MmapSync      = 2;
 
-    pub const MAP_FAILED: int               = -1;
+    pub const MAP_FAILED: isize               = -1;
 }
 
 #[cfg(any(target_os = "macos",
@@ -109,7 +109,7 @@ mod consts {
     pub const MS_KILLPAGES  : MmapSync          = 0x0004; /* invalidate pages, leave mapped */
     pub const MS_DEACTIVATE : MmapSync          = 0x0008; /* deactivate pages, leave mapped */
 
-    pub const MAP_FAILED: int               = -1;
+    pub const MAP_FAILED: isize               = -1;
 }
 
 mod ffi {
@@ -147,7 +147,7 @@ pub fn munlock(addr: *const c_void, length: size_t) -> SysResult<()> {
 pub fn mmap(addr: *mut c_void, length: size_t, prot: MmapProt, flags: MmapFlag, fd: Fd, offset: off_t) -> SysResult<*mut c_void> {
     let ret = unsafe { ffi::mmap(addr, length, prot, flags, fd, offset) };
 
-    if ret as int == MAP_FAILED  {
+    if ret as isize == MAP_FAILED  {
         Err(SysError::last())
     } else {
         Ok(ret)

src/sys/socket.rs

@@ -252,7 +252,7 @@ pub fn socket(domain: AddressFamily, mut ty: SockType, flags: SockFlag) -> SysRe
     Ok(res)
 }
 
-pub fn listen(sockfd: Fd, backlog: uint) -> SysResult<()> {
+pub fn listen(sockfd: Fd, backlog: usize) -> SysResult<()> {
     let res = unsafe { ffi::listen(sockfd, backlog as c_int) };
     from_ffi(res)
 }
@@ -368,7 +368,7 @@ mod sa_helpers {
     }
 }
 
-pub fn recvfrom(sockfd: Fd, buf: &mut [u8]) -> SysResult<(uint, SockAddr)> {
+pub fn recvfrom(sockfd: Fd, buf: &mut [u8]) -> SysResult<(usize, SockAddr)> {
     let saddr : sockaddr_storage = unsafe { mem::zeroed() };
     let mut len = mem::size_of::<sockaddr_storage>() as socklen_t;
 
@@ -380,7 +380,7 @@ pub fn recvfrom(sockfd: Fd, buf: &mut [u8]) -> SysResult<(uint, SockAddr)> {
         return Err(SysError::last());
     }
 
-    Ok((ret as uint,
+    Ok((ret as usize,
             match saddr.ss_family as i32 {
                 AF_INET => { sa_helpers::to_sockaddr_ipv4(&saddr) },
                 AF_INET6 => { sa_helpers::to_sockaddr_ipv6(&saddr) },
@@ -427,7 +427,7 @@ fn sendto_sockaddr<T>(sockfd: Fd, buf: &[u8], flags: SockMessageFlags, addr: &T)
     }
 }
 
-pub fn sendto(sockfd: Fd, buf: &[u8], addr: &SockAddr, flags: SockMessageFlags) -> SysResult<uint> {
+pub fn sendto(sockfd: Fd, buf: &[u8], addr: &SockAddr, flags: SockMessageFlags) -> SysResult<usize> {
     use self::SockAddr::*;
 
     let ret = match *addr {
@@ -439,7 +439,7 @@ pub fn sendto(sockfd: Fd, buf: &[u8], addr: &SockAddr, flags: SockMessageFlags)
     if ret < 0 {
         Err(SysError::last())
     } else {
-        Ok(ret as uint)
+        Ok(ret as usize)
     }
 }
 
@@ -450,7 +450,7 @@ pub struct linger {
     pub l_linger: c_int
 }
 
-pub fn getsockopt<T>(fd: Fd, level: SockLevel, opt: SockOpt, val: &mut T) -> SysResult<uint> {
+pub fn getsockopt<T>(fd: Fd, level: SockLevel, opt: SockOpt, val: &mut T) -> SysResult<usize> {
     let mut len = mem::size_of::<T>() as socklen_t;
 
     let res = unsafe {
@@ -464,7 +464,7 @@ pub fn getsockopt<T>(fd: Fd, level: SockLevel, opt: SockOpt, val: &mut T) -> Sys
         return Err(SysError::last());
     }
 
-    Ok(len as uint)
+    Ok(len as usize)
 }
 
 pub fn setsockopt<T>(fd: Fd, level: SockLevel, opt: SockOpt, val: &T) -> SysResult<()> {

src/sys/stat.rs

@@ -42,7 +42,7 @@ pub fn mknod(path: &Path, kind: SFlag, perm: FilePermission, dev: dev_t) -> SysR
 }
 
 #[cfg(target_os = "linux")]
-const MINORBITS: uint = 20;
+const MINORBITS: usize = 20;
 
 #[cfg(target_os = "linux")]
 pub fn mkdev(major: u64, minor: u64) -> dev_t {

src/sys/utsname.rs

@@ -13,7 +13,7 @@ mod ffi {
 }
 
 
-const UTSNAME_LEN: uint = 65;
+const UTSNAME_LEN: usize = 65;
 
 #[repr(C)]
 #[derive(Copy)]

src/unistd.rs

@@ -97,7 +97,7 @@ pub fn fork() -> SysResult<Fork> {
 // let mut v = Vec::new();
 // let iov = Iovec::from_slice(immutable_vec.as_slice());
 // v.push(iov);
-// let _:SysResult<uint> = readv(fd, v.as_slice());
+// let _:SysResult<usize> = readv(fd, v.as_slice());
 
 // We do not want <T> to appear in ffi functions, so we provide this aliases.
 type IovecR = Iovec<ToRead>;
@@ -117,7 +117,7 @@ pub struct Iovec<T> {
 impl <T> Iovec<T> {
     #[inline]
     pub fn as_slice<'a>(&'a self) -> &'a [u8] {
-        unsafe { mem::transmute(RawSlice { data: self.iov_base as *const u8, len: self.iov_len as uint }) }
+        unsafe { mem::transmute(RawSlice { data: self.iov_base as *const u8, len: self.iov_len as usize }) }
     }
 }
 
@@ -271,42 +271,42 @@ pub fn close(fd: Fd) -> SysResult<()> {
     from_ffi(res)
 }
 
-pub fn read(fd: Fd, buf: &mut [u8]) -> SysResult<uint> {
+pub fn read(fd: Fd, buf: &mut [u8]) -> SysResult<usize> {
     let res = unsafe { ffi::read(fd, buf.as_mut_ptr() as *mut c_void, buf.len() as size_t) };
 
     if res < 0 {
         return Err(SysError::last());
     }
 
-    return Ok(res as uint)
+    return Ok(res as usize)
 }
 
-pub fn write(fd: Fd, buf: &[u8]) -> SysResult<uint> {
+pub fn write(fd: Fd, buf: &[u8]) -> SysResult<usize> {
     let res = unsafe { ffi::write(fd, buf.as_ptr() as *const c_void, buf.len() as size_t) };
 
     if res < 0 {
         return Err(SysError::last());
     }
 
-    return Ok(res as uint)
+    return Ok(res as usize)
 }
 
-pub fn writev(fd: Fd, iov: &[Iovec<ToWrite>]) -> SysResult<uint> {
+pub fn writev(fd: Fd, iov: &[Iovec<ToWrite>]) -> SysResult<usize> {
     let res = unsafe { ffi::writev(fd, iov.as_ptr(), iov.len() as c_int) };
     if res < 0 {
         return Err(SysError::last());
     }
 
-    return Ok(res as uint)
+    return Ok(res as usize)
 }
 
-pub fn readv(fd: Fd, iov: &mut [Iovec<ToRead>]) -> SysResult<uint> {
+pub fn readv(fd: Fd, iov: &mut [Iovec<ToRead>]) -> SysResult<usize> {
     let res = unsafe { ffi::readv(fd, iov.as_ptr(), iov.len() as c_int) };
     if res < 0 {
         return Err(SysError::last());
     }
 
-    return Ok(res as uint)
+    return Ok(res as usize)
 }
 
 pub fn pipe() -> SysResult<(Fd, Fd)> {

tests/unistd.rs

@@ -1,5 +1,4 @@
 #![allow(unstable)]
-#![feature(int_uint)]
 
 extern crate nix;
 
@@ -43,7 +42,7 @@ mod test {
         let read_res = read(reader, read_buf.as_mut_slice());
         // Successful read
         assert!(read_res.is_ok());
-        let read = read_res.ok().unwrap() as uint;
+        let read = read_res.ok().unwrap() as usize;
         // Check we have read as much as we written
         assert_eq!(read, written);
         // Check equality of written and read data