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/at_vec.rs | 12 +-- src/libstd/cast.rs | 6 +- src/libstd/cleanup.rs | 4 +- src/libstd/mem.rs | 158 +++++++++++++++++++++++++++++++++++++ src/libstd/num/f32.rs | 6 +- src/libstd/num/f64.rs | 6 +- src/libstd/num/int_macros.rs | 6 +- src/libstd/num/uint.rs | 6 +- src/libstd/num/uint_macros.rs | 6 +- src/libstd/rand/mod.rs | 4 +- src/libstd/reflect.rs | 6 +- src/libstd/rt/context.rs | 2 +- src/libstd/rt/global_heap.rs | 2 +- src/libstd/rt/io/native/process.rs | 4 +- src/libstd/rt/sched.rs | 4 +- src/libstd/rt/test.rs | 2 +- src/libstd/std.rs | 1 + src/libstd/sys.rs | 140 -------------------------------- src/libstd/unstable/sync.rs | 2 +- src/libstd/util.rs | 2 +- src/libstd/vec.rs | 44 +++++------ 21 files changed, 221 insertions(+), 202 deletions(-) create mode 100644 src/libstd/mem.rs (limited to 'src/libstd') diff --git a/src/libstd/at_vec.rs b/src/libstd/at_vec.rs index f6669893170..8607710edc3 100644 --- a/src/libstd/at_vec.rs +++ b/src/libstd/at_vec.rs @@ -14,7 +14,7 @@ use clone::Clone; use container::Container; use iter::Iterator; use option::{Option, Some, None}; -use sys; +use mem; use unstable::raw::Repr; use vec::{ImmutableVector, OwnedVector}; @@ -26,7 +26,7 @@ use vec::{ImmutableVector, OwnedVector}; pub fn capacity(v: @[T]) -> uint { unsafe { let box = v.repr(); - (*box).data.alloc / sys::size_of::() + (*box).data.alloc / mem::size_of::() } } @@ -160,7 +160,7 @@ pub mod raw { use cast::{transmute, transmute_copy}; use libc; use ptr; - use sys; + use mem; use uint; use unstable::intrinsics::{move_val_init, TyDesc}; use unstable::intrinsics; @@ -176,7 +176,7 @@ pub mod raw { #[inline] pub unsafe fn set_len(v: &mut @[T], new_len: uint) { let repr: *mut Box> = cast::transmute_copy(v); - (*repr).data.fill = new_len * sys::size_of::(); + (*repr).data.fill = new_len * mem::size_of::(); } /** @@ -199,7 +199,7 @@ pub mod raw { unsafe fn push_fast(v: &mut @[T], initval: T) { let repr: *mut Box> = cast::transmute_copy(v); let amt = v.len(); - (*repr).data.fill += sys::size_of::(); + (*repr).data.fill += mem::size_of::(); let p = ptr::offset(&(*repr).data.data as *T, amt as int) as *mut T; move_val_init(&mut(*p), initval); } @@ -236,7 +236,7 @@ pub mod raw { unsafe { if n > (**ptr).data.alloc / (*ty).size { let alloc = n * (*ty).size; - let total_size = alloc + sys::size_of::>(); + let total_size = alloc + mem::size_of::>(); if alloc / (*ty).size != n || total_size < alloc { fail2!("vector size is too large: {}", n); } diff --git a/src/libstd/cast.rs b/src/libstd/cast.rs index e028bbeac68..a4f2ee0d09c 100644 --- a/src/libstd/cast.rs +++ b/src/libstd/cast.rs @@ -11,7 +11,7 @@ //! Unsafe casting functions use ptr::RawPtr; -use sys; +use mem; use unstable::intrinsics; /// Casts the value at `src` to U. The two types must have the same length. @@ -21,7 +21,7 @@ pub unsafe fn transmute_copy(src: &T) -> U { let mut dest: U = intrinsics::uninit(); let dest_ptr: *mut u8 = transmute(&mut dest); let src_ptr: *u8 = transmute(src); - intrinsics::memcpy32(dest_ptr, src_ptr, sys::size_of::() as u32); + intrinsics::memcpy32(dest_ptr, src_ptr, mem::size_of::() as u32); dest } @@ -32,7 +32,7 @@ pub unsafe fn transmute_copy(src: &T) -> U { let mut dest: U = intrinsics::uninit(); let dest_ptr: *mut u8 = transmute(&mut dest); let src_ptr: *u8 = transmute(src); - intrinsics::memcpy64(dest_ptr, src_ptr, sys::size_of::() as u64); + intrinsics::memcpy64(dest_ptr, src_ptr, mem::size_of::() as u64); dest } diff --git a/src/libstd/cleanup.rs b/src/libstd/cleanup.rs index 38925621f12..a8c4d9fdca3 100644 --- a/src/libstd/cleanup.rs +++ b/src/libstd/cleanup.rs @@ -68,7 +68,7 @@ fn debug_mem() -> bool { /// Destroys all managed memory (i.e. @ boxes) held by the current task. pub unsafe fn annihilate() { use rt::local_heap::local_free; - use sys; + use mem; use managed; let mut stats = AnnihilateStats { @@ -115,7 +115,7 @@ pub unsafe fn annihilate() { if !uniq { stats.n_bytes_freed += (*((*box).type_desc)).size - + sys::size_of::>(); + + mem::size_of::>(); local_free(box as *i8); } true diff --git a/src/libstd/mem.rs b/src/libstd/mem.rs new file mode 100644 index 00000000000..311bf5f6bc8 --- /dev/null +++ b/src/libstd/mem.rs @@ -0,0 +1,158 @@ +// Copyright 2012 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//! Functions relating to memory layout + +use unstable::intrinsics; + +/// Returns the size of a type +#[inline] +pub fn size_of() -> uint { + unsafe { intrinsics::size_of::() } +} + +/// Returns the size of the type that `_val` points to +#[inline] +pub fn size_of_val(_val: &T) -> uint { + size_of::() +} + +/** + * Returns the size of a type, or 1 if the actual size is zero. + * + * Useful for building structures containing variable-length arrays. + */ +#[inline] +pub fn nonzero_size_of() -> uint { + let s = size_of::(); + if s == 0 { 1 } else { s } +} + +/// Returns the size of the type of the value that `_val` points to +#[inline] +pub fn nonzero_size_of_val(_val: &T) -> uint { + nonzero_size_of::() +} + + +/** + * 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] +pub fn min_align_of() -> uint { + unsafe { intrinsics::min_align_of::() } +} + +/// Returns the ABI-required minimum alignment of the type of the value that +/// `_val` points to +#[inline] +pub fn min_align_of_val(_val: &T) -> uint { + min_align_of::() +} + +/// Returns the preferred alignment of a type +#[inline] +pub fn pref_align_of() -> uint { + unsafe { intrinsics::pref_align_of::() } +} + +/// Returns the preferred alignment of the type of the value that +/// `_val` points to +#[inline] +pub fn pref_align_of_val(_val: &T) -> uint { + pref_align_of::() +} + +#[cfg(test)] +mod tests { + use cast; + use mem::*; + + #[test] + fn size_of_basic() { + assert_eq!(size_of::(), 1u); + assert_eq!(size_of::(), 2u); + assert_eq!(size_of::(), 4u); + assert_eq!(size_of::(), 8u); + } + + #[test] + #[cfg(target_arch = "x86")] + #[cfg(target_arch = "arm")] + #[cfg(target_arch = "mips")] + fn size_of_32() { + assert_eq!(size_of::(), 4u); + assert_eq!(size_of::<*uint>(), 4u); + } + + #[test] + #[cfg(target_arch = "x86_64")] + fn size_of_64() { + assert_eq!(size_of::(), 8u); + assert_eq!(size_of::<*uint>(), 8u); + } + + #[test] + fn size_of_val_basic() { + assert_eq!(size_of_val(&1u8), 1); + assert_eq!(size_of_val(&1u16), 2); + assert_eq!(size_of_val(&1u32), 4); + assert_eq!(size_of_val(&1u64), 8); + } + + #[test] + fn nonzero_size_of_basic() { + type Z = [i8, ..0]; + assert_eq!(size_of::(), 0u); + assert_eq!(nonzero_size_of::(), 1u); + assert_eq!(nonzero_size_of::(), size_of::()); + } + + #[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::(), 1u); + assert_eq!(pref_align_of::(), 2u); + assert_eq!(pref_align_of::(), 4u); + } + + #[test] + #[cfg(target_arch = "x86")] + #[cfg(target_arch = "arm")] + #[cfg(target_arch = "mips")] + fn align_of_32() { + assert_eq!(pref_align_of::(), 4u); + assert_eq!(pref_align_of::<*uint>(), 4u); + } + + #[test] + #[cfg(target_arch = "x86_64")] + fn align_of_64() { + assert_eq!(pref_align_of::(), 8u); + assert_eq!(pref_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); + } +} diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs index 2b4a636e1ad..e99dcd6b2eb 100644 --- a/src/libstd/num/f32.rs +++ b/src/libstd/num/f32.rs @@ -928,7 +928,7 @@ mod tests { use num::*; use num; - use sys; + use mem; #[test] fn test_num() { @@ -1198,8 +1198,8 @@ mod tests { #[test] fn test_primitive() { let none: Option = None; - assert_eq!(Primitive::bits(none), sys::size_of::() * 8); - assert_eq!(Primitive::bytes(none), sys::size_of::()); + assert_eq!(Primitive::bits(none), mem::size_of::() * 8); + assert_eq!(Primitive::bytes(none), mem::size_of::()); } #[test] diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs index d4442e5b34f..f367de376d4 100644 --- a/src/libstd/num/f64.rs +++ b/src/libstd/num/f64.rs @@ -976,7 +976,7 @@ mod tests { use num::*; use num; - use sys; + use mem; #[test] fn test_num() { @@ -1249,8 +1249,8 @@ mod tests { #[test] fn test_primitive() { let none: Option = None; - assert_eq!(Primitive::bits(none), sys::size_of::() * 8); - assert_eq!(Primitive::bytes(none), sys::size_of::()); + assert_eq!(Primitive::bits(none), mem::size_of::() * 8); + assert_eq!(Primitive::bytes(none), mem::size_of::()); } #[test] diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs index 7fae567809b..694e5e7f6bf 100644 --- a/src/libstd/num/int_macros.rs +++ b/src/libstd/num/int_macros.rs @@ -456,7 +456,7 @@ mod tests { use int; use i32; use num; - use sys; + use mem; #[test] fn test_num() { @@ -653,8 +653,8 @@ mod tests { #[test] fn test_primitive() { let none: Option<$T> = None; - assert_eq!(Primitive::bits(none), sys::size_of::<$T>() * 8); - assert_eq!(Primitive::bytes(none), sys::size_of::<$T>()); + assert_eq!(Primitive::bits(none), mem::size_of::<$T>() * 8); + assert_eq!(Primitive::bytes(none), mem::size_of::<$T>()); } #[test] diff --git a/src/libstd/num/uint.rs b/src/libstd/num/uint.rs index 38a4df270fc..2ecbb79407e 100644 --- a/src/libstd/num/uint.rs +++ b/src/libstd/num/uint.rs @@ -14,7 +14,7 @@ use num; use num::{CheckedAdd, CheckedSub, CheckedMul}; use option::{Option, Some, None}; use unstable::intrinsics; -use sys; +use mem; pub use self::generated::*; @@ -97,7 +97,7 @@ impl num::Times for uint { /// Returns the smallest power of 2 greater than or equal to `n` #[inline] pub fn next_power_of_two(n: uint) -> uint { - let halfbits: uint = sys::size_of::() * 4u; + let halfbits: uint = mem::size_of::() * 4u; let mut tmp: uint = n - 1u; let mut shift: uint = 1u; while shift <= halfbits { tmp |= tmp >> shift; shift <<= 1u; } @@ -107,7 +107,7 @@ pub fn next_power_of_two(n: uint) -> uint { /// Returns the smallest power of 2 greater than or equal to `n` #[inline] pub fn next_power_of_two_opt(n: uint) -> Option { - let halfbits: uint = sys::size_of::() * 4u; + let halfbits: uint = mem::size_of::() * 4u; let mut tmp: uint = n - 1u; let mut shift: uint = 1u; while shift <= halfbits { tmp |= tmp >> shift; shift <<= 1u; } diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs index f52feced67c..2974b402d4a 100644 --- a/src/libstd/num/uint_macros.rs +++ b/src/libstd/num/uint_macros.rs @@ -337,7 +337,7 @@ mod tests { use super::*; use num; - use sys; + use mem; use u16; #[test] @@ -431,8 +431,8 @@ mod tests { #[test] fn test_primitive() { let none: Option<$T> = None; - assert_eq!(Primitive::bits(none), sys::size_of::<$T>() * 8); - assert_eq!(Primitive::bytes(none), sys::size_of::<$T>()); + assert_eq!(Primitive::bits(none), mem::size_of::<$T>() * 8); + assert_eq!(Primitive::bytes(none), mem::size_of::<$T>()); } #[test] diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs index 1e76effd0d2..954db42c89b 100644 --- a/src/libstd/rand/mod.rs +++ b/src/libstd/rand/mod.rs @@ -52,7 +52,7 @@ fn main () { ``` */ -use sys::size_of; +use mem::size_of; use unstable::raw::Slice; use cast; use container::Container; @@ -952,7 +952,7 @@ mod test { mod bench { use extra::test::BenchHarness; use rand::*; - use sys::size_of; + use mem::size_of; #[bench] fn rand_xorshift(bh: &mut BenchHarness) { diff --git a/src/libstd/reflect.rs b/src/libstd/reflect.rs index 292330de7b5..1cd76727716 100644 --- a/src/libstd/reflect.rs +++ b/src/libstd/reflect.rs @@ -18,7 +18,7 @@ Runtime type reflection use unstable::intrinsics::{Opaque, TyDesc, TyVisitor}; use libc::c_void; -use sys; +use mem; use unstable::raw; /** @@ -64,12 +64,12 @@ impl MovePtrAdaptor { #[inline] pub fn align_to(&mut self) { - self.align(sys::min_align_of::()); + self.align(mem::min_align_of::()); } #[inline] pub fn bump_past(&mut self) { - self.bump(sys::size_of::()); + self.bump(mem::size_of::()); } } diff --git a/src/libstd/rt/context.rs b/src/libstd/rt/context.rs index 853cc08a0ba..222f9a44b17 100644 --- a/src/libstd/rt/context.rs +++ b/src/libstd/rt/context.rs @@ -233,6 +233,6 @@ fn align_down(sp: *mut uint) -> *mut uint { // ptr::mut_offset is positive ints only #[inline] pub fn mut_offset(ptr: *mut T, count: int) -> *mut T { - use std::sys::size_of; + use mem::size_of; (ptr as int + count * (size_of::() as int)) as *mut T } diff --git a/src/libstd/rt/global_heap.rs b/src/libstd/rt/global_heap.rs index 7d3f5f91774..446efbd9047 100644 --- a/src/libstd/rt/global_heap.rs +++ b/src/libstd/rt/global_heap.rs @@ -11,7 +11,7 @@ use libc::{c_void, c_char, size_t, uintptr_t, free, malloc, realloc}; use unstable::intrinsics::TyDesc; use unstable::raw; -use sys::size_of; +use mem::size_of; extern { #[rust_stack] diff --git a/src/libstd/rt/io/native/process.rs b/src/libstd/rt/io/native/process.rs index d338192c664..57367beacd8 100644 --- a/src/libstd/rt/io/native/process.rs +++ b/src/libstd/rt/io/native/process.rs @@ -271,12 +271,12 @@ fn spawn_process_os(prog: &str, args: &[~str], }; use libc::funcs::extra::msvcrt::get_osfhandle; - use sys; + use mem; unsafe { let mut si = zeroed_startupinfo(); - si.cb = sys::size_of::() as DWORD; + si.cb = mem::size_of::() as DWORD; si.dwFlags = STARTF_USESTDHANDLES; let cur_proc = GetCurrentProcess(); diff --git a/src/libstd/rt/sched.rs b/src/libstd/rt/sched.rs index 0a4622bc65e..7724f58153e 100644 --- a/src/libstd/rt/sched.rs +++ b/src/libstd/rt/sched.rs @@ -857,7 +857,7 @@ fn new_sched_rng() -> XorShiftRng { #[fixed_stack_segment] #[inline(never)] fn new_sched_rng() -> XorShiftRng { use libc; - use sys; + use mem; use c_str::ToCStr; use vec::MutableVector; use iter::Iterator; @@ -871,7 +871,7 @@ fn new_sched_rng() -> XorShiftRng { } let mut seeds = [0u32, .. 4]; - let size = sys::size_of_val(&seeds); + let size = mem::size_of_val(&seeds); loop { let nbytes = do seeds.as_mut_buf |buf, _| { unsafe { diff --git a/src/libstd/rt/test.rs b/src/libstd/rt/test.rs index 1178bfdaa80..9f4e6558ac5 100644 --- a/src/libstd/rt/test.rs +++ b/src/libstd/rt/test.rs @@ -103,7 +103,7 @@ mod darwin_fd_limit { // The strategy here is to fetch the current resource limits, read the kern.maxfilesperproc // sysctl value, and bump the soft resource limit for maxfiles up to the sysctl value. use ptr::{to_unsafe_ptr, to_mut_unsafe_ptr, mut_null}; - use sys::size_of_val; + use mem::size_of_val; use os::last_os_error; // Fetch the kern.maxfilesperproc value diff --git a/src/libstd/std.rs b/src/libstd/std.rs index 73cb6a5645d..c446fe3d94f 100644 --- a/src/libstd/std.rs +++ b/src/libstd/std.rs @@ -189,6 +189,7 @@ pub mod condition; pub mod logging; pub mod util; pub mod routine; +pub mod mem; /* Unsupported interfaces */ diff --git a/src/libstd/sys.rs b/src/libstd/sys.rs index 10c3fed1d54..0299ca0b49a 100644 --- a/src/libstd/sys.rs +++ b/src/libstd/sys.rs @@ -19,68 +19,6 @@ use libc; use repr; use rt::task; use str; -use unstable::intrinsics; - -/// Returns the size of a type -#[inline] -pub fn size_of() -> uint { - unsafe { intrinsics::size_of::() } -} - -/// Returns the size of the type that `_val` points to -#[inline] -pub fn size_of_val(_val: &T) -> uint { - size_of::() -} - -/** - * Returns the size of a type, or 1 if the actual size is zero. - * - * Useful for building structures containing variable-length arrays. - */ -#[inline] -pub fn nonzero_size_of() -> uint { - let s = size_of::(); - if s == 0 { 1 } else { s } -} - -/// Returns the size of the type of the value that `_val` points to -#[inline] -pub fn nonzero_size_of_val(_val: &T) -> uint { - nonzero_size_of::() -} - - -/** - * 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] -pub fn min_align_of() -> uint { - unsafe { intrinsics::min_align_of::() } -} - -/// Returns the ABI-required minimum alignment of the type of the value that -/// `_val` points to -#[inline] -pub fn min_align_of_val(_val: &T) -> uint { - min_align_of::() -} - -/// Returns the preferred alignment of a type -#[inline] -pub fn pref_align_of() -> uint { - unsafe { intrinsics::pref_align_of::() } -} - -/// Returns the preferred alignment of the type of the value that -/// `_val` points to -#[inline] -pub fn pref_align_of_val(_val: &T) -> uint { - pref_align_of::() -} /// Returns the refcount of a shared box (as just before calling this) #[inline] @@ -131,84 +69,6 @@ mod tests { use cast; use sys::*; - #[test] - fn size_of_basic() { - assert_eq!(size_of::(), 1u); - assert_eq!(size_of::(), 2u); - assert_eq!(size_of::(), 4u); - assert_eq!(size_of::(), 8u); - } - - #[test] - #[cfg(target_arch = "x86")] - #[cfg(target_arch = "arm")] - #[cfg(target_arch = "mips")] - fn size_of_32() { - assert_eq!(size_of::(), 4u); - assert_eq!(size_of::<*uint>(), 4u); - } - - #[test] - #[cfg(target_arch = "x86_64")] - fn size_of_64() { - assert_eq!(size_of::(), 8u); - assert_eq!(size_of::<*uint>(), 8u); - } - - #[test] - fn size_of_val_basic() { - assert_eq!(size_of_val(&1u8), 1); - assert_eq!(size_of_val(&1u16), 2); - assert_eq!(size_of_val(&1u32), 4); - assert_eq!(size_of_val(&1u64), 8); - } - - #[test] - fn nonzero_size_of_basic() { - type Z = [i8, ..0]; - assert_eq!(size_of::(), 0u); - assert_eq!(nonzero_size_of::(), 1u); - assert_eq!(nonzero_size_of::(), size_of::()); - } - - #[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::(), 1u); - assert_eq!(pref_align_of::(), 2u); - assert_eq!(pref_align_of::(), 4u); - } - - #[test] - #[cfg(target_arch = "x86")] - #[cfg(target_arch = "arm")] - #[cfg(target_arch = "mips")] - fn align_of_32() { - assert_eq!(pref_align_of::(), 4u); - assert_eq!(pref_align_of::<*uint>(), 4u); - } - - #[test] - #[cfg(target_arch = "x86_64")] - fn align_of_64() { - assert_eq!(pref_align_of::(), 8u); - assert_eq!(pref_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); - } - #[test] fn synthesize_closure() { use unstable::raw::Closure; diff --git a/src/libstd/unstable/sync.rs b/src/libstd/unstable/sync.rs index f3945d8f3c9..0b28497e640 100644 --- a/src/libstd/unstable/sync.rs +++ b/src/libstd/unstable/sync.rs @@ -425,7 +425,7 @@ mod tests { use super::{Exclusive, UnsafeArc, atomically}; use task; use util; - use sys::size_of; + use mem::size_of; //#[unsafe_no_drop_flag] FIXME: #9758 #[ignore] diff --git a/src/libstd/util.rs b/src/libstd/util.rs index 44cfdb86057..3e44a30e47b 100644 --- a/src/libstd/util.rs +++ b/src/libstd/util.rs @@ -93,7 +93,7 @@ mod tests { use ops::Drop; use option::{None, Some}; use either::{Either, Left, Right}; - use sys::size_of; + use mem::size_of; #[test] fn identity_crisis() { 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