"The type parameters can also be explicitly supplied in a trailing [path]"
"(#paths) component after the function name. This might be necessary if there "
"is not sufficient context to determine the type parameters. For example, "
-"`sys::size_of::<u32>() == 4`."
+"`mem::size_of::<u32>() == 4`."
msgstr ""
#. type: Plain text
"impl<T: Send> Unique<T> {\n"
" pub fn new(value: T) -> Unique<T> {\n"
" unsafe {\n"
-" let ptr = malloc(std::sys::size_of::<T>() as size_t) as *mut T;\n"
+" let ptr = malloc(std::mem::size_of::<T>() as size_t) as *mut T;\n"
" assert!(!ptr::is_null(ptr));\n"
" // `*ptr` is uninitialized, and `*ptr = value` would attempt to destroy it\n"
" intrinsics::move_val_init(&mut *ptr, value);\n"
"The type parameters can also be explicitly supplied in a trailing [path]"
"(#paths) component after the function name. This might be necessary if there "
"is not sufficient context to determine the type parameters. For example, "
-"`sys::size_of::<u32>() == 4`."
+"`mem::size_of::<u32>() == 4`."
msgstr ""
#. type: Plain text
"impl<T: Send> Unique<T> {\n"
" pub fn new(value: T) -> Unique<T> {\n"
" unsafe {\n"
-" let ptr = malloc(std::sys::size_of::<T>() as size_t) as *mut T;\n"
+" let ptr = malloc(std::mem::size_of::<T>() as size_t) as *mut T;\n"
" assert!(!ptr::is_null(ptr));\n"
" // `*ptr` is uninitialized, and `*ptr = value` would attempt to destroy it\n"
" intrinsics::move_val_init(&mut *ptr, value);\n"
The type parameters can also be explicitly supplied in a trailing
[path](#paths) component after the function name. This might be necessary
if there is not sufficient context to determine the type parameters. For
-example, `sys::size_of::<u32>() == 4`.
+example, `mem::size_of::<u32>() == 4`.
Since a parameter type is opaque to the generic function, the set of
operations that can be performed on it is limited. Values of parameter
#[inline(never)];
unsafe {
- let ptr = malloc(std::sys::size_of::<T>() as size_t) as *mut T;
+ let ptr = malloc(std::mem::size_of::<T>() as size_t) as *mut T;
assert!(!ptr::is_null(ptr));
// `*ptr` is uninitialized, and `*ptr = value` would attempt to destroy it
intrinsics::move_val_init(&mut *ptr, value);
use std::cast;
use std::num;
use std::ptr;
-use std::sys;
+use std::mem;
use std::uint;
use std::vec;
use std::unstable::intrinsics;
let (tydesc, is_done) = un_bitpack_tydesc_ptr(*tydesc_data);
let (size, align) = ((*tydesc).size, (*tydesc).align);
- let after_tydesc = idx + sys::size_of::<*TyDesc>();
+ let after_tydesc = idx + mem::size_of::<*TyDesc>();
let start = round_up_to(after_tydesc, align);
}
// Find where the next tydesc lives
- idx = round_up_to(start + size, sys::pref_align_of::<*TyDesc>());
+ idx = round_up_to(start + size, mem::pref_align_of::<*TyDesc>());
}
}
let head = transmute_mut_region(&mut self.head);
tydesc_start = head.fill;
- after_tydesc = head.fill + sys::size_of::<*TyDesc>();
+ after_tydesc = head.fill + mem::size_of::<*TyDesc>();
start = round_up_to(after_tydesc, align);
end = start + n_bytes;
}
}
let head = transmute_mut_region(&mut self.head);
- head.fill = round_up_to(end, sys::pref_align_of::<*TyDesc>());
+ head.fill = round_up_to(end, mem::pref_align_of::<*TyDesc>());
//debug2!("idx = {}, size = {}, align = {}, fill = {}",
// start, n_bytes, align, head.fill);
use container::Container;
use iter::Iterator;
use option::{Option, Some, None};
-use sys;
+use mem;
use unstable::raw::Repr;
use vec::{ImmutableVector, OwnedVector};
pub fn capacity<T>(v: @[T]) -> uint {
unsafe {
let box = v.repr();
- (*box).data.alloc / sys::size_of::<T>()
+ (*box).data.alloc / mem::size_of::<T>()
}
}
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;
#[inline]
pub unsafe fn set_len<T>(v: &mut @[T], new_len: uint) {
let repr: *mut Box<Vec<T>> = cast::transmute_copy(v);
- (*repr).data.fill = new_len * sys::size_of::<T>();
+ (*repr).data.fill = new_len * mem::size_of::<T>();
}
/**
unsafe fn push_fast<T>(v: &mut @[T], initval: T) {
let repr: *mut Box<Vec<T>> = cast::transmute_copy(v);
let amt = v.len();
- (*repr).data.fill += sys::size_of::<T>();
+ (*repr).data.fill += mem::size_of::<T>();
let p = ptr::offset(&(*repr).data.data as *T, amt as int) as *mut T;
move_val_init(&mut(*p), initval);
}
unsafe {
if n > (**ptr).data.alloc / (*ty).size {
let alloc = n * (*ty).size;
- let total_size = alloc + sys::size_of::<Vec<()>>();
+ let total_size = alloc + mem::size_of::<Vec<()>>();
if alloc / (*ty).size != n || total_size < alloc {
fail2!("vector size is too large: {}", n);
}
//! 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.
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::<U>() as u32);
+ intrinsics::memcpy32(dest_ptr, src_ptr, mem::size_of::<U>() as u32);
dest
}
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::<U>() as u64);
+ intrinsics::memcpy64(dest_ptr, src_ptr, mem::size_of::<U>() as u64);
dest
}
/// 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 {
if !uniq {
stats.n_bytes_freed +=
(*((*box).type_desc)).size
- + sys::size_of::<raw::Box<()>>();
+ + mem::size_of::<raw::Box<()>>();
local_free(box as *i8);
}
true
--- /dev/null
+// 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 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, 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<T>() -> uint {
+ unsafe { intrinsics::size_of::<T>() }
+}
+
+/// Returns the size of the type that `_val` points to
+#[inline]
+pub fn size_of_val<T>(_val: &T) -> uint {
+ size_of::<T>()
+}
+
+/**
+ * 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<T>() -> uint {
+ let s = size_of::<T>();
+ 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<T>(_val: &T) -> uint {
+ nonzero_size_of::<T>()
+}
+
+
+/**
+ * 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<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]
+pub fn min_align_of_val<T>(_val: &T) -> uint {
+ min_align_of::<T>()
+}
+
+/// Returns the preferred alignment of a type
+#[inline]
+pub fn pref_align_of<T>() -> uint {
+ unsafe { intrinsics::pref_align_of::<T>() }
+}
+
+/// Returns the preferred alignment of the type of the value that
+/// `_val` points to
+#[inline]
+pub fn pref_align_of_val<T>(_val: &T) -> uint {
+ pref_align_of::<T>()
+}
+
+#[cfg(test)]
+mod tests {
+ use cast;
+ use mem::*;
+
+ #[test]
+ fn size_of_basic() {
+ assert_eq!(size_of::<u8>(), 1u);
+ assert_eq!(size_of::<u16>(), 2u);
+ assert_eq!(size_of::<u32>(), 4u);
+ assert_eq!(size_of::<u64>(), 8u);
+ }
+
+ #[test]
+ #[cfg(target_arch = "x86")]
+ #[cfg(target_arch = "arm")]
+ #[cfg(target_arch = "mips")]
+ fn size_of_32() {
+ assert_eq!(size_of::<uint>(), 4u);
+ assert_eq!(size_of::<*uint>(), 4u);
+ }
+
+ #[test]
+ #[cfg(target_arch = "x86_64")]
+ fn size_of_64() {
+ assert_eq!(size_of::<uint>(), 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::<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);
+ }
+
+ #[test]
+ #[cfg(target_arch = "x86")]
+ #[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);
+ }
+
+ #[test]
+ #[cfg(target_arch = "x86_64")]
+ fn align_of_64() {
+ assert_eq!(pref_align_of::<uint>(), 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);
+ }
+}
use num::*;
use num;
- use sys;
+ use mem;
#[test]
fn test_num() {
#[test]
fn test_primitive() {
let none: Option<f32> = None;
- assert_eq!(Primitive::bits(none), sys::size_of::<f32>() * 8);
- assert_eq!(Primitive::bytes(none), sys::size_of::<f32>());
+ assert_eq!(Primitive::bits(none), mem::size_of::<f32>() * 8);
+ assert_eq!(Primitive::bytes(none), mem::size_of::<f32>());
}
#[test]
use num::*;
use num;
- use sys;
+ use mem;
#[test]
fn test_num() {
#[test]
fn test_primitive() {
let none: Option<f64> = None;
- assert_eq!(Primitive::bits(none), sys::size_of::<f64>() * 8);
- assert_eq!(Primitive::bytes(none), sys::size_of::<f64>());
+ assert_eq!(Primitive::bits(none), mem::size_of::<f64>() * 8);
+ assert_eq!(Primitive::bytes(none), mem::size_of::<f64>());
}
#[test]
use int;
use i32;
use num;
- use sys;
+ use mem;
#[test]
fn test_num() {
#[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]
use num::{CheckedAdd, CheckedSub, CheckedMul};
use option::{Option, Some, None};
use unstable::intrinsics;
-use sys;
+use mem;
pub use self::generated::*;
/// 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::<uint>() * 4u;
+ let halfbits: uint = mem::size_of::<uint>() * 4u;
let mut tmp: uint = n - 1u;
let mut shift: uint = 1u;
while shift <= halfbits { tmp |= tmp >> shift; shift <<= 1u; }
/// Returns the smallest power of 2 greater than or equal to `n`
#[inline]
pub fn next_power_of_two_opt(n: uint) -> Option<uint> {
- let halfbits: uint = sys::size_of::<uint>() * 4u;
+ let halfbits: uint = mem::size_of::<uint>() * 4u;
let mut tmp: uint = n - 1u;
let mut shift: uint = 1u;
while shift <= halfbits { tmp |= tmp >> shift; shift <<= 1u; }
use super::*;
use num;
- use sys;
+ use mem;
use u16;
#[test]
#[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]
```
*/
-use sys::size_of;
+use mem::size_of;
use unstable::raw::Slice;
use cast;
use container::Container;
mod bench {
use extra::test::BenchHarness;
use rand::*;
- use sys::size_of;
+ use mem::size_of;
#[bench]
fn rand_xorshift(bh: &mut BenchHarness) {
use unstable::intrinsics::{Opaque, TyDesc, TyVisitor};
use libc::c_void;
-use sys;
+use mem;
use unstable::raw;
/**
#[inline]
pub fn align_to<T>(&mut self) {
- self.align(sys::min_align_of::<T>());
+ self.align(mem::min_align_of::<T>());
}
#[inline]
pub fn bump_past<T>(&mut self) {
- self.bump(sys::size_of::<T>());
+ self.bump(mem::size_of::<T>());
}
}
// ptr::mut_offset is positive ints only
#[inline]
pub fn mut_offset<T>(ptr: *mut T, count: int) -> *mut T {
- use std::sys::size_of;
+ use mem::size_of;
(ptr as int + count * (size_of::<T>() as int)) as *mut T
}
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]
};
use libc::funcs::extra::msvcrt::get_osfhandle;
- use sys;
+ use mem;
unsafe {
let mut si = zeroed_startupinfo();
- si.cb = sys::size_of::<STARTUPINFO>() as DWORD;
+ si.cb = mem::size_of::<STARTUPINFO>() as DWORD;
si.dwFlags = STARTF_USESTDHANDLES;
let cur_proc = GetCurrentProcess();
#[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;
}
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 {
// 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
pub mod logging;
pub mod util;
pub mod routine;
+pub mod mem;
/* Unsupported interfaces */
use repr;
use rt::task;
use str;
-use unstable::intrinsics;
-
-/// Returns the size of a type
-#[inline]
-pub fn size_of<T>() -> uint {
- unsafe { intrinsics::size_of::<T>() }
-}
-
-/// Returns the size of the type that `_val` points to
-#[inline]
-pub fn size_of_val<T>(_val: &T) -> uint {
- size_of::<T>()
-}
-
-/**
- * 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<T>() -> uint {
- let s = size_of::<T>();
- 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<T>(_val: &T) -> uint {
- nonzero_size_of::<T>()
-}
-
-
-/**
- * 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<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]
-pub fn min_align_of_val<T>(_val: &T) -> uint {
- min_align_of::<T>()
-}
-
-/// Returns the preferred alignment of a type
-#[inline]
-pub fn pref_align_of<T>() -> uint {
- unsafe { intrinsics::pref_align_of::<T>() }
-}
-
-/// Returns the preferred alignment of the type of the value that
-/// `_val` points to
-#[inline]
-pub fn pref_align_of_val<T>(_val: &T) -> uint {
- pref_align_of::<T>()
-}
/// Returns the refcount of a shared box (as just before calling this)
#[inline]
use cast;
use sys::*;
- #[test]
- fn size_of_basic() {
- assert_eq!(size_of::<u8>(), 1u);
- assert_eq!(size_of::<u16>(), 2u);
- assert_eq!(size_of::<u32>(), 4u);
- assert_eq!(size_of::<u64>(), 8u);
- }
-
- #[test]
- #[cfg(target_arch = "x86")]
- #[cfg(target_arch = "arm")]
- #[cfg(target_arch = "mips")]
- fn size_of_32() {
- assert_eq!(size_of::<uint>(), 4u);
- assert_eq!(size_of::<*uint>(), 4u);
- }
-
- #[test]
- #[cfg(target_arch = "x86_64")]
- fn size_of_64() {
- assert_eq!(size_of::<uint>(), 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::<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);
- }
-
- #[test]
- #[cfg(target_arch = "x86")]
- #[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);
- }
-
- #[test]
- #[cfg(target_arch = "x86_64")]
- fn align_of_64() {
- assert_eq!(pref_align_of::<uint>(), 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;
use super::{Exclusive, UnsafeArc, atomically};
use task;
use util;
- use sys::size_of;
+ use mem::size_of;
//#[unsafe_no_drop_flag] FIXME: #9758
#[ignore]
use ops::Drop;
use option::{None, Some};
use either::{Either, Left, Right};
- use sys::size_of;
+ use mem::size_of;
#[test]
fn identity_crisis() {
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;
vec.reserve(capacity);
vec
} else {
- let alloc = capacity * sys::nonzero_size_of::<T>();
- let ptr = malloc_raw(alloc + sys::size_of::<Vec<()>>()) as *mut Vec<()>;
+ let alloc = capacity * mem::nonzero_size_of::<T>();
+ let ptr = malloc_raw(alloc + mem::size_of::<Vec<()>>()) as *mut Vec<()>;
(*ptr).alloc = alloc;
(*ptr).fill = 0;
cast::transmute(ptr)
fn iter(self) -> VecIterator<'self, T> {
unsafe {
let p = vec::raw::to_ptr(self);
- if sys::size_of::<T>() == 0 {
+ if mem::size_of::<T>() == 0 {
VecIterator{ptr: p,
end: (p as uint + self.len()) as *T,
lifetime: None}
::at_vec::raw::reserve_raw(td, ptr, n);
} else {
let ptr: *mut *mut Vec<()> = cast::transmute(self);
- let alloc = n * sys::nonzero_size_of::<T>();
- let size = alloc + sys::size_of::<Vec<()>>();
- if alloc / sys::nonzero_size_of::<T>() != n || size < alloc {
+ let alloc = n * mem::nonzero_size_of::<T>();
+ let size = alloc + mem::size_of::<Vec<()>>();
+ if alloc / mem::nonzero_size_of::<T>() != n || size < alloc {
fail2!("vector size is too large: {}", n);
}
*ptr = realloc_raw(*ptr as *mut c_void, size)
unsafe {
if contains_managed::<T>() {
let repr: **Box<Vec<()>> = cast::transmute(self);
- (**repr).data.alloc / sys::nonzero_size_of::<T>()
+ (**repr).data.alloc / mem::nonzero_size_of::<T>()
} else {
let repr: **Vec<()> = cast::transmute(self);
- (**repr).alloc / sys::nonzero_size_of::<T>()
+ (**repr).alloc / mem::nonzero_size_of::<T>()
}
}
}
unsafe {
let ptr: *mut *mut Vec<()> = cast::transmute(self);
let alloc = (**ptr).fill;
- let size = alloc + sys::size_of::<Vec<()>>();
+ let size = alloc + mem::size_of::<Vec<()>>();
*ptr = realloc_raw(*ptr as *mut c_void, size) as *mut Vec<()>;
(**ptr).alloc = alloc;
}
if contains_managed::<T>() {
let repr: **mut Box<Vec<u8>> = cast::transmute(this);
let fill = (**repr).data.fill;
- (**repr).data.fill += sys::nonzero_size_of::<T>();
+ (**repr).data.fill += mem::nonzero_size_of::<T>();
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<u8> = cast::transmute(this);
let fill = (**repr).fill;
- (**repr).fill += sys::nonzero_size_of::<T>();
+ (**repr).fill += mem::nonzero_size_of::<T>();
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);
fn mut_iter(self) -> VecMutIterator<'self, T> {
unsafe {
let p = vec::raw::to_mut_ptr(self);
- if sys::size_of::<T>() == 0 {
+ if mem::size_of::<T>() == 0 {
VecMutIterator{ptr: p,
end: (p as uint + self.len()) as *mut T,
lifetime: None}
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;
pub unsafe fn set_len<T>(v: &mut ~[T], new_len: uint) {
if contains_managed::<T>() {
let repr: **mut Box<Vec<()>> = cast::transmute(v);
- (**repr).data.fill = new_len * sys::nonzero_size_of::<T>();
+ (**repr).data.fill = new_len * mem::nonzero_size_of::<T>();
} else {
let repr: **mut Vec<()> = cast::transmute(v);
- (**repr).fill = new_len * sys::nonzero_size_of::<T>();
+ (**repr).fill = new_len * mem::nonzero_size_of::<T>();
}
}
None
} else {
let old = self.ptr;
- self.ptr = if sys::size_of::<T>() == 0 {
+ self.ptr = if mem::size_of::<T>() == 0 {
// purposefully don't use 'ptr.offset' because for
// vectors with 0-size elements this would return the
// same pointer.
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) {
let diff = (self.end as uint) - (self.ptr as uint);
- let exact = diff / sys::nonzero_size_of::<T>();
+ let exact = diff / mem::nonzero_size_of::<T>();
(exact, Some(exact))
}
}
if self.end == self.ptr {
None
} else {
- self.end = if sys::size_of::<T>() == 0 {
+ self.end = if mem::size_of::<T>() == 0 {
// See above for why 'ptr.offset' isn't used
cast::transmute(self.end as uint - 1)
} else {
#[cfg(test)]
mod tests {
use option::{None, Option, Some};
- use sys;
+ use mem;
use vec::*;
use cmp::*;
use prelude::*;
let v0 : &[Z] = &[];
let v1 : &[Z] = &[[]];
let v2 : &[Z] = &[[], []];
- assert_eq!(sys::size_of::<Z>(), 0);
+ assert_eq!(mem::size_of::<Z>(), 0);
assert_eq!(v0.len(), 0);
assert_eq!(v1.len(), 1);
assert_eq!(v2.len(), 2);
// error-pattern:index out of bounds: the len is 3 but the index is
use std::uint::max_value;
-use std::sys::size_of;
+use std::mem::size_of;
fn main() {
let xs = [1, 2, 3];
// error-pattern:index out of bounds
-use std::sys;
+use std::mem;
fn main() {
let x = ~[1u,2u,3u];
do x.as_imm_buf |p, _len| {
let base = p as uint;
- let idx = base / sys::size_of::<uint>();
+ let idx = base / mem::size_of::<uint>();
error2!("ov1 base = 0x{:x}", base);
error2!("ov1 idx = 0x{:x}", idx);
- error2!("ov1 sizeof::<uint>() = 0x{:x}", sys::size_of::<uint>());
+ error2!("ov1 sizeof::<uint>() = 0x{:x}", mem::size_of::<uint>());
error2!("ov1 idx * sizeof::<uint>() = 0x{:x}",
- idx * sys::size_of::<uint>());
+ idx * mem::size_of::<uint>());
// This should fail.
error2!("ov1 0x{:x}", x[idx]);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::sys::size_of;
+use std::mem::size_of;
#[unsafe_no_drop_flag]
struct Test<T> {
use std::cast;
use std::ptr;
-use std::sys;
+use std::mem;
fn addr_of<T>(ptr: &T) -> uint {
let ptr = ptr::to_unsafe_ptr(ptr);
fn is_aligned<T>(ptr: &T) -> bool {
unsafe {
let addr: uint = cast::transmute(ptr);
- (addr % sys::min_align_of::<T>()) == 0
+ (addr % mem::min_align_of::<T>()) == 0
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::sys;
+use std::mem;
pub fn main() {
enum E { V = 0x1717171717171717 }
static C: E = V;
- let expected: u64 = if sys::size_of::<uint>() < 8 {
+ let expected: u64 = if mem::size_of::<uint>() < 8 {
0x17171717
} else {
0x1717171717171717
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::sys;
+use std::mem;
pub fn main() {
// Bare functions should just be a pointer
- assert_eq!(sys::size_of::<extern "Rust" fn()>(), sys::size_of::<int>());
+ assert_eq!(mem::size_of::<extern "Rust" fn()>(), mem::size_of::<int>());
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::sys;
+use std::mem;
struct Cat {
x: int
#[cfg(target_arch = "x86_64")]
pub fn main() {
- assert_eq!(sys::size_of::<Cat>(), 8 as uint);
- assert_eq!(sys::size_of::<Kitty>(), 16 as uint);
+ assert_eq!(mem::size_of::<Cat>(), 8 as uint);
+ assert_eq!(mem::size_of::<Kitty>(), 16 as uint);
}
#[cfg(target_arch = "x86")]
#[cfg(target_arch = "arm")]
pub fn main() {
- assert_eq!(sys::size_of::<Cat>(), 4 as uint);
- assert_eq!(sys::size_of::<Kitty>(), 8 as uint);
+ assert_eq!(mem::size_of::<Cat>(), 4 as uint);
+ assert_eq!(mem::size_of::<Kitty>(), 8 as uint);
}
#[feature(macro_rules)];
-use std::sys;
+use std::mem;
enum E<T> { Thing(int, T), Nothing((), ((), ()), [i8, ..0]) }
struct S<T>(int, T);
macro_rules! check_option {
($T:ty) => {
- assert_eq!(sys::size_of::<Option<$T>>(), sys::size_of::<$T>());
+ assert_eq!(mem::size_of::<Option<$T>>(), mem::size_of::<$T>());
}
}
macro_rules! check_fancy {
($T:ty) => {
- assert_eq!(sys::size_of::<E<$T>>(), sys::size_of::<S<$T>>());
+ assert_eq!(mem::size_of::<E<$T>>(), mem::size_of::<S<$T>>());
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::sys;
+use std::mem;
#[packed]
struct S<T, S> {
}
pub fn main() {
- assert_eq!(sys::size_of::<S<u8, u8>>(), 3);
+ assert_eq!(mem::size_of::<S<u8, u8>>(), 3);
- assert_eq!(sys::size_of::<S<u64, u16>>(), 11);
+ assert_eq!(mem::size_of::<S<u64, u16>>(), 11);
- assert_eq!(sys::size_of::<S<~str, @mut [int]>>(),
- 1 + sys::size_of::<~str>() + sys::size_of::<@mut [int]>());
+ assert_eq!(mem::size_of::<S<~str, @mut [int]>>(),
+ 1 + mem::size_of::<~str>() + mem::size_of::<@mut [int]>());
}
extern mod packed;
-use std::sys;
+use std::mem;
fn main() {
- assert_eq!(
sys::size_of::<packed::S>(), 5);
+ assert_eq!(
mem::size_of::<packed::S>(), 5);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::sys;
+use std::mem;
#[packed]
struct S4 {
pub fn main() {
- assert_eq!(sys::size_of::<S4>(), 4);
- assert_eq!(sys::size_of::<S5>(), 5);
- assert_eq!(sys::size_of::<S13_str>(), 13 + sys::size_of::<~str>());
- assert_eq!(sys::size_of::<S3_Foo>(), 3 + sys::size_of::<Foo>());
- assert_eq!(sys::size_of::<S7_Option>(), 7 + sys::size_of::<Option<@mut f64>>());
+ assert_eq!(mem::size_of::<S4>(), 4);
+ assert_eq!(mem::size_of::<S5>(), 5);
+ assert_eq!(mem::size_of::<S13_str>(), 13 + mem::size_of::<~str>());
+ assert_eq!(mem::size_of::<S3_Foo>(), 3 + mem::size_of::<Foo>());
+ assert_eq!(mem::size_of::<S7_Option>(), 7 + mem::size_of::<Option<@mut f64>>());
}
// xfail-android: FIXME(#9116) Bus error
-use std::sys;
+use std::mem;
#[packed]
#[deriving(Eq)]
pub fn main() {
let foos = [Foo { bar: 1, baz: 2 }, .. 10];
- assert_eq!(sys::size_of::<[Foo, .. 10]>(), 90);
+ assert_eq!(mem::size_of::<[Foo, .. 10]>(), 90);
for i in range(0u, 10) {
assert_eq!(foos[i], Foo { bar: 1, baz: 2});
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::sys;
+use std::mem;
#[packed]
struct S4(u8,[u8, .. 3]);
struct S7_Option(f32, u8, u16, Option<@mut f64>);
pub fn main() {
- assert_eq!(sys::size_of::<S4>(), 4);
+ assert_eq!(mem::size_of::<S4>(), 4);
- assert_eq!(sys::size_of::<S5>(), 5);
+ assert_eq!(mem::size_of::<S5>(), 5);
- assert_eq!(sys::size_of::<S13_str>(),
- 13 + sys::size_of::<~str>());
+ assert_eq!(mem::size_of::<S13_str>(),
+ 13 + mem::size_of::<~str>());
- assert_eq!(sys::size_of::<S3_Foo>(),
- 3 + sys::size_of::<Foo>());
+ assert_eq!(mem::size_of::<S3_Foo>(),
+ 3 + mem::size_of::<Foo>());
- assert_eq!(sys::size_of::<S7_Option>(),
- 7 + sys::size_of::<Option<@mut f64>>());
+ assert_eq!(mem::size_of::<S7_Option>(),
+ 7 + mem::size_of::<Option<@mut f64>>());
}
// Issue #2303
-use std::sys;
+use std::mem;
mod rusti {
extern "rust-intrinsic" {
let y = format!("{:?}", x);
info2!("align inner = {:?}", rusti::min_align_of::<Inner>());
- info2!("size outer = {:?}", sys::size_of::<Outer>());
+ info2!("size outer = {:?}", mem::size_of::<Outer>());
info2!("y = {}", y);
// per clang/gcc the alignment of `inner` is 4 on x86.
// per clang/gcc the size of `outer` should be 12
// because `inner`s alignment was 4.
- assert_eq!(sys::size_of::<Outer>(), m::size());
+ assert_eq!(mem::size_of::<Outer>(), m::size());
assert_eq!(y, ~"Outer{c8: 22u8, t: Inner{c64: 44u32}}");
}
// Issue #2303
-use std::sys;
+use std::mem;
mod rusti {
extern "rust-intrinsic" {
let y = format!("{:?}", x);
info2!("align inner = {}", rusti::min_align_of::<Inner>());
- info2!("size outer = {}", sys::size_of::<Outer>());
+ info2!("size outer = {}", mem::size_of::<Outer>());
info2!("y = {}", y);
// per clang/gcc the alignment of `Inner` is 4 on x86.
// per clang/gcc the size of `Outer` should be 12
// because `Inner`s alignment was 4.
- assert_eq!(sys::size_of::<Outer>(), m::m::size());
+ assert_eq!(mem::size_of::<Outer>(), m::m::size());
assert_eq!(y, ~"Outer{c8: 22u8, t: Inner{c64: 44u64}}");
}
use std::libc::c_void;
use std::ptr;
-use std::sys;
+use std::mem;
use std::unstable::intrinsics::{TyDesc, get_tydesc, visit_tydesc, TyVisitor, Opaque};
use std::unstable::raw::Vec;
#[inline(always)]
pub fn align_to<T>(&mut self) {
- self.align(sys::min_align_of::<T>());
+ self.align(mem::min_align_of::<T>());
}
#[inline(always)]
pub fn bump_past<T>(&mut self) {
- self.bump(sys::size_of::<T>());
+ self.bump(mem::size_of::<T>());
}
}
use std::cast;
use std::libc;
-use std::sys;
+use std::mem;
struct arena(());
#[fixed_stack_segment] #[inline(never)]
fn alloc<'a>(_bcx : &'a arena) -> &'a Bcx<'a> {
unsafe {
- cast::transmute(libc::malloc(sys::size_of::<Bcx<'blk>>()
+ cast::transmute(libc::malloc(mem::size_of::<Bcx<'blk>>()
as libc::size_t))
}
}
// except according to those terms.
extern mod std;
-use std::sys::size_of;
+use std::mem::size_of;
struct t {a: u8, b: i8}
struct u {a: u8, b: i8, c: u8}
projects / rust.git / commitdiff