core: Rename 'unsafe' mod to 'cast'

Author: brson

src/libcore/at_vec.rs

@@ -29,7 +29,7 @@ extern mod rusti {
 pure fn capacity<T>(&&v: @[const T]) -> uint {
     unsafe {
         let repr: **raw::VecRepr =
-            ::unsafe::reinterpret_cast(&addr_of(v));
+            ::cast::reinterpret_cast(&addr_of(v));
         (**repr).unboxed.alloc / sys::size_of::<T>()
     }
 }
@@ -154,13 +154,13 @@ mod raw {
      */
     #[inline(always)]
     unsafe fn set_len<T>(&&v: @[const T], new_len: uint) {
-        let repr: **VecRepr = ::unsafe::reinterpret_cast(&addr_of(v));
+        let repr: **VecRepr = ::cast::reinterpret_cast(&addr_of(v));
         (**repr).unboxed.fill = new_len * sys::size_of::<T>();
     }
 
     #[inline(always)]
     unsafe fn push<T>(&v: @[const T], +initval: T) {
-        let repr: **VecRepr = ::unsafe::reinterpret_cast(&addr_of(v));
+        let repr: **VecRepr = ::cast::reinterpret_cast(&addr_of(v));
         let fill = (**repr).unboxed.fill;
         if (**repr).unboxed.alloc > fill {
             push_fast(v, move initval);
@@ -172,7 +172,7 @@ mod raw {
     // This doesn't bother to make sure we have space.
     #[inline(always)] // really pretty please
     unsafe fn push_fast<T>(&v: @[const T], +initval: T) {
-        let repr: **VecRepr = ::unsafe::reinterpret_cast(&addr_of(v));
+        let repr: **VecRepr = ::cast::reinterpret_cast(&addr_of(v));
         let fill = (**repr).unboxed.fill;
         (**repr).unboxed.fill += sys::size_of::<T>();
         let p = ptr::addr_of((**repr).unboxed.data);

src/libcore/unsafe.rs renamed to src/libcore/cast.rs

@@ -2,7 +2,7 @@ use libc::{c_char, c_void, intptr_t, uintptr_t};
 use ptr::{mut_null, null, to_unsafe_ptr};
 use repr::BoxRepr;
 use sys::TypeDesc;
-use unsafe::transmute;
+use cast::transmute;
 
 export annihilate;
 

src/libcore/cleanup.rs

@@ -181,7 +181,7 @@ fn send<T: Send>(ch: Chan<T>, +data: T) {
     let res = rustrt::rust_port_id_send(p, data_ptr);
     if res != 0 unsafe {
         // Data sent successfully
-        unsafe::forget(move data);
+        cast::forget(move data);
     }
     task::yield();
 }

src/libcore/comm.rs

@@ -41,7 +41,7 @@ export uint, u8, u16, u32, u64;
 export float, f32, f64;
 export box, char, str, ptr, vec, at_vec, bool;
 export either, option, result, iter;
-export gc, io, libc, os, run, rand, sys, unsafe, logging;
+export gc, io, libc, os, run, rand, sys, cast, logging;
 export comm, task, future, pipes;
 export extfmt;
 // The test harness links against core, so don't include runtime in tests.
@@ -228,7 +228,7 @@ mod path;
 mod rand;
 mod run;
 mod sys;
-mod unsafe;
+mod cast;
 mod mutable;
 mod flate;
 mod repr;

src/libcore/core.rc

@@ -9,7 +9,7 @@
 //
 // Note that recursive use is not permitted.
 
-use unsafe::reinterpret_cast;
+use cast::reinterpret_cast;
 use ptr::null;
 
 export DVec;
@@ -81,7 +81,7 @@ fn unwrap<A>(+d: DVec<A>) -> ~[A] {
 priv impl<A> DVec<A> {
     pure fn check_not_borrowed() {
         unsafe {
-            let data: *() = unsafe::reinterpret_cast(&self.data);
+            let data: *() = cast::reinterpret_cast(&self.data);
             if data.is_null() {
                 fail ~"Recursive use of dvec";
             }
@@ -91,9 +91,9 @@ priv impl<A> DVec<A> {
     #[inline(always)]
     fn check_out<B>(f: fn(-~[A]) -> B) -> B {
         unsafe {
-            let mut data = unsafe::reinterpret_cast(&null::<()>());
+            let mut data = cast::reinterpret_cast(&null::<()>());
             data <-> self.data;
-            let data_ptr: *() = unsafe::reinterpret_cast(&data);
+            let data_ptr: *() = cast::reinterpret_cast(&data);
             if data_ptr.is_null() { fail ~"Recursive use of dvec"; }
             return f(move data);
         }
@@ -168,9 +168,9 @@ impl<A> DVec<A> {
     /// Insert a single item at the front of the list
     fn unshift(-t: A) {
         unsafe {
-            let mut data = unsafe::reinterpret_cast(&null::<()>());
+            let mut data = cast::reinterpret_cast(&null::<()>());
             data <-> self.data;
-            let data_ptr: *() = unsafe::reinterpret_cast(&data);
+            let data_ptr: *() = cast::reinterpret_cast(&data);
             if data_ptr.is_null() { fail ~"Recursive use of dvec"; }
             log(error, ~"a");
             self.data <- ~[move t];

src/libcore/dvec.rs

@@ -17,7 +17,7 @@
 
 use either::Either;
 use pipes::recv;
-use unsafe::copy_lifetime;
+use cast::copy_lifetime;
 
 export Future;
 export extensions;

src/libcore/future.rs

@@ -55,14 +55,14 @@ extern mod rustrt {
 }
 
 unsafe fn bump<T, U>(ptr: *T, count: uint) -> *U {
-    return unsafe::reinterpret_cast(&ptr::offset(ptr, count));
+    return cast::reinterpret_cast(&ptr::offset(ptr, count));
 }
 
 unsafe fn align_to_pointer<T>(ptr: *T) -> *T {
     let align = sys::min_align_of::<*T>();
-    let ptr: uint = unsafe::reinterpret_cast(&ptr);
+    let ptr: uint = cast::reinterpret_cast(&ptr);
     let ptr = (ptr + (align - 1)) & -align;
-    return unsafe::reinterpret_cast(&ptr);
+    return cast::reinterpret_cast(&ptr);
 }
 
 unsafe fn get_safe_point_count() -> uint {
@@ -101,8 +101,8 @@ type Visitor = fn(root: **Word, tydesc: *Word) -> bool;
 // Walks the list of roots for the given safe point, and calls visitor
 // on each root.
 unsafe fn walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) {
-    let fp_bytes: *u8 = unsafe::reinterpret_cast(&fp);
-    let sp_meta: *u32 = unsafe::reinterpret_cast(&sp.sp_meta);
+    let fp_bytes: *u8 = cast::reinterpret_cast(&fp);
+    let sp_meta: *u32 = cast::reinterpret_cast(&sp.sp_meta);
 
     let num_stack_roots = *sp_meta as uint;
     let num_reg_roots = *ptr::offset(sp_meta, 1) as uint;
@@ -143,9 +143,9 @@ unsafe fn walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) {
 
 // Is fp contained in segment?
 unsafe fn is_frame_in_segment(fp: *Word, segment: *StackSegment) -> bool {
-    let begin: Word = unsafe::reinterpret_cast(&segment);
-    let end: Word = unsafe::reinterpret_cast(&(*segment).end);
-    let frame: Word = unsafe::reinterpret_cast(&fp);
+    let begin: Word = cast::reinterpret_cast(&segment);
+    let end: Word = cast::reinterpret_cast(&(*segment).end);
+    let frame: Word = cast::reinterpret_cast(&fp);
 
     return begin <= frame && frame <= end;
 }
@@ -315,7 +315,7 @@ fn cleanup_stack_for_failure() {
         // own stack roots on the stack anyway.
         let sentinel_box = ~0;
         let sentinel: **Word = if expect_sentinel() {
-            unsafe::reinterpret_cast(&ptr::addr_of(sentinel_box))
+            cast::reinterpret_cast(&ptr::addr_of(sentinel_box))
         } else {
             ptr::null()
         };

src/libcore/gc.rs

@@ -721,7 +721,7 @@ fn with_str_writer(f: fn(Writer)) -> ~str {
     vec::push(v, 0);
     assert str::is_utf8(v);
 
-    unsafe { move ::unsafe::transmute(v) }
+    unsafe { move ::cast::transmute(v) }
 }
 
 // Utility functions

src/libcore/io.rs

@@ -13,7 +13,7 @@ mutation when the data structure should be immutable.
 #[forbid(deprecated_pattern)];
 
 use util::with;
-use unsafe::transmute_immut;
+use cast::transmute_immut;
 
 export Mut;
 

src/libcore/mutable.rs

@@ -222,10 +222,10 @@ mod global_env {
         fn getenv(n: &str) -> Option<~str> {
             unsafe {
                 let s = str::as_c_str(n, libc::getenv);
-                return if ptr::null::<u8>() == unsafe::reinterpret_cast(&s) {
+                return if ptr::null::<u8>() == cast::reinterpret_cast(&s) {
                     option::None::<~str>
                 } else {
-                    let s = unsafe::reinterpret_cast(&s);
+                    let s = cast::reinterpret_cast(&s);
                     option::Some::<~str>(str::raw::from_buf(s))
                 };
             }

src/libcore/os.rs

@@ -77,7 +77,7 @@ bounded and unbounded protocols allows for less code duplication.
 #[forbid(deprecated_pattern)];
 
 use cmp::Eq;
-use unsafe::{forget, reinterpret_cast, transmute};
+use cast::{forget, reinterpret_cast, transmute};
 use either::{Either, Left, Right};
 use option::unwrap;
 

src/libcore/pipes.rs

@@ -89,8 +89,8 @@ unsafe fn chan_from_global_ptr<T: Send>(
         // Install the channel
         log(debug,~"BEFORE COMPARE AND SWAP");
         let swapped = compare_and_swap(
-            unsafe::reinterpret_cast(&global),
-            0u, unsafe::reinterpret_cast(&ch));
+            cast::reinterpret_cast(&global),
+            0u, cast::reinterpret_cast(&ch));
         log(debug,fmt!("AFTER .. swapped? %?", swapped));
 
         if swapped {
@@ -100,11 +100,11 @@ unsafe fn chan_from_global_ptr<T: Send>(
         } else {
             // Somebody else got in before we did
             comm::send(setup_ch, Abort);
-            unsafe::reinterpret_cast(&*global)
+            cast::reinterpret_cast(&*global)
         }
     } else {
         log(debug, ~"global != 0");
-        unsafe::reinterpret_cast(&*global)
+        cast::reinterpret_cast(&*global)
     }
 }
 
@@ -211,15 +211,15 @@ unsafe fn weaken_task(f: fn(comm::Port<()>)) {
     let po = comm::Port();
     let ch = comm::Chan(po);
     unsafe {
-        rustrt::rust_task_weaken(unsafe::reinterpret_cast(&ch));
+        rustrt::rust_task_weaken(cast::reinterpret_cast(&ch));
     }
     let _unweaken = Unweaken(ch);
     f(po);
 
     struct Unweaken {
       ch: comm::Chan<()>,
       drop unsafe {
-        rustrt::rust_task_unweaken(unsafe::reinterpret_cast(&self.ch));
+        rustrt::rust_task_unweaken(cast::reinterpret_cast(&self.ch));
       }
     }
 
@@ -309,7 +309,7 @@ struct ArcDestruct<T> {
             return; // Happens when destructing an unwrapper's handle.
         }
         do task::unkillable {
-            let data: ~ArcData<T> = unsafe::reinterpret_cast(&self.data);
+            let data: ~ArcData<T> = cast::reinterpret_cast(&self.data);
             let new_count = rustrt::rust_atomic_decrement(&mut data.count);
             assert new_count >= 0;
             if new_count == 0 {
@@ -319,22 +319,22 @@ struct ArcDestruct<T> {
                 // being here means we're the only *awake* task with the data.
                 if data.unwrapper != 0 {
                     let p: UnwrapProto =
-                        unsafe::reinterpret_cast(&data.unwrapper);
+                        cast::reinterpret_cast(&data.unwrapper);
                     let (message, response) = option::swap_unwrap(p);
                     // Send 'ready' and wait for a response.
                     pipes::send_one(move message, ());
                     // Unkillable wait. Message guaranteed to come.
                     if pipes::recv_one(move response) {
                         // Other task got the data.
-                        unsafe::forget(move data);
+                        cast::forget(move data);
                     } else {
                         // Other task was killed. drop glue takes over.
                     }
                 } else {
                     // drop glue takes over.
                 }
             } else {
-                unsafe::forget(move data);
+                cast::forget(move data);
             }
         }
     }
@@ -359,7 +359,7 @@ unsafe fn unwrap_shared_mutable_state<T: Send>(+rc: SharedMutableState<T>)
                 pipes::send_one(move response, false);
                 // Either this swap_unwrap or the one below (at "Got here")
                 // ought to run.
-                unsafe::forget(option::swap_unwrap(&mut self.ptr));
+                cast::forget(option::swap_unwrap(&mut self.ptr));
             } else {
                 assert self.ptr.is_none();
                 pipes::send_one(move response, true);
@@ -368,11 +368,11 @@ unsafe fn unwrap_shared_mutable_state<T: Send>(+rc: SharedMutableState<T>)
     }
 
     do task::unkillable {
-        let ptr: ~ArcData<T> = unsafe::reinterpret_cast(&rc.data);
+        let ptr: ~ArcData<T> = cast::reinterpret_cast(&rc.data);
         let (c1,p1) = pipes::oneshot(); // ()
         let (c2,p2) = pipes::oneshot(); // bool
         let server: UnwrapProto = ~mut Some((move c1,move p2));
-        let serverp: libc::uintptr_t = unsafe::transmute(move server);
+        let serverp: libc::uintptr_t = cast::transmute(move server);
         // Try to put our server end in the unwrapper slot.
         if rustrt::rust_compare_and_swap_ptr(&mut ptr.unwrapper, 0, serverp) {
             // Got in. Step 0: Tell destructor not to run. We are now it.
@@ -383,7 +383,7 @@ unsafe fn unwrap_shared_mutable_state<T: Send>(+rc: SharedMutableState<T>)
             if new_count == 0 {
                 // We were the last owner. Can unwrap immediately.
                 // Also we have to free the server endpoints.
-                let _server: UnwrapProto = unsafe::transmute(move serverp);
+                let _server: UnwrapProto = cast::transmute(move serverp);
                 option::swap_unwrap(&mut ptr.data)
                 // drop glue takes over.
             } else {
@@ -403,9 +403,9 @@ unsafe fn unwrap_shared_mutable_state<T: Send>(+rc: SharedMutableState<T>)
             }
         } else {
             // Somebody else was trying to unwrap. Avoid guaranteed deadlock.
-            unsafe::forget(move ptr);
+            cast::forget(move ptr);
             // Also we have to free the (rejected) server endpoints.
-            let _server: UnwrapProto = unsafe::transmute(move serverp);
+            let _server: UnwrapProto = cast::transmute(move serverp);
             fail ~"Another task is already unwrapping this ARC!";
         }
     }
@@ -422,7 +422,7 @@ type SharedMutableState<T: Send> = ArcDestruct<T>;
 unsafe fn shared_mutable_state<T: Send>(+data: T) -> SharedMutableState<T> {
     let data = ~ArcData { count: 1, unwrapper: 0, data: Some(move data) };
     unsafe {
-        let ptr = unsafe::transmute(move data);
+        let ptr = cast::transmute(move data);
         ArcDestruct(ptr)
     }
 }
@@ -431,34 +431,34 @@ unsafe fn shared_mutable_state<T: Send>(+data: T) -> SharedMutableState<T> {
 unsafe fn get_shared_mutable_state<T: Send>(rc: &a/SharedMutableState<T>)
         -> &a/mut T {
     unsafe {
-        let ptr: ~ArcData<T> = unsafe::reinterpret_cast(&(*rc).data);
+        let ptr: ~ArcData<T> = cast::reinterpret_cast(&(*rc).data);
         assert ptr.count > 0;
         // Cast us back into the correct region
-        let r = unsafe::transmute_region(option::get_ref(&ptr.data));
-        unsafe::forget(move ptr);
-        return unsafe::transmute_mut(r);
+        let r = cast::transmute_region(option::get_ref(&ptr.data));
+        cast::forget(move ptr);
+        return cast::transmute_mut(r);
     }
 }
 #[inline(always)]
 unsafe fn get_shared_immutable_state<T: Send>(rc: &a/SharedMutableState<T>)
         -> &a/T {
     unsafe {
-        let ptr: ~ArcData<T> = unsafe::reinterpret_cast(&(*rc).data);
+        let ptr: ~ArcData<T> = cast::reinterpret_cast(&(*rc).data);
         assert ptr.count > 0;
         // Cast us back into the correct region
-        let r = unsafe::transmute_region(option::get_ref(&ptr.data));
-        unsafe::forget(move ptr);
+        let r = cast::transmute_region(option::get_ref(&ptr.data));
+        cast::forget(move ptr);
         return r;
     }
 }
 
 unsafe fn clone_shared_mutable_state<T: Send>(rc: &SharedMutableState<T>)
         -> SharedMutableState<T> {
     unsafe {
-        let ptr: ~ArcData<T> = unsafe::reinterpret_cast(&(*rc).data);
+        let ptr: ~ArcData<T> = cast::reinterpret_cast(&(*rc).data);
         let new_count = rustrt::rust_atomic_increment(&mut ptr.count);
         assert new_count >= 2;
-        unsafe::forget(move ptr);
+        cast::forget(move ptr);
     }
     ArcDestruct((*rc).data)
 }
@@ -543,7 +543,7 @@ impl<T: Send> Exclusive<T> {
     #[inline(always)]
     unsafe fn with_imm<U>(f: fn(x: &T) -> U) -> U {
         do self.with |x| {
-            f(unsafe::transmute_immut(x))
+            f(cast::transmute_immut(x))
         }
     }
 }