rust/src/libcore/cast.rs

155 lines
4.5 KiB
Rust
Raw Normal View History

// 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.
//! Unsafe casting functions
pub mod rusti {
#[abi = "rust-intrinsic"]
#[link_name = "rusti"]
pub extern "rust-intrinsic" {
fn forget<T>(+x: T);
fn reinterpret_cast<T, U>(&&e: T) -> U;
}
}
/// Casts the value at `src` to U. The two types must have the same length.
#[inline(always)]
pub unsafe fn reinterpret_cast<T, U>(src: &T) -> U {
2012-08-29 18:00:36 -05:00
rusti::reinterpret_cast(*src)
}
/**
* Move a thing into the void
*
* The forget function will take ownership of the provided value but neglect
* to run any required cleanup or memory-management operations on it. This
* can be used for various acts of magick, particularly when using
* reinterpret_cast on pointer types.
*/
#[inline(always)]
2013-02-15 02:51:28 -06:00
pub unsafe fn forget<T>(thing: T) { rusti::forget(thing); }
2012-01-17 19:28:21 -06:00
/**
* Force-increment the reference count on a shared box. If used
2012-09-11 19:17:54 -05:00
* carelessly, this can leak the box. Use this in conjunction with transmute
* and/or reinterpret_cast when such calls would otherwise scramble a box's
* reference count
*/
2013-02-15 02:51:28 -06:00
pub unsafe fn bump_box_refcount<T>(t: @T) { forget(t); }
2012-06-27 12:11:57 -05:00
/**
* Transform a value of one type into a value of another type.
* Both types must have the same size and alignment.
*
* # Example
*
2013-03-28 20:39:09 -05:00
* assert!(transmute("L") == ~[76u8, 0u8]);
*/
2012-09-11 17:57:32 -05:00
#[inline(always)]
pub unsafe fn transmute<L, G>(thing: L) -> G {
2012-09-11 19:17:54 -05:00
let newthing: G = reinterpret_cast(&thing);
2013-02-15 02:51:28 -06:00
forget(thing);
newthing
}
/// Coerce an immutable reference to be mutable.
2012-09-11 17:57:32 -05:00
#[inline(always)]
pub unsafe fn transmute_mut<'a,T>(ptr: &'a T) -> &'a mut T { transmute(ptr) }
/// Coerce a mutable reference to be immutable.
2012-09-11 17:57:32 -05:00
#[inline(always)]
pub unsafe fn transmute_immut<'a,T>(ptr: &'a mut T) -> &'a T {
2013-02-15 02:51:28 -06:00
transmute(ptr)
}
/// Coerce a borrowed pointer to have an arbitrary associated region.
2012-09-11 17:57:32 -05:00
#[inline(always)]
pub unsafe fn transmute_region<'a,'b,T>(ptr: &'a T) -> &'b T {
transmute(ptr)
}
/// Coerce an immutable reference to be mutable.
2012-09-11 17:57:32 -05:00
#[inline(always)]
pub unsafe fn transmute_mut_unsafe<T>(ptr: *const T) -> *mut T {
transmute(ptr)
}
/// Coerce an immutable reference to be mutable.
2012-09-11 17:57:32 -05:00
#[inline(always)]
pub unsafe fn transmute_immut_unsafe<T>(ptr: *const T) -> *T {
transmute(ptr)
}
/// Coerce a borrowed mutable pointer to have an arbitrary associated region.
2012-09-11 17:57:32 -05:00
#[inline(always)]
pub unsafe fn transmute_mut_region<'a,'b,T>(ptr: &'a mut T) -> &'b mut T {
2013-02-15 02:51:28 -06:00
transmute(ptr)
}
/// Transforms lifetime of the second pointer to match the first.
2012-09-11 17:57:32 -05:00
#[inline(always)]
pub unsafe fn copy_lifetime<'a,S,T>(_ptr: &'a S, ptr: &T) -> &'a T {
transmute_region(ptr)
}
/// Transforms lifetime of the second pointer to match the first.
#[inline(always)]
pub unsafe fn copy_lifetime_vec<'a,S,T>(_ptr: &'a [S], ptr: &T) -> &'a T {
transmute_region(ptr)
}
/****************************************************************************
* Tests
****************************************************************************/
2012-01-17 19:28:21 -06:00
#[cfg(test)]
mod tests {
use cast::{bump_box_refcount, reinterpret_cast, transmute};
2012-01-17 19:28:21 -06:00
#[test]
fn test_reinterpret_cast() {
2013-03-28 20:39:09 -05:00
assert!(1u == unsafe { reinterpret_cast(&1) });
2012-01-17 19:28:21 -06:00
}
2012-06-27 12:11:57 -05:00
#[test]
fn test_bump_box_refcount() {
2012-06-27 12:11:57 -05:00
unsafe {
let box = @~"box box box"; // refcount 1
2012-06-27 12:11:57 -05:00
bump_box_refcount(box); // refcount 2
let ptr: *int = transmute(box); // refcount 2
2012-08-29 18:00:36 -05:00
let _box1: @~str = reinterpret_cast(&ptr);
let _box2: @~str = reinterpret_cast(&ptr);
2013-03-28 20:39:09 -05:00
assert!(*_box1 == ~"box box box");
assert!(*_box2 == ~"box box box");
2012-06-27 12:11:57 -05:00
// Will destroy _box1 and _box2. Without the bump, this would
// use-after-free. With too many bumps, it would leak.
}
}
#[test]
fn test_transmute() {
2012-12-12 20:41:30 -06:00
use managed::raw::BoxRepr;
unsafe {
2012-12-12 20:41:30 -06:00
let x = @100u8;
2013-02-15 02:51:28 -06:00
let x: *BoxRepr = transmute(x);
2013-03-28 20:39:09 -05:00
assert!((*x).data == 100);
2013-02-15 02:51:28 -06:00
let _x: @int = transmute(x);
}
}
#[test]
fn test_transmute2() {
unsafe {
2013-03-28 20:39:09 -05:00
assert!(~[76u8, 0u8] == transmute(~"L"));
}
}
2012-01-17 19:28:21 -06:00
}