// Copy the object out from the pointer onto the stack,
// where it is covered by normal Rust destructor semantics
// and cleans itself up, if necessary
- ptr::read(self.ptr as *const T);
+ ptr::read(self.ptr);
// clean-up our allocation
free(self.ptr as *mut c_void)
libc::realloc(ptr as *mut libc::c_void, size as libc::size_t) as *mut u8
} else {
let new_ptr = allocate(size, align);
- ptr::copy_memory(new_ptr, ptr as *const u8, cmp::min(size, old_size));
+ ptr::copy_memory(new_ptr, ptr, cmp::min(size, old_size));
deallocate(ptr, old_size, align);
new_ptr
}
pub fn as_slices<'a>(&'a self) -> (&'a [K], &'a [V]) {
unsafe {(
mem::transmute(raw::Slice {
- data: self.keys.0 as *const K,
+ data: self.keys.0,
len: self.len()
}),
mem::transmute(raw::Slice {
- data: self.vals.0 as *const V,
+ data: self.vals.0,
len: self.len()
})
)}
} else {
unsafe {
mem::transmute(raw::Slice {
- data: self.edges.0 as *const Node<K, V>,
+ data: self.edges.0,
len: self.len() + 1
})
}
/// Turn ptr into a slice
#[inline]
unsafe fn buffer_as_slice(&self) -> &[T] {
- mem::transmute(RawSlice { data: self.ptr as *const T, len: self.cap })
+ mem::transmute(RawSlice { data: self.ptr, len: self.cap })
}
/// Turn ptr into a mut slice
#[inline]
unsafe fn buffer_as_mut_slice(&mut self) -> &mut [T] {
- mem::transmute(RawSlice { data: self.ptr as *const T, len: self.cap })
+ mem::transmute(RawSlice { data: self.ptr, len: self.cap })
}
/// Moves an element out of the buffer
#[inline]
unsafe fn buffer_read(&mut self, off: uint) -> T {
- ptr::read(self.ptr.offset(off as int) as *const T)
+ ptr::read(self.ptr.offset(off as int))
}
/// Writes an element into the buffer, moving it.
&*buf_v.offset(j),
(i - j) as uint);
ptr::copy_nonoverlapping_memory(buf_v.offset(j),
- &tmp as *const T,
+ &tmp,
1);
mem::forget(tmp);
}
pub fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] {
unsafe {
mem::transmute(RawSlice {
- data: *self.ptr as *const T,
+ data: *self.ptr,
len: self.len,
})
}
let ptr = self.as_mut_ptr().offset(index as int);
// copy it out, unsafely having a copy of the value on
// the stack and in the vector at the same time.
- ret = ptr::read(ptr as *const T);
+ ret = ptr::read(ptr);
// Shift everything down to fill in that spot.
ptr::copy_memory(ptr, &*ptr.offset(1), len - index - 1);
// | |
// end_u end_t
- let t = ptr::read(pv.start_t as *const T);
+ let t = ptr::read(pv.start_t);
// start_u start_t
// | |
// +-+-+-+-+-+-+-+-+-+
fn as_slice<'a>(&'a self) -> &'a [T] {
unsafe {
mem::transmute(RawSlice {
- data: *self.ptr as *const T,
+ data: *self.ptr,
len: self.len
})
}
// We have instances of `U`s and `T`s in `vec`. Destruct them.
while self.start_u != self.end_u {
- let _ = ptr::read(self.start_u as *const U); // Run a `U` destructor.
+ let _ = ptr::read(self.start_u); // Run a `U` destructor.
self.start_u = self.start_u.offset(1);
}
while self.start_t != self.end_t {
- let _ = ptr::read(self.start_t as *const T); // Run a `T` destructor.
+ let _ = ptr::read(self.start_t); // Run a `T` destructor.
self.start_t = self.start_t.offset(1);
}
// After this destructor ran, the destructor of `vec` will run,
#[inline]
#[stable]
pub fn load(&self, order: Ordering) -> bool {
- unsafe { atomic_load(self.v.get() as *const usize, order) > 0 }
+ unsafe { atomic_load(self.v.get(), order) > 0 }
}
/// Stores a value into the bool.
/// ```
#[inline]
pub fn load(&self, order: Ordering) -> isize {
- unsafe { atomic_load(self.v.get() as *const isize, order) }
+ unsafe { atomic_load(self.v.get(), order) }
}
/// Stores a value into the isize.
/// ```
#[inline]
pub fn load(&self, order: Ordering) -> usize {
- unsafe { atomic_load(self.v.get() as *const usize, order) }
+ unsafe { atomic_load(self.v.get(), order) }
}
/// Stores a value into the usize.
#[stable]
pub fn load(&self, order: Ordering) -> *mut T {
unsafe {
- atomic_load(self.p.get() as *const *mut T, order) as *mut T
+ atomic_load(self.p.get(), order) as *mut T
}
}
#[inline]
pub fn load(&self, order: Ordering) -> int {
- unsafe { atomic_load(self.v.get() as *const int, order) }
+ unsafe { atomic_load(self.v.get(), order) }
}
#[inline]
#[inline]
pub fn load(&self, order: Ordering) -> uint {
- unsafe { atomic_load(self.v.get() as *const uint, order) }
+ unsafe { atomic_load(self.v.get(), order) }
}
#[inline]
#[inline]
#[stable]
unsafe fn offset(self, count: int) -> *mut T {
- intrinsics::offset(self as *const T, count) as *mut T
+ intrinsics::offset(self, count) as *mut T
}
#[inline]
diff / mem::size_of::<$t>()
};
unsafe {
- transmute::<_, $result>(RawSlice { data: $start as *const T, len: len })
+ transmute::<_, $result>(RawSlice { data: $start, len: len })
}
}}
}
#[inline]
#[unstable = "should be renamed to from_raw_parts_mut"]
pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: uint) -> &'a mut [T] {
- transmute(RawSlice { data: *p as *const T, len: len })
+ transmute(RawSlice { data: *p, len: len })
}
//
// lot more efficient) than doing str::as_c_str("", ...) every time.
pub fn noname() -> *const c_char {
static CNULL: c_char = 0;
- &CNULL as *const c_char
+ &CNULL
}
impl<'a, 'tcx> Builder<'a, 'tcx> {
l_sysid: 0,
};
let ret = unsafe {
- libc::fcntl(fd, os::F_SETLKW, &flock as *const os::flock)
+ libc::fcntl(fd, os::F_SETLKW, &flock)
};
if ret == -1 {
unsafe { libc::close(fd); }
l_sysid: 0,
};
unsafe {
- libc::fcntl(self.fd, os::F_SETLK, &flock as *const os::flock);
+ libc::fcntl(self.fd, os::F_SETLK, &flock);
libc::close(self.fd);
}
}
/// This works similarly to `put`, building an `EmptyBucket` out of the
/// taken bucket.
pub fn take(mut self) -> (EmptyBucket<K, V, M>, K, V) {
- let key = self.raw.key as *const K;
- let val = self.raw.val as *const V;
-
self.table.size -= 1;
unsafe {
idx: self.idx,
table: self.table
},
- ptr::read(key),
- ptr::read(val)
+ ptr::read(self.raw.key),
+ ptr::read(self.raw.val)
)
}
}
pub fn shift(mut self) -> Option<GapThenFull<K, V, M>> {
unsafe {
*self.gap.raw.hash = mem::replace(&mut *self.full.raw.hash, EMPTY_BUCKET);
- copy_nonoverlapping_memory(self.gap.raw.key, self.full.raw.key as *const K, 1);
- copy_nonoverlapping_memory(self.gap.raw.val, self.full.raw.val as *const V, 1);
+ copy_nonoverlapping_memory(self.gap.raw.key, self.full.raw.key, 1);
+ copy_nonoverlapping_memory(self.gap.raw.val, self.full.raw.val, 1);
}
let FullBucket { raw: prev_raw, idx: prev_idx, .. } = self.full;
if *self.raw.hash != EMPTY_BUCKET {
self.elems_left -= 1;
return Some((
- ptr::read(self.raw.key as *const K),
- ptr::read(self.raw.val as *const V)
+ ptr::read(self.raw.key),
+ ptr::read(self.raw.val)
));
}
}
SafeHash {
hash: *bucket.hash,
},
- ptr::read(bucket.key as *const K),
- ptr::read(bucket.val as *const V)
+ ptr::read(bucket.key),
+ ptr::read(bucket.val)
)
}
})
SafeHash {
hash: ptr::replace(bucket.hash, EMPTY_BUCKET),
},
- ptr::read(bucket.key as *const K),
- ptr::read(bucket.val as *const V)
+ ptr::read(bucket.key),
+ ptr::read(bucket.val)
)
}
})
}
let mut info: Dl_info = unsafe { intrinsics::init() };
- if unsafe { dladdr(addr as *const libc::c_void, &mut info) == 0 } {
+ if unsafe { dladdr(addr, &mut info) == 0 } {
output(w, idx,addr, None)
} else {
output(w, idx, addr, Some(unsafe {
// destructor as running for this thread so calls to `get` will return
// `None`.
*(*ptr).dtor_running.get() = true;
- ptr::read((*ptr).inner.get() as *const T);
+ ptr::read((*ptr).inner.get());
}
}
projects / rust.git / commitdiff