///
/// fn main() {
/// unsafe {
-/// let my_num: *mut i32 = libc::malloc(mem::size_of::<i32>() as libc::size_t) as *mut i32;
+/// let my_num: *mut i32 = libc::malloc(mem::size_of::<i32>()) as *mut i32;
/// if my_num.is_null() {
/// panic!("failed to allocate memory");
/// }
#![unstable(reason = "not public", issue = "0", feature = "fd")]
use io::{self, Read};
-use libc::{self, c_int, size_t, c_void};
+use libc::{self, c_int, c_void};
use mem;
use sync::atomic::{AtomicBool, Ordering};
use sys::cvt;
let ret = cvt(unsafe {
libc::read(self.fd,
buf.as_mut_ptr() as *mut c_void,
- buf.len() as size_t)
+ buf.len())
})?;
Ok(ret as usize)
}
let ret = cvt(unsafe {
libc::write(self.fd,
buf.as_ptr() as *const c_void,
- buf.len() as size_t)
+ buf.len())
})?;
Ok(ret as usize)
}
loop {
let buf_read = cvt(unsafe {
- libc::readlink(p, buf.as_mut_ptr() as *mut _, buf.capacity() as libc::size_t)
+ libc::readlink(p, buf.as_mut_ptr() as *mut _, buf.capacity())
})? as usize;
unsafe { buf.set_len(buf_read); }
libc::memchr(
haystack.as_ptr() as *const libc::c_void,
needle as libc::c_int,
- haystack.len() as libc::size_t)
+ haystack.len())
};
if p.is_null() {
None
libc::memrchr(
haystack.as_ptr() as *const libc::c_void,
needle as libc::c_int,
- haystack.len() as libc::size_t)
+ haystack.len())
};
if p.is_null() {
None
unsafe {
libc::write(libc::STDERR_FILENO,
msg.as_ptr() as *const libc::c_void,
- msg.len() as libc::size_t);
+ msg.len());
intrinsics::abort();
}
}
let p = buf.as_mut_ptr();
unsafe {
- if strerror_r(errno as c_int, p, buf.len() as libc::size_t) < 0 {
+ if strerror_r(errno as c_int, p, buf.len()) < 0 {
panic!("strerror_r failure");
}
loop {
unsafe {
let ptr = buf.as_mut_ptr() as *mut libc::c_char;
- if !libc::getcwd(ptr, buf.capacity() as libc::size_t).is_null() {
+ if !libc::getcwd(ptr, buf.capacity()).is_null() {
let len = CStr::from_ptr(buf.as_ptr() as *const libc::c_char).to_bytes().len();
buf.set_len(len);
buf.shrink_to_fit();
libc::KERN_PROC as c_int,
libc::KERN_PROC_PATHNAME as c_int,
-1 as c_int];
- let mut sz: libc::size_t = 0;
+ let mut sz = 0;
cvt(libc::sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint,
- ptr::null_mut(), &mut sz, ptr::null_mut(),
- 0 as libc::size_t))?;
+ ptr::null_mut(), &mut sz, ptr::null_mut(), 0))?;
if sz == 0 {
return Err(io::Error::last_os_error())
}
- let mut v: Vec<u8> = Vec::with_capacity(sz as usize);
+ let mut v: Vec<u8> = Vec::with_capacity(sz);
cvt(libc::sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint,
v.as_mut_ptr() as *mut libc::c_void, &mut sz,
- ptr::null_mut(), 0 as libc::size_t))?;
+ ptr::null_mut(), 0))?;
if sz == 0 {
return Err(io::Error::last_os_error());
}
- v.set_len(sz as usize - 1); // chop off trailing NUL
+ v.set_len(sz - 1); // chop off trailing NUL
Ok(PathBuf::from(OsString::from_vec(v)))
}
}
buf: &mut Vec<c_char>) -> Option<()> {
let mut result = ptr::null_mut();
match libc::getpwuid_r(me, passwd, buf.as_mut_ptr(),
- buf.capacity() as libc::size_t,
+ buf.capacity(),
&mut result) {
0 if !result.is_null() => Some(()),
_ => None
// getpwuid_r semantics is different on Illumos/Solaris:
// http://illumos.org/man/3c/getpwuid_r
let result = libc::getpwuid_r(me, passwd, buf.as_mut_ptr(),
- buf.capacity() as libc::size_t);
+ buf.capacity());
if result.is_null() { None } else { Some(()) }
}
// full entropy pool
let reader = File::open("/dev/urandom").expect("Unable to open /dev/urandom");
let mut reader_rng = ReaderRng::new(reader);
- reader_rng.fill_bytes(& mut v[read..]);
- read += v.len() as usize;
+ reader_rng.fill_bytes(&mut v[read..]);
+ read += v.len();
} else {
panic!("unexpected getrandom error: {}", err);
}
}
fn fill_bytes(&mut self, v: &mut [u8]) {
let ret = unsafe {
- SecRandomCopyBytes(kSecRandomDefault, v.len() as size_t,
+ SecRandomCopyBytes(kSecRandomDefault, v.len(),
v.as_mut_ptr())
};
if ret == -1 {
let stack_size = cmp::max(stack, min_stack_size(&attr));
match pthread_attr_setstacksize(&mut attr,
- stack_size as libc::size_t) {
+ stack_size) {
0 => {}
n => {
assert_eq!(n, libc::EINVAL);
let page_size = os::page_size();
let stack_size = (stack_size + page_size - 1) &
(-(page_size as isize - 1) as usize - 1);
- let stack_size = stack_size as libc::size_t;
assert_eq!(libc::pthread_attr_setstacksize(&mut attr,
stack_size), 0);
}
// Rellocate the last page of the stack.
// This ensures SIGBUS will be raised on
// stack overflow.
- let result = mmap(stackaddr,
- psize as libc::size_t,
- PROT_NONE,
- MAP_PRIVATE | MAP_ANON | MAP_FIXED,
- -1,
- 0);
+ let result = mmap(stackaddr, psize, PROT_NONE,
+ MAP_PRIVATE | MAP_ANON | MAP_FIXED, -1, 0);
if result != stackaddr || result == MAP_FAILED {
panic!("failed to allocate a guard page");
#[cfg(target_os = "macos")]
pub unsafe fn current() -> Option<usize> {
- Some((libc::pthread_get_stackaddr_np(libc::pthread_self()) as libc::size_t -
- libc::pthread_get_stacksize_np(libc::pthread_self())) as usize)
+ Some((libc::pthread_get_stackaddr_np(libc::pthread_self()) as usize -
+ libc::pthread_get_stacksize_np(libc::pthread_self())))
}
#[cfg(any(target_os = "openbsd", target_os = "bitrig"))]
let extra = if cfg!(target_os = "bitrig") {3} else {1} * os::page_size();
Some(if libc::pthread_main_np() == 1 {
// main thread
- current_stack.ss_sp as usize - current_stack.ss_size as usize + extra
+ current_stack.ss_sp as usize - current_stack.ss_size + extra
} else {
// new thread
- current_stack.ss_sp as usize - current_stack.ss_size as usize
+ current_stack.ss_sp as usize - current_stack.ss_size
})
}
&mut size), 0);
ret = if cfg!(target_os = "freebsd") {
- Some(stackaddr as usize - guardsize as usize)
+ Some(stackaddr as usize - guardsize)
} else if cfg!(target_os = "netbsd") {
Some(stackaddr as usize)
} else {
- Some(stackaddr as usize + guardsize as usize)
+ Some(stackaddr as usize + guardsize)
};
}
assert_eq!(libc::pthread_attr_destroy(&mut attr), 0);
weak!(fn __pthread_get_minstack(*const libc::pthread_attr_t) -> libc::size_t);
match __pthread_get_minstack.get() {
- None => libc::PTHREAD_STACK_MIN as usize,
- Some(f) => unsafe { f(attr) as usize },
+ None => libc::PTHREAD_STACK_MIN,
+ Some(f) => unsafe { f(attr) },
}
}
#[cfg(all(not(target_os = "linux"),
not(target_os = "netbsd")))]
fn min_stack_size(_: *const libc::pthread_attr_t) -> usize {
- libc::PTHREAD_STACK_MIN as usize
+ libc::PTHREAD_STACK_MIN
}
#[cfg(target_os = "netbsd")]
projects / rust.git / commitdiff