2012-07-04 16:53:12 -05:00
|
|
|
//! Misc low level stuff
|
2012-03-10 02:04:09 -06:00
|
|
|
|
2012-09-20 17:37:43 -05:00
|
|
|
// NB: transitionary, de-mode-ing.
|
|
|
|
#[forbid(deprecated_mode)];
|
|
|
|
#[forbid(deprecated_pattern)];
|
|
|
|
|
2012-08-27 18:26:35 -05:00
|
|
|
use cmp::{Eq, Ord};
|
2012-09-05 23:10:22 -05:00
|
|
|
use libc::c_void;
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2012-09-26 18:01:40 -05:00
|
|
|
pub type FreeGlue = fn(*TypeDesc, *c_void);
|
2012-09-05 23:10:22 -05:00
|
|
|
|
2012-08-13 18:20:27 -05:00
|
|
|
// Corresponds to runtime type_desc type
|
2012-09-26 18:01:40 -05:00
|
|
|
pub enum TypeDesc = {
|
2012-07-09 19:23:13 -05:00
|
|
|
size: uint,
|
2012-09-05 23:10:22 -05:00
|
|
|
align: uint,
|
|
|
|
take_glue: uint,
|
|
|
|
drop_glue: uint,
|
|
|
|
free_glue: uint
|
2011-12-13 18:25:51 -06:00
|
|
|
// Remaining fields not listed
|
|
|
|
};
|
|
|
|
|
2012-08-29 16:04:10 -05:00
|
|
|
/// The representation of a Rust closure
|
2012-09-26 18:01:40 -05:00
|
|
|
pub struct Closure {
|
2012-09-07 16:50:47 -05:00
|
|
|
code: *(),
|
|
|
|
env: *(),
|
2012-08-29 16:04:10 -05:00
|
|
|
}
|
|
|
|
|
2012-03-23 09:05:16 -05:00
|
|
|
#[abi = "rust-intrinsic"]
|
2012-07-03 18:11:00 -05:00
|
|
|
extern mod rusti {
|
2012-03-22 06:30:10 -05:00
|
|
|
fn get_tydesc<T>() -> *();
|
|
|
|
fn size_of<T>() -> uint;
|
2012-04-27 17:40:40 -05:00
|
|
|
fn pref_align_of<T>() -> uint;
|
|
|
|
fn min_align_of<T>() -> uint;
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
|
2012-08-02 17:42:56 -05:00
|
|
|
/// Compares contents of two pointers using the default method.
|
|
|
|
/// Equivalent to `*x1 == *x2`. Useful for hashtables.
|
2012-09-26 18:01:40 -05:00
|
|
|
pub pure fn shape_eq<T:Eq>(x1: &T, x2: &T) -> bool {
|
2012-08-02 17:42:56 -05:00
|
|
|
*x1 == *x2
|
|
|
|
}
|
|
|
|
|
2012-09-26 18:01:40 -05:00
|
|
|
pub pure fn shape_lt<T:Ord>(x1: &T, x2: &T) -> bool {
|
2012-08-02 17:42:56 -05:00
|
|
|
*x1 < *x2
|
|
|
|
}
|
|
|
|
|
2012-09-26 18:01:40 -05:00
|
|
|
pub pure fn shape_le<T:Ord>(x1: &T, x2: &T) -> bool {
|
2012-08-27 18:26:35 -05:00
|
|
|
*x1 <= *x2
|
2012-08-02 17:42:56 -05:00
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/**
|
|
|
|
* Returns a pointer to a type descriptor.
|
|
|
|
*
|
|
|
|
* Useful for calling certain function in the Rust runtime or otherwise
|
|
|
|
* performing dark magick.
|
|
|
|
*/
|
2012-09-11 17:57:32 -05:00
|
|
|
#[inline(always)]
|
2012-09-26 18:01:40 -05:00
|
|
|
pub pure fn get_type_desc<T>() -> *TypeDesc {
|
2012-09-18 13:17:40 -05:00
|
|
|
unsafe { rusti::get_tydesc::<T>() as *TypeDesc }
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Returns the size of a type
|
2012-06-14 13:38:45 -05:00
|
|
|
#[inline(always)]
|
2012-09-26 18:01:40 -05:00
|
|
|
pub pure fn size_of<T>() -> uint {
|
2012-09-18 13:17:40 -05:00
|
|
|
unsafe { rusti::size_of::<T>() }
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2012-08-21 17:32:30 -05:00
|
|
|
#[inline(always)]
|
2012-09-26 18:01:40 -05:00
|
|
|
pub pure fn min_align_of<T>() -> uint {
|
2012-09-18 13:17:40 -05:00
|
|
|
unsafe { rusti::min_align_of::<T>() }
|
2012-04-27 00:28:03 -05:00
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Returns the preferred alignment of a type
|
2012-08-21 17:32:30 -05:00
|
|
|
#[inline(always)]
|
2012-09-26 18:01:40 -05:00
|
|
|
pub pure fn pref_align_of<T>() -> uint {
|
2012-09-18 13:17:40 -05:00
|
|
|
unsafe { rusti::pref_align_of::<T>() }
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Returns the refcount of a shared box (as just before calling this)
|
2012-09-11 17:57:32 -05:00
|
|
|
#[inline(always)]
|
2012-10-02 13:37:37 -05:00
|
|
|
pub pure fn refcount<T>(t: @T) -> uint {
|
2012-06-01 21:47:04 -05:00
|
|
|
unsafe {
|
2012-09-18 19:34:08 -05:00
|
|
|
let ref_ptr: *uint = cast::reinterpret_cast(&t);
|
2012-06-28 13:40:31 -05:00
|
|
|
*ref_ptr - 1
|
2012-06-01 21:47:04 -05:00
|
|
|
}
|
2011-12-13 18:25:51 -06:00
|
|
|
}
|
|
|
|
|
2012-09-26 18:01:40 -05:00
|
|
|
pub pure fn log_str<T>(t: &T) -> ~str {
|
2012-06-01 21:47:04 -05:00
|
|
|
unsafe {
|
2012-09-14 11:40:28 -05:00
|
|
|
do io::with_str_writer |wr| {
|
2012-09-20 17:37:43 -05:00
|
|
|
repr::write_repr(wr, t)
|
2012-09-14 11:40:28 -05:00
|
|
|
}
|
2012-06-01 21:47:04 -05:00
|
|
|
}
|
2012-01-11 11:09:46 -06:00
|
|
|
}
|
|
|
|
|
2012-01-17 19:28:21 -06:00
|
|
|
#[cfg(test)]
|
2012-09-26 18:01:40 -05:00
|
|
|
pub mod tests {
|
2012-01-17 19:28:21 -06:00
|
|
|
|
|
|
|
#[test]
|
2012-09-26 18:01:40 -05:00
|
|
|
pub fn size_of_basic() {
|
2012-01-17 19:28:21 -06:00
|
|
|
assert size_of::<u8>() == 1u;
|
|
|
|
assert size_of::<u16>() == 2u;
|
|
|
|
assert size_of::<u32>() == 4u;
|
|
|
|
assert size_of::<u64>() == 8u;
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
#[cfg(target_arch = "x86")]
|
|
|
|
#[cfg(target_arch = "arm")]
|
2012-09-26 18:01:40 -05:00
|
|
|
pub fn size_of_32() {
|
2012-01-17 19:28:21 -06:00
|
|
|
assert size_of::<uint>() == 4u;
|
|
|
|
assert size_of::<*uint>() == 4u;
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
#[cfg(target_arch = "x86_64")]
|
2012-09-26 18:01:40 -05:00
|
|
|
pub fn size_of_64() {
|
2012-01-17 19:28:21 -06:00
|
|
|
assert size_of::<uint>() == 8u;
|
|
|
|
assert size_of::<*uint>() == 8u;
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2012-09-26 18:01:40 -05:00
|
|
|
pub fn align_of_basic() {
|
2012-04-27 00:28:03 -05:00
|
|
|
assert pref_align_of::<u8>() == 1u;
|
|
|
|
assert pref_align_of::<u16>() == 2u;
|
|
|
|
assert pref_align_of::<u32>() == 4u;
|
2012-01-17 19:28:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
#[cfg(target_arch = "x86")]
|
|
|
|
#[cfg(target_arch = "arm")]
|
2012-09-26 18:01:40 -05:00
|
|
|
pub fn align_of_32() {
|
2012-04-27 00:28:03 -05:00
|
|
|
assert pref_align_of::<uint>() == 4u;
|
|
|
|
assert pref_align_of::<*uint>() == 4u;
|
2012-01-17 19:28:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
#[cfg(target_arch = "x86_64")]
|
2012-09-26 18:01:40 -05:00
|
|
|
pub fn align_of_64() {
|
2012-04-27 00:28:03 -05:00
|
|
|
assert pref_align_of::<uint>() == 8u;
|
|
|
|
assert pref_align_of::<*uint>() == 8u;
|
2012-01-17 19:28:21 -06:00
|
|
|
}
|
2012-08-29 16:04:10 -05:00
|
|
|
|
|
|
|
#[test]
|
2012-09-26 18:01:40 -05:00
|
|
|
pub fn synthesize_closure() unsafe {
|
2012-08-29 16:04:10 -05:00
|
|
|
let x = 10;
|
|
|
|
let f: fn(int) -> int = |y| x + y;
|
|
|
|
|
|
|
|
assert f(20) == 30;
|
|
|
|
|
2012-09-19 00:35:28 -05:00
|
|
|
let original_closure: Closure = cast::transmute(move f);
|
2012-08-29 16:04:10 -05:00
|
|
|
|
|
|
|
let actual_function_pointer = original_closure.code;
|
|
|
|
let environment = original_closure.env;
|
|
|
|
|
|
|
|
let new_closure = Closure {
|
|
|
|
code: actual_function_pointer,
|
|
|
|
env: environment
|
|
|
|
};
|
|
|
|
|
2012-09-19 00:35:28 -05:00
|
|
|
let new_f: fn(int) -> int = cast::transmute(move new_closure);
|
2012-08-29 16:04:10 -05:00
|
|
|
assert new_f(20) == 30;
|
|
|
|
}
|
2012-01-17 19:28:21 -06:00
|
|
|
}
|
|
|
|
|
2011-12-13 18:25:51 -06:00
|
|
|
// Local Variables:
|
|
|
|
// mode: rust;
|
|
|
|
// fill-column: 78;
|
|
|
|
// indent-tabs-mode: nil
|
|
|
|
// c-basic-offset: 4
|
|
|
|
// buffer-file-coding-system: utf-8-unix
|
|
|
|
// End:
|