From 34d376f3cf234dc714fcfab7639affd3967dc16d Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Wed, 16 Oct 2013 18:34:01 -0700 Subject: std: Move size/align functions to std::mem. #2240 --- src/libstd/vec.rs | 44 ++++++++++++++++++++++---------------------- 1 file changed, 22 insertions(+), 22 deletions(-) (limited to 'src/libstd/vec.rs') diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index 60c569e75d0..d298507aa8c 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -116,8 +116,8 @@ use ptr; use ptr::RawPtr; use rt::global_heap::malloc_raw; use rt::global_heap::realloc_raw; -use sys; -use sys::size_of; +use mem; +use mem::size_of; use uint; use unstable::finally::Finally; use unstable::intrinsics; @@ -185,8 +185,8 @@ pub fn with_capacity(capacity: uint) -> ~[T] { vec.reserve(capacity); vec } else { - let alloc = capacity * sys::nonzero_size_of::(); - let ptr = malloc_raw(alloc + sys::size_of::>()) as *mut Vec<()>; + let alloc = capacity * mem::nonzero_size_of::(); + let ptr = malloc_raw(alloc + mem::size_of::>()) as *mut Vec<()>; (*ptr).alloc = alloc; (*ptr).fill = 0; cast::transmute(ptr) @@ -1002,7 +1002,7 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] { fn iter(self) -> VecIterator<'self, T> { unsafe { let p = vec::raw::to_ptr(self); - if sys::size_of::() == 0 { + if mem::size_of::() == 0 { VecIterator{ptr: p, end: (p as uint + self.len()) as *T, lifetime: None} @@ -1406,9 +1406,9 @@ impl OwnedVector for ~[T] { ::at_vec::raw::reserve_raw(td, ptr, n); } else { let ptr: *mut *mut Vec<()> = cast::transmute(self); - let alloc = n * sys::nonzero_size_of::(); - let size = alloc + sys::size_of::>(); - if alloc / sys::nonzero_size_of::() != n || size < alloc { + let alloc = n * mem::nonzero_size_of::(); + let size = alloc + mem::size_of::>(); + if alloc / mem::nonzero_size_of::() != n || size < alloc { fail2!("vector size is too large: {}", n); } *ptr = realloc_raw(*ptr as *mut c_void, size) @@ -1439,10 +1439,10 @@ impl OwnedVector for ~[T] { unsafe { if contains_managed::() { let repr: **Box> = cast::transmute(self); - (**repr).data.alloc / sys::nonzero_size_of::() + (**repr).data.alloc / mem::nonzero_size_of::() } else { let repr: **Vec<()> = cast::transmute(self); - (**repr).alloc / sys::nonzero_size_of::() + (**repr).alloc / mem::nonzero_size_of::() } } } @@ -1451,7 +1451,7 @@ impl OwnedVector for ~[T] { unsafe { let ptr: *mut *mut Vec<()> = cast::transmute(self); let alloc = (**ptr).fill; - let size = alloc + sys::size_of::>(); + let size = alloc + mem::size_of::>(); *ptr = realloc_raw(*ptr as *mut c_void, size) as *mut Vec<()>; (**ptr).alloc = alloc; } @@ -1485,14 +1485,14 @@ impl OwnedVector for ~[T] { if contains_managed::() { let repr: **mut Box> = cast::transmute(this); let fill = (**repr).data.fill; - (**repr).data.fill += sys::nonzero_size_of::(); + (**repr).data.fill += mem::nonzero_size_of::(); let p = to_unsafe_ptr(&((**repr).data.data)); let p = ptr::offset(p, fill as int) as *mut T; intrinsics::move_val_init(&mut(*p), t); } else { let repr: **mut Vec = cast::transmute(this); let fill = (**repr).fill; - (**repr).fill += sys::nonzero_size_of::(); + (**repr).fill += mem::nonzero_size_of::(); let p = to_unsafe_ptr(&((**repr).data)); let p = ptr::offset(p, fill as int) as *mut T; intrinsics::move_val_init(&mut(*p), t); @@ -1957,7 +1957,7 @@ impl<'self,T> MutableVector<'self, T> for &'self mut [T] { fn mut_iter(self) -> VecMutIterator<'self, T> { unsafe { let p = vec::raw::to_mut_ptr(self); - if sys::size_of::() == 0 { + if mem::size_of::() == 0 { VecMutIterator{ptr: p, end: (p as uint + self.len()) as *mut T, lifetime: None} @@ -2054,7 +2054,7 @@ pub mod raw { use clone::Clone; use option::Some; use ptr; - use sys; + use mem; use unstable::intrinsics; use vec::{with_capacity, ImmutableVector, MutableVector}; use unstable::intrinsics::contains_managed; @@ -2071,10 +2071,10 @@ pub mod raw { pub unsafe fn set_len(v: &mut ~[T], new_len: uint) { if contains_managed::() { let repr: **mut Box> = cast::transmute(v); - (**repr).data.fill = new_len * sys::nonzero_size_of::(); + (**repr).data.fill = new_len * mem::nonzero_size_of::(); } else { let repr: **mut Vec<()> = cast::transmute(v); - (**repr).fill = new_len * sys::nonzero_size_of::(); + (**repr).fill = new_len * mem::nonzero_size_of::(); } } @@ -2323,7 +2323,7 @@ macro_rules! iterator { None } else { let old = self.ptr; - self.ptr = if sys::size_of::() == 0 { + self.ptr = if mem::size_of::() == 0 { // purposefully don't use 'ptr.offset' because for // vectors with 0-size elements this would return the // same pointer. @@ -2340,7 +2340,7 @@ macro_rules! iterator { #[inline] fn size_hint(&self) -> (uint, Option) { let diff = (self.end as uint) - (self.ptr as uint); - let exact = diff / sys::nonzero_size_of::(); + let exact = diff / mem::nonzero_size_of::(); (exact, Some(exact)) } } @@ -2357,7 +2357,7 @@ macro_rules! double_ended_iterator { if self.end == self.ptr { None } else { - self.end = if sys::size_of::() == 0 { + self.end = if mem::size_of::() == 0 { // See above for why 'ptr.offset' isn't used cast::transmute(self.end as uint - 1) } else { @@ -2497,7 +2497,7 @@ impl Extendable for ~[A] { #[cfg(test)] mod tests { use option::{None, Option, Some}; - use sys; + use mem; use vec::*; use cmp::*; use prelude::*; @@ -2597,7 +2597,7 @@ mod tests { let v0 : &[Z] = &[]; let v1 : &[Z] = &[[]]; let v2 : &[Z] = &[[], []]; - assert_eq!(sys::size_of::(), 0); + assert_eq!(mem::size_of::(), 0); assert_eq!(v0.len(), 0); assert_eq!(v1.len(), 1); assert_eq!(v2.len(), 2); -- cgit 1.4.1-3-g733a5