// we *need* valid pointer.
assert!(!ptr.is_null());
// `*ptr` is uninitialized, and `*ptr = value` would attempt to destroy it
- // move_val_init moves a value into this memory without
+ // `overwrite` moves a value into this memory without
// attempting to drop the original value.
- mem::move_val_init(&mut *ptr, value);
+ mem::overwrite(&mut *ptr, value);
Unique{ptr: ptr}
}
}
use std::intrinsics::{TyDesc, get_tydesc};
use std::intrinsics;
use std::mem;
-use std::mem::min_align_of;
use std::num;
use std::ptr::read;
use std::rc::Rc;
}
// Find where the next tydesc lives
- idx = round_up(start + size, mem::pref_align_of::<*TyDesc>());
+ idx = round_up(start + size, mem::align_of::<*TyDesc>());
}
}
#[inline]
fn alloc_copy<'a, T>(&'a mut self, op: || -> T) -> &'a T {
unsafe {
- let ptr = self.alloc_copy_inner(mem::size_of::<T>(), min_align_of::<T>());
+ let ptr = self.alloc_copy_inner(mem::size_of::<T>(),
+ mem::min_align_of::<T>());
let ptr = ptr as *mut T;
- mem::move_val_init(&mut (*ptr), op());
+ mem::overwrite(&mut (*ptr), op());
return &*ptr;
}
}
return self.alloc_noncopy_grow(n_bytes, align);
}
- self.head.fill.set(round_up(end, mem::pref_align_of::<*TyDesc>()));
+ self.head.fill.set(round_up(end, mem::align_of::<*TyDesc>()));
//debug!("idx = {}, size = {}, align = {}, fill = {}",
// start, n_bytes, align, head.fill);
unsafe {
let tydesc = get_tydesc::<T>();
let (ty_ptr, ptr) =
- self.alloc_noncopy_inner(mem::size_of::<T>(), min_align_of::<T>());
+ self.alloc_noncopy_inner(mem::size_of::<T>(),
+ mem::min_align_of::<T>());
let ty_ptr = ty_ptr as *mut uint;
let ptr = ptr as *mut T;
// Write in our tydesc along with a bit indicating that it
// has *not* been initialized yet.
*ty_ptr = mem::transmute(tydesc);
// Actually initialize it
- mem::move_val_init(&mut(*ptr), op());
+ mem::overwrite(&mut(*ptr), op());
// Now that we are done, update the tydesc to indicate that
// the object is there.
*ty_ptr = bitpack_tydesc_ptr(tydesc, true);
size = size.checked_add(&elems_size).unwrap();
let mut chunk = unsafe {
- let chunk = exchange_malloc(size, min_align_of::<TypedArenaChunk<T>>());
+ let chunk = exchange_malloc(size,
+ mem::min_align_of::<TypedArenaChunk<T>>());
let mut chunk: Box<TypedArenaChunk<T>> = mem::transmute(chunk);
- mem::move_val_init(&mut chunk.next, next);
+ mem::overwrite(&mut chunk.next, next);
chunk
};
fn start(&self) -> *u8 {
let this: *TypedArenaChunk<T> = self;
unsafe {
- mem::transmute(round_up(this.offset(1) as uint, min_align_of::<T>()))
+ mem::transmute(round_up(this.offset(1) as uint,
+ mem::min_align_of::<T>()))
}
}
}
let ptr: &'a mut T = mem::transmute(this.ptr);
- mem::move_val_init(ptr, object);
+ mem::overwrite(ptr, object);
this.ptr = this.ptr.offset(1);
let ptr: &'a T = ptr;
ptr
#![allow(missing_doc)]
use std::clone::Clone;
-use std::mem::{move_val_init, init, replace, swap};
+use std::mem::{overwrite, zeroed, replace, swap};
use std::slice;
/// A priority queue implemented with a binary heap
// compared to using swaps, which involves twice as many moves.
fn siftup(&mut self, start: uint, mut pos: uint) {
unsafe {
- let new = replace(self.data.get_mut(pos), init());
+ let new = replace(self.data.get_mut(pos), zeroed());
while pos > start {
let parent = (pos - 1) >> 1;
if new > *self.data.get(parent) {
- let x = replace(self.data.get_mut(parent), init());
- move_val_init(self.data.get_mut(pos), x);
+ let x = replace(self.data.get_mut(parent), zeroed());
+ overwrite(self.data.get_mut(pos), x);
pos = parent;
continue
}
break
}
- move_val_init(self.data.get_mut(pos), new);
+ overwrite(self.data.get_mut(pos), new);
}
}
fn siftdown_range(&mut self, mut pos: uint, end: uint) {
unsafe {
let start = pos;
- let new = replace(self.data.get_mut(pos), init());
+ let new = replace(self.data.get_mut(pos), zeroed());
let mut child = 2 * pos + 1;
while child < end {
if right < end && !(*self.data.get(child) > *self.data.get(right)) {
child = right;
}
- let x = replace(self.data.get_mut(child), init());
- move_val_init(self.data.get_mut(pos), x);
+ let x = replace(self.data.get_mut(child), zeroed());
+ overwrite(self.data.get_mut(pos), x);
pos = child;
child = 2 * pos + 1;
}
- move_val_init(self.data.get_mut(pos), new);
+ overwrite(self.data.get_mut(pos), new);
self.siftup(start, pos);
}
}
//! Ordered containers with integer keys, implemented as radix tries (`TrieSet` and `TrieMap` types)
-use std::mem::init;
+use std::mem::zeroed;
use std::mem;
use std::slice::{Items, MutItems};
use std::slice;
remaining_max: 0,
length: 0,
// ick :( ... at least the compiler will tell us if we screwed up.
- stack: [init(), init(), init(), init(), init(), init(), init(), init()]
+ stack: [zeroed(), zeroed(), zeroed(), zeroed(), zeroed(),
+ zeroed(), zeroed(), zeroed()]
}
}
remaining_min: 0,
remaining_max: 0,
length: 0,
- stack: [init(), init(), init(), init(), init(), init(), init(), init(),
- init(), init(), init(), init(), init(), init(), init(), init()]
+ stack: [zeroed(), zeroed(), zeroed(), zeroed(),
+ zeroed(), zeroed(), zeroed(), zeroed(),
+ zeroed(), zeroed(), zeroed(), zeroed(),
+ zeroed(), zeroed(), zeroed(), zeroed()]
}
}
}
/// Returns the size of a type in bytes.
#[inline]
+#[stable]
pub fn size_of<T>() -> uint {
unsafe { intrinsics::size_of::<T>() }
}
/// Returns the size of the type that `_val` points to in bytes.
#[inline]
+#[unstable = "the name of this function may change slightly before stabilizing"]
pub fn size_of_val<T>(_val: &T) -> uint {
size_of::<T>()
}
-/// Returns the size of a type in bytes, or 1 if the actual size is zero.
-///
-/// Useful for building structures containing variable-length arrays.
+/// Deprecated, this function will be removed soon
#[inline]
+#[deprecated = "this function will be removed soon"]
pub fn nonzero_size_of<T>() -> uint {
match size_of::<T>() {
0 => 1,
- x => x
+ n => n,
}
}
-/// Returns the size in bytes of the type of the value that `_val` points to.
+/// Deprecated, this function will be removed soon
#[inline]
-pub fn nonzero_size_of_val<T>(_val: &T) -> uint {
- nonzero_size_of::<T>()
+#[deprecated = "this function will be removed soon"]
+pub fn nonzero_size_of_val<T>(val: &T) -> uint {
+ match size_of_val::<T>(val) {
+ 0 => 1,
+ n => n,
+ }
}
/// Returns the ABI-required minimum alignment of a type
/// This is the alignment used for struct fields. It may be smaller
/// than the preferred alignment.
#[inline]
+#[stable]
pub fn min_align_of<T>() -> uint {
unsafe { intrinsics::min_align_of::<T>() }
}
/// Returns the ABI-required minimum alignment of the type of the value that
/// `_val` points to
#[inline]
+#[unstable = "the name of this function may change slightly before stabilizing"]
pub fn min_align_of_val<T>(_val: &T) -> uint {
min_align_of::<T>()
}
-/// Returns the preferred alignment of a type
+/// Returns the alignment in memory for a type.
+///
+/// This function will return the alignment, in bytes, of a type in memory. If
+/// the alignment returned is adhered to, then the type is guaranteed to
+/// function properly.
#[inline]
-pub fn pref_align_of<T>() -> uint {
+#[stable]
+pub fn align_of<T>() -> uint {
+ // We use the preferred alignment as the default alignment for a type. This
+ // appears to be what clang migrated towards as well:
+ //
+ // http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20110725/044411.html
unsafe { intrinsics::pref_align_of::<T>() }
}
-/// Returns the preferred alignment of the type of the value that
-/// `_val` points to
+/// Returns the alignment of the type of the value that `_val` points to.
+///
+/// This is similar to `align_of`, but function will properly handle types such
+/// as trait objects (in the future), returning the alignment for an arbitrary
+/// value at runtime.
#[inline]
-pub fn pref_align_of_val<T>(_val: &T) -> uint {
- pref_align_of::<T>()
+#[unstable = "the name of this function may change slightly before stabilizing"]
+pub fn align_of_val<T>(_val: &T) -> uint {
+ align_of::<T>()
}
+/// Deprecated, this function has been renamed to align_of
+#[inline]
+#[deprecated = "use mem::align_of instead"]
+pub fn pref_align_of<T>() -> uint { align_of::<T>() }
+
+/// Deprecated, this function has been renamed to align_of_val
+#[inline]
+#[deprecated = "use mem::align_of_val instead"]
+pub fn pref_align_of_val<T>(val: &T) -> uint { align_of_val(val) }
+
/// Create a value initialized to zero.
///
-/// `init` is unsafe because it returns a zeroed-out datum,
-/// which is unsafe unless T is Copy.
+/// This function is similar to allocating space for a a local variable and
+/// zeroing it out (an unsafe operation).
+///
+/// Care must be taken when using this function, if the type `T` has a
+/// destructor and the value falls out of scope (due to unwinding or returning)
+/// before being initialized, then the destructor will run on zeroed
+/// data, likely leading to crashes.
+///
+/// This is useful for FFI functions sometimes, but should generally be avoided.
#[inline]
-pub unsafe fn init<T>() -> T {
+#[unstable = "the name of this function is subject to change"]
+pub unsafe fn zeroed<T>() -> T {
intrinsics::init()
}
+/// Deprecated, use zeroed() instead
+#[inline]
+#[deprecated = "this function has been renamed to zeroed()"]
+pub unsafe fn init<T>() -> T { zeroed() }
+
/// Create an uninitialized value.
+///
+/// Care must be taken when using this function, if the type `T` has a
+/// destructor and the value falls out of scope (due to unwinding or returning)
+/// before being initialized, then the destructor will run on uninitialized
+/// data, likely leading to crashes.
+///
+/// This is useful for FFI functions sometimes, but should generally be avoided.
#[inline]
+#[unstable = "the name of this function is subject to change"]
pub unsafe fn uninit<T>() -> T {
intrinsics::uninit()
}
-/// Move a value to an uninitialized memory location.
+/// Unsafely overwrite a memory location with the given value without destroying
+/// the old value.
///
-/// Drop glue is not run on the destination.
+/// This operation is unsafe because it does not destroy the previous value
+/// contained at the location `dst`. This could leak allocations or resources,
+/// so care must be taken to previously deallocate the value at `dst`.
+#[inline]
+#[unstable = "the name of this function is subject to change"]
+pub unsafe fn overwrite<T>(dst: *mut T, src: T) {
+ intrinsics::move_val_init(&mut *dst, src)
+}
+
+/// Deprecated, use move_val_init() instead
#[inline]
+#[deprecated = "this function has been renamed to move_val_init()"]
pub unsafe fn move_val_init<T>(dst: &mut T, src: T) {
- intrinsics::move_val_init(dst, src)
+ overwrite(dst, src)
}
/// Convert an u16 to little endian from the target's endianness.
/// Convert an u16 to little endian from the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn to_le16(x: u16) -> u16 { unsafe { bswap16(x) } }
+#[cfg(target_endian = "big")] #[inline] #[stable]
+pub fn to_le16(x: u16) -> u16 { unsafe { bswap16(x) } }
/// Convert an u32 to little endian from the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn to_le32(x: u32) -> u32 { x }
+#[cfg(target_endian = "little")] #[inline] #[stable]
+pub fn to_le32(x: u32) -> u32 { x }
/// Convert an u32 to little endian from the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn to_le32(x: u32) -> u32 { unsafe { bswap32(x) } }
+#[cfg(target_endian = "big")] #[inline] #[stable]
+pub fn to_le32(x: u32) -> u32 { unsafe { bswap32(x) } }
/// Convert an u64 to little endian from the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn to_le64(x: u64) -> u64 { x }
+#[cfg(target_endian = "little")] #[inline] #[stable]
+pub fn to_le64(x: u64) -> u64 { x }
/// Convert an u64 to little endian from the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn to_le64(x: u64) -> u64 { unsafe { bswap64(x) } }
+#[cfg(target_endian = "big")] #[inline] #[stable]
+pub fn to_le64(x: u64) -> u64 { unsafe { bswap64(x) } }
/// Convert an u16 to big endian from the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn to_be16(x: u16) -> u16 { unsafe { bswap16(x) } }
+#[cfg(target_endian = "little")] #[inline] #[stable]
+pub fn to_be16(x: u16) -> u16 { unsafe { bswap16(x) } }
/// Convert an u16 to big endian from the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn to_be16(x: u16) -> u16 { x }
+#[cfg(target_endian = "big")] #[inline] #[stable]
+pub fn to_be16(x: u16) -> u16 { x }
/// Convert an u32 to big endian from the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn to_be32(x: u32) -> u32 { unsafe { bswap32(x) } }
+#[cfg(target_endian = "little")] #[inline] #[stable]
+pub fn to_be32(x: u32) -> u32 { unsafe { bswap32(x) } }
/// Convert an u32 to big endian from the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn to_be32(x: u32) -> u32 { x }
+#[cfg(target_endian = "big")] #[inline] #[stable]
+pub fn to_be32(x: u32) -> u32 { x }
/// Convert an u64 to big endian from the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn to_be64(x: u64) -> u64 { unsafe { bswap64(x) } }
+#[cfg(target_endian = "little")] #[inline] #[stable]
+pub fn to_be64(x: u64) -> u64 { unsafe { bswap64(x) } }
/// Convert an u64 to big endian from the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn to_be64(x: u64) -> u64 { x }
+#[cfg(target_endian = "big")] #[inline] #[stable]
+pub fn to_be64(x: u64) -> u64 { x }
/// Convert an u16 from little endian to the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn from_le16(x: u16) -> u16 { x }
+#[cfg(target_endian = "little")] #[inline] #[stable]
+pub fn from_le16(x: u16) -> u16 { x }
/// Convert an u16 from little endian to the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn from_le16(x: u16) -> u16 { unsafe { bswap16(x) } }
+#[cfg(target_endian = "big")] #[inline] #[stable]
+pub fn from_le16(x: u16) -> u16 { unsafe { bswap16(x) } }
/// Convert an u32 from little endian to the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn from_le32(x: u32) -> u32 { x }
+#[cfg(target_endian = "little")] #[inline] #[stable]
+pub fn from_le32(x: u32) -> u32 { x }
/// Convert an u32 from little endian to the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn from_le32(x: u32) -> u32 { unsafe { bswap32(x) } }
+#[cfg(target_endian = "big")] #[inline] #[stable]
+pub fn from_le32(x: u32) -> u32 { unsafe { bswap32(x) } }
/// Convert an u64 from little endian to the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn from_le64(x: u64) -> u64 { x }
+#[cfg(target_endian = "little")] #[inline] #[stable]
+pub fn from_le64(x: u64) -> u64 { x }
/// Convert an u64 from little endian to the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn from_le64(x: u64) -> u64 { unsafe { bswap64(x) } }
+#[cfg(target_endian = "big")] #[inline] #[stable]
+pub fn from_le64(x: u64) -> u64 { unsafe { bswap64(x) } }
/// Convert an u16 from big endian to the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn from_be16(x: u16) -> u16 { unsafe { bswap16(x) } }
+#[cfg(target_endian = "little")] #[inline] #[stable]
+pub fn from_be16(x: u16) -> u16 { unsafe { bswap16(x) } }
/// Convert an u16 from big endian to the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn from_be16(x: u16) -> u16 { x }
+#[cfg(target_endian = "big")] #[inline] #[stable]
+pub fn from_be16(x: u16) -> u16 { x }
/// Convert an u32 from big endian to the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn from_be32(x: u32) -> u32 { unsafe { bswap32(x) } }
+#[cfg(target_endian = "little")] #[inline] #[stable]
+pub fn from_be32(x: u32) -> u32 { unsafe { bswap32(x) } }
/// Convert an u32 from big endian to the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn from_be32(x: u32) -> u32 { x }
+#[cfg(target_endian = "big")] #[inline] #[stable]
+pub fn from_be32(x: u32) -> u32 { x }
/// Convert an u64 from big endian to the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn from_be64(x: u64) -> u64 { unsafe { bswap64(x) } }
+#[cfg(target_endian = "little")] #[inline] #[stable]
+pub fn from_be64(x: u64) -> u64 { unsafe { bswap64(x) } }
/// Convert an u64 from big endian to the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn from_be64(x: u64) -> u64 { x }
+#[cfg(target_endian = "big")] #[inline] #[stable]
+pub fn from_be64(x: u64) -> u64 { x }
/**
* Swap the values at two mutable locations of the same type, without
* deinitialising or copying either one.
*/
#[inline]
+#[stable]
pub fn swap<T>(x: &mut T, y: &mut T) {
unsafe {
// Give ourselves some scratch space to work with
* ```
*/
#[inline]
+#[stable]
pub fn replace<T>(dest: &mut T, mut src: T) -> T {
swap(dest, &mut src);
src
/// println!("{}", *borrow);
/// ```
#[inline]
+#[stable]
pub fn drop<T>(_x: T) { }
/// Moves a thing into the void.
assert_eq!(size_of_val(&1u64), 8);
}
- #[test]
- fn nonzero_size_of_basic() {
- type Z = [i8, ..0];
- assert_eq!(size_of::<Z>(), 0u);
- assert_eq!(nonzero_size_of::<Z>(), 1u);
- assert_eq!(nonzero_size_of::<uint>(), size_of::<uint>());
- }
-
- #[test]
- fn nonzero_size_of_val_basic() {
- let z = [0u8, ..0];
- assert_eq!(size_of_val(&z), 0u);
- assert_eq!(nonzero_size_of_val(&z), 1u);
- assert_eq!(nonzero_size_of_val(&1u), size_of_val(&1u));
- }
-
#[test]
fn align_of_basic() {
- assert_eq!(pref_align_of::<u8>(), 1u);
- assert_eq!(pref_align_of::<u16>(), 2u);
- assert_eq!(pref_align_of::<u32>(), 4u);
+ assert_eq!(align_of::<u8>(), 1u);
+ assert_eq!(align_of::<u16>(), 2u);
+ assert_eq!(align_of::<u32>(), 4u);
}
#[test]
#[cfg(target_arch = "arm")]
#[cfg(target_arch = "mips")]
fn align_of_32() {
- assert_eq!(pref_align_of::<uint>(), 4u);
- assert_eq!(pref_align_of::<*uint>(), 4u);
+ assert_eq!(align_of::<uint>(), 4u);
+ assert_eq!(align_of::<*uint>(), 4u);
}
#[test]
#[cfg(target_arch = "x86_64")]
fn align_of_64() {
- assert_eq!(pref_align_of::<uint>(), 8u);
- assert_eq!(pref_align_of::<*uint>(), 8u);
+ assert_eq!(align_of::<uint>(), 8u);
+ assert_eq!(align_of::<*uint>(), 8u);
}
#[test]
fn align_of_val_basic() {
- assert_eq!(pref_align_of_val(&1u8), 1u);
- assert_eq!(pref_align_of_val(&1u16), 2u);
- assert_eq!(pref_align_of_val(&1u32), 4u);
+ assert_eq!(align_of_val(&1u8), 1u);
+ assert_eq!(align_of_val(&1u16), 2u);
+ assert_eq!(align_of_val(&1u32), 4u);
}
#[test]
unsafe {
let ret = alloc(size) as *mut Vec<A>;
- (*ret).fill = len * mem::nonzero_size_of::<A>();
- (*ret).alloc = len * mem::nonzero_size_of::<A>();
+ let a_size = mem::size_of::<A>();
+ let a_size = if a_size == 0 {1} else {a_size};
+ (*ret).fill = len * a_size;
+ (*ret).alloc = len * a_size;
let mut i = 0;
let p = &mut (*ret).data as *mut _ as *mut A;
try_finally(
&mut i, (),
|i, ()| while *i < len {
- mem::move_val_init(
+ mem::overwrite(
&mut(*p.offset(*i as int)),
self.unsafe_ref(*i).clone());
*i += 1;
#[inline]
unsafe fn init_elem(self, i: uint, val: T) {
- mem::move_val_init(&mut (*self.as_mut_ptr().offset(i as int)), val);
+ mem::overwrite(&mut (*self.as_mut_ptr().offset(i as int)), val);
}
#[inline]
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) {
let diff = (self.end as uint) - (self.ptr as uint);
- let exact = diff / mem::nonzero_size_of::<T>();
+ let size = mem::size_of::<T>();
+ let exact = diff / (if size == 0 {1} else {size});
(exact, Some(exact))
}
}
fn pread(&mut self, buf: &mut [u8], offset: u64) -> Result<int, IoError> {
let mut read = 0;
- let mut overlap: libc::OVERLAPPED = unsafe { mem::init() };
+ let mut overlap: libc::OVERLAPPED = unsafe { mem::zeroed() };
overlap.Offset = offset as libc::DWORD;
overlap.OffsetHigh = (offset >> 32) as libc::DWORD;
let ret = unsafe {
fn pwrite(&mut self, buf: &[u8], mut offset: u64) -> Result<(), IoError> {
let mut cur = buf.as_ptr();
let mut remaining = buf.len();
- let mut overlap: libc::OVERLAPPED = unsafe { mem::init() };
+ let mut overlap: libc::OVERLAPPED = unsafe { mem::zeroed() };
while remaining > 0 {
overlap.Offset = offset as libc::DWORD;
overlap.OffsetHigh = (offset >> 32) as libc::DWORD;
fn addr_to_sockaddr(addr: ip::SocketAddr) -> (libc::sockaddr_storage, uint) {
unsafe {
- let storage: libc::sockaddr_storage = mem::init();
+ let storage: libc::sockaddr_storage = mem::zeroed();
let len = match ip_to_inaddr(addr.ip) {
InAddr(inaddr) => {
let storage: *mut libc::sockaddr_in = mem::transmute(&storage);
pub fn getsockopt<T: Copy>(fd: sock_t, opt: libc::c_int,
val: libc::c_int) -> IoResult<T> {
unsafe {
- let mut slot: T = mem::init();
+ let mut slot: T = mem::zeroed();
let mut len = mem::size_of::<T>() as libc::socklen_t;
let ret = c::getsockopt(fd, opt, val,
&mut slot as *mut _ as *mut _,
*mut libc::socklen_t) -> libc::c_int)
-> IoResult<ip::SocketAddr>
{
- let mut storage: libc::sockaddr_storage = unsafe { mem::init() };
+ let mut storage: libc::sockaddr_storage = unsafe { mem::zeroed() };
let mut len = mem::size_of::<libc::sockaddr_storage>() as libc::socklen_t;
unsafe {
let storage = &mut storage as *mut libc::sockaddr_storage;
let _guard = LOCK.lock();
if !INITIALIZED {
- let mut data: c::WSADATA = mem::init();
+ let mut data: c::WSADATA = mem::zeroed();
let ret = c::WSAStartup(0x202, // version 2.2
&mut data);
assert_eq!(ret, 0);
try!(util::await(self.fd(), Some(self.deadline), util::Readable));
}
unsafe {
- let mut storage: libc::sockaddr_storage = mem::init();
+ let mut storage: libc::sockaddr_storage = mem::zeroed();
let storagep = &mut storage as *mut libc::sockaddr_storage;
let size = mem::size_of::<libc::sockaddr_storage>();
let mut size = size as libc::socklen_t;
impl rtio::RtioUdpSocket for UdpSocket {
fn recvfrom(&mut self, buf: &mut [u8]) -> IoResult<(uint, ip::SocketAddr)> {
let fd = self.fd();
- let mut storage: libc::sockaddr_storage = unsafe { mem::init() };
+ let mut storage: libc::sockaddr_storage = unsafe { mem::zeroed() };
let storagep = &mut storage as *mut _ as *mut libc::sockaddr;
let mut addrlen: libc::socklen_t =
mem::size_of::<libc::sockaddr_storage>() as libc::socklen_t;
use libc;
use std::c_str::CString;
-use std::intrinsics;
use std::io;
+use std::mem;
use std::os::win32::as_utf16_p;
use std::os;
use std::ptr;
}
let mut bytes_read = 0;
- let mut overlapped: libc::OVERLAPPED = unsafe { intrinsics::init() };
+ let mut overlapped: libc::OVERLAPPED = unsafe { mem::zeroed() };
overlapped.hEvent = self.read.get_ref().handle();
// Pre-flight check to see if the reading half has been closed. This
}
let mut offset = 0;
- let mut overlapped: libc::OVERLAPPED = unsafe { intrinsics::init() };
+ let mut overlapped: libc::OVERLAPPED = unsafe { mem::zeroed() };
overlapped.hEvent = self.write.get_ref().handle();
while offset < buf.len() {
// someone on the other end connects. This function can "fail" if a
// client connects after we created the pipe but before we got down
// here. Thanks windows.
- let mut overlapped: libc::OVERLAPPED = unsafe { intrinsics::init() };
+ let mut overlapped: libc::OVERLAPPED = unsafe { mem::zeroed() };
overlapped.hEvent = self.event.handle();
if unsafe { libc::ConnectNamedPipe(handle, &mut overlapped) == 0 } {
let mut err = unsafe { libc::GetLastError() };
// self-pipe plus the old handler registered (return value of sigaction).
fn register_sigchld() -> (libc::c_int, c::sigaction) {
unsafe {
- let mut old: c::sigaction = mem::init();
- let mut new: c::sigaction = mem::init();
+ let mut old: c::sigaction = mem::zeroed();
+ let mut new: c::sigaction = mem::zeroed();
new.sa_handler = sigchld_handler;
new.sa_flags = c::SA_NOCLDSTOP;
assert_eq!(c::sigaction(c::SIGCHLD, &new, &mut old), 0);
messages: Receiver<Req>,
(read_fd, old): (libc::c_int, c::sigaction)) {
util::set_nonblocking(input, true).unwrap();
- let mut set: c::fd_set = unsafe { mem::init() };
+ let mut set: c::fd_set = unsafe { mem::zeroed() };
let mut tv: libc::timeval;
let mut active = Vec::<(libc::pid_t, Sender<p::ProcessExit>, u64)>::new();
let max = cmp::max(input, read_fd) + 1;
// returns the current time (in milliseconds)
pub fn now() -> u64 {
unsafe {
- let mut now: libc::timeval = mem::init();
+ let mut now: libc::timeval = mem::zeroed();
assert_eq!(c::gettimeofday(&mut now, ptr::null()), 0);
return (now.tv_sec as u64) * 1000 + (now.tv_usec as u64) / 1000;
}
}
fn helper(input: libc::c_int, messages: Receiver<Req>, _: ()) {
- let mut set: c::fd_set = unsafe { mem::init() };
+ let mut set: c::fd_set = unsafe { mem::zeroed() };
let mut fd = FileDesc::new(input, true);
- let mut timeout: libc::timeval = unsafe { mem::init() };
+ let mut timeout: libc::timeval = unsafe { mem::zeroed() };
// active timers are those which are able to be selected upon (and it's a
// sorted list, and dead timers are those which have expired, but ownership
// to use select() with a timeout.
-1 if os::errno() as int == INPROGRESS as int ||
os::errno() as int == WOULDBLOCK as int => {
- let mut set: c::fd_set = unsafe { mem::init() };
+ let mut set: c::fd_set = unsafe { mem::zeroed() };
c::fd_set(&mut set, fd);
match await(fd, &mut set, timeout_ms) {
0 => Err(timeout("connection timed out")),
pub fn await(fd: net::sock_t, deadline: Option<u64>,
status: SocketStatus) -> IoResult<()> {
- let mut set: c::fd_set = unsafe { mem::init() };
+ let mut set: c::fd_set = unsafe { mem::zeroed() };
c::fd_set(&mut set, fd);
let (read, write) = match status {
Readable => (&set as *_, ptr::null()),
Writable => (ptr::null(), &set as *_),
};
- let mut tv: libc::timeval = unsafe { mem::init() };
+ let mut tv: libc::timeval = unsafe { mem::zeroed() };
match retry(|| {
let now = ::io::timer::now();
if handle as uint == libc::INVALID_HANDLE_VALUE as uint {
fail!("create file error: {}", os::last_os_error());
}
- let mut overlapped: libc::OVERLAPPED = unsafe { mem::init() };
+ let mut overlapped: libc::OVERLAPPED = unsafe { mem::zeroed() };
let ret = unsafe {
LockFileEx(handle, LOCKFILE_EXCLUSIVE_LOCK, 0, 100, 0,
&mut overlapped)
impl Drop for Lock {
fn drop(&mut self) {
- let mut overlapped: libc::OVERLAPPED = unsafe { mem::init() };
+ let mut overlapped: libc::OVERLAPPED = unsafe { mem::zeroed() };
unsafe {
UnlockFileEx(self.handle, 0, 100, 0, &mut overlapped);
libc::CloseHandle(self.handle);
fn addr_to_sockaddr(addr: ip::SocketAddr) -> (libc::sockaddr_storage, uint) {
unsafe {
- let mut storage: libc::sockaddr_storage = mem::init();
+ let mut storage: libc::sockaddr_storage = mem::zeroed();
let len = match addr.ip {
ip::Ipv4Addr(a, b, c, d) => {
let storage: &mut libc::sockaddr_in =
};
// Allocate a sockaddr_storage since we don't know if it's ipv4 or ipv6
- let mut sockaddr: libc::sockaddr_storage = unsafe { mem::init() };
+ let mut sockaddr: libc::sockaddr_storage = unsafe { mem::zeroed() };
let mut namelen = mem::size_of::<libc::sockaddr_storage>() as c_int;
let sockaddr_p = &mut sockaddr as *mut libc::sockaddr_storage;
// this should pass the real required alignment
let ret = exchange_malloc(size, 8) as *mut RawVec<()>;
- (*ret).fill = len * mem::nonzero_size_of::<T>();
- (*ret).alloc = len * mem::nonzero_size_of::<T>();
+ let a_size = mem::size_of::<T>();
+ let a_size = if a_size == 0 {1} else {a_size};
+ (*ret).fill = len * a_size;
+ (*ret).alloc = len * a_size;
// Be careful with the following loop. We want it to be optimized
// to a memcpy (or something similarly fast) when T is Copy. LLVM
try_finally(
&mut i, (),
|i, ()| while *i < len {
- mem::move_val_init(
+ mem::overwrite(
&mut(*p.offset(*i as int)),
self.unsafe_ref(*i).clone());
*i += 1;
impl Mutex {
pub unsafe fn new() -> Mutex {
let m = Mutex {
- lock: Unsafe::new(mem::init()),
- cond: Unsafe::new(mem::init()),
+ lock: Unsafe::new(mem::zeroed()),
+ cond: Unsafe::new(mem::zeroed()),
};
pthread_mutex_init(m.lock.get(), 0 as *libc::c_void);
unsafe {
let mut xs = Vec::with_capacity(length);
while xs.len < length {
- mem::move_val_init(xs.as_mut_slice().unsafe_mut_ref(xs.len),
+ mem::overwrite(xs.as_mut_slice().unsafe_mut_ref(xs.len),
op(xs.len));
xs.len += 1;
}
unsafe {
let mut xs = Vec::with_capacity(length);
while xs.len < length {
- mem::move_val_init(xs.as_mut_slice().unsafe_mut_ref(xs.len),
+ mem::overwrite(xs.as_mut_slice().unsafe_mut_ref(xs.len),
value.clone());
xs.len += 1;
}
let this_slice = self.as_slice();
while vector.len < len {
unsafe {
- mem::move_val_init(
+ mem::overwrite(
vector.as_mut_slice().unsafe_mut_ref(vector.len),
this_slice.unsafe_ref(vector.len).clone());
}
unsafe {
let end = (self.ptr as *T).offset(self.len as int) as *mut T;
- mem::move_val_init(&mut *end, value);
+ mem::overwrite(&mut *end, value);
self.len += 1;
}
}
ptr::copy_memory(p.offset(1), &*p, len - index);
// Write it in, overwriting the first copy of the `index`th
// element.
- mem::move_val_init(&mut *p, element);
+ mem::overwrite(&mut *p, element);
}
self.set_len(len + 1);
}
unsafe {
let ret = allocate(size, 8) as *mut RawVec<()>;
- (*ret).fill = len * mem::nonzero_size_of::<T>();
- (*ret).alloc = len * mem::nonzero_size_of::<T>();
+ let a_size = mem::size_of::<T>();
+ let a_size = if a_size == 0 {1} else {a_size};
+ (*ret).fill = len * a_size;
+ (*ret).alloc = len * a_size;
ptr::copy_nonoverlapping_memory(&mut (*ret).data as *mut _ as *mut u8,
vp as *u8, data_size);
unsafe {
let mut x: bool = false;
// this line breaks it
- mem::move_val_init(&mut x, false);
+ mem::overwrite(&mut x, false);
}
}
projects / rust.git / commitdiff