---

yaml
---
r: 42636
b: refs/heads/try
c: 163b97b
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 19dfec2aaf746535de1521f68421f9980dbf25de
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
-refs/heads/try: e43cff6657b5ba4245480ede5230e3f00aa52185
+refs/heads/try: 163b97b7bb53b7a9753b5fbd9b28dc1e09337259
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278

branches/try/src/libcore/pipes.rs

@@ -280,17 +280,23 @@ extern mod rusti {
 // I get link errors. This is a bug that needs investigated more.
 #[doc(hidden)]
 pub fn atomic_xchng_rel(dst: &mut int, src: int) -> int {
-    rusti::atomic_xchg_rel(dst, src)
+    unsafe {
+        rusti::atomic_xchg_rel(dst, src)
+    }
 }
 
 #[doc(hidden)]
 pub fn atomic_add_acq(dst: &mut int, src: int) -> int {
-    rusti::atomic_xadd_acq(dst, src)
+    unsafe {
+        rusti::atomic_xadd_acq(dst, src)
+    }
 }
 
 #[doc(hidden)]
 pub fn atomic_sub_rel(dst: &mut int, src: int) -> int {
-    rusti::atomic_xsub_rel(dst, src)
+    unsafe {
+        rusti::atomic_xsub_rel(dst, src)
+    }
 }
 
 #[doc(hidden)]

branches/try/src/libcore/private.rs

@@ -93,8 +93,10 @@ type rust_port_id = uint;
 type GlobalPtr = *libc::uintptr_t;
 
 fn compare_and_swap(address: &mut int, oldval: int, newval: int) -> bool {
-    let old = rusti::atomic_cxchg(address, oldval, newval);
-    old == oldval
+    unsafe {
+        let old = rusti::atomic_cxchg(address, oldval, newval);
+        old == oldval
+    }
 }
 
 /**

branches/try/src/libcore/repr.rs

@@ -201,10 +201,12 @@ impl ReprVisitor {
 
     #[inline(always)]
     fn visit_ptr_inner(ptr: *c_void, inner: *TyDesc) -> bool {
-        let mut u = ReprVisitor(ptr, self.writer);
-        let v = reflect::MovePtrAdaptor(move u);
-        visit_tydesc(inner, (move v) as @TyVisitor);
-        true
+        unsafe {
+            let mut u = ReprVisitor(ptr, self.writer);
+            let v = reflect::MovePtrAdaptor(move u);
+            visit_tydesc(inner, (move v) as @TyVisitor);
+            true
+        }
     }
 
     #[inline(always)]
@@ -558,11 +560,13 @@ impl ReprVisitor : TyVisitor {
 }
 
 pub fn write_repr<T>(writer: @Writer, object: &T) {
-    let ptr = ptr::to_unsafe_ptr(object) as *c_void;
-    let tydesc = intrinsic::get_tydesc::<T>();
-    let mut u = ReprVisitor(ptr, writer);
-    let v = reflect::MovePtrAdaptor(move u);
-    visit_tydesc(tydesc, (move v) as @TyVisitor)
+    unsafe {
+        let ptr = ptr::to_unsafe_ptr(object) as *c_void;
+        let tydesc = intrinsic::get_tydesc::<T>();
+        let mut u = ReprVisitor(ptr, writer);
+        let v = reflect::MovePtrAdaptor(move u);
+        visit_tydesc(tydesc, (move v) as @TyVisitor)
+    }
 }
 
 #[test]

branches/try/src/libcore/task/mod.rs

@@ -571,23 +571,29 @@ pub fn try<T:Owned>(f: fn~() -> T) -> Result<T,()> {
 pub fn yield() {
     //! Yield control to the task scheduler
 
-    let task_ = rt::rust_get_task();
-    let killed = rt::rust_task_yield(task_);
-    if killed && !failing() {
-        fail ~"killed";
+    unsafe {
+        let task_ = rt::rust_get_task();
+        let killed = rt::rust_task_yield(task_);
+        if killed && !failing() {
+            fail ~"killed";
+        }
     }
 }
 
 pub fn failing() -> bool {
     //! True if the running task has failed
 
-    rt::rust_task_is_unwinding(rt::rust_get_task())
+    unsafe {
+        rt::rust_task_is_unwinding(rt::rust_get_task())
+    }
 }
 
 pub fn get_task() -> Task {
     //! Get a handle to the running task
 
-    TaskHandle(rt::get_task_id())
+    unsafe {
+        TaskHandle(rt::get_task_id())
+    }
 }
 
 /**
@@ -608,7 +614,11 @@ pub fn get_task() -> Task {
 pub unsafe fn unkillable<U>(f: fn() -> U) -> U {
     struct AllowFailure {
         t: *rust_task,
-        drop { rt::rust_task_allow_kill(self.t); }
+        drop {
+            unsafe {
+                rt::rust_task_allow_kill(self.t);
+            }
+        }
     }
 
     fn AllowFailure(t: *rust_task) -> AllowFailure{
@@ -617,17 +627,23 @@ pub unsafe fn unkillable<U>(f: fn() -> U) -> U {
         }
     }
 
-    let t = rt::rust_get_task();
-    let _allow_failure = AllowFailure(t);
-    rt::rust_task_inhibit_kill(t);
-    f()
+    unsafe {
+        let t = rt::rust_get_task();
+        let _allow_failure = AllowFailure(t);
+        rt::rust_task_inhibit_kill(t);
+        f()
+    }
 }
 
 /// The inverse of unkillable. Only ever to be used nested in unkillable().
 pub unsafe fn rekillable<U>(f: fn() -> U) -> U {
     struct DisallowFailure {
         t: *rust_task,
-        drop { rt::rust_task_inhibit_kill(self.t); }
+        drop {
+            unsafe {
+                rt::rust_task_inhibit_kill(self.t);
+            }
+        }
     }
 
     fn DisallowFailure(t: *rust_task) -> DisallowFailure {
@@ -636,10 +652,12 @@ pub unsafe fn rekillable<U>(f: fn() -> U) -> U {
         }
     }
 
-    let t = rt::rust_get_task();
-    let _allow_failure = DisallowFailure(t);
-    rt::rust_task_allow_kill(t);
-    f()
+    unsafe {
+        let t = rt::rust_get_task();
+        let _allow_failure = DisallowFailure(t);
+        rt::rust_task_allow_kill(t);
+        f()
+    }
 }
 
 /**
@@ -650,8 +668,10 @@ pub unsafe fn atomically<U>(f: fn() -> U) -> U {
     struct DeferInterrupts {
         t: *rust_task,
         drop {
-            rt::rust_task_allow_yield(self.t);
-            rt::rust_task_allow_kill(self.t);
+            unsafe {
+                rt::rust_task_allow_yield(self.t);
+                rt::rust_task_allow_kill(self.t);
+            }
         }
     }
 
@@ -661,11 +681,13 @@ pub unsafe fn atomically<U>(f: fn() -> U) -> U {
         }
     }
 
-    let t = rt::rust_get_task();
-    let _interrupts = DeferInterrupts(t);
-    rt::rust_task_inhibit_kill(t);
-    rt::rust_task_inhibit_yield(t);
-    f()
+    unsafe {
+        let t = rt::rust_get_task();
+        let _interrupts = DeferInterrupts(t);
+        rt::rust_task_inhibit_kill(t);
+        rt::rust_task_inhibit_yield(t);
+        f()
+    }
 }
 
 #[test] #[should_fail] #[ignore(cfg(windows))]
@@ -908,18 +930,22 @@ fn test_spawn_sched() {
     let ch = oldcomm::Chan(&po);
 
     fn f(i: int, ch: oldcomm::Chan<()>) {
-        let parent_sched_id = rt::rust_get_sched_id();
+        unsafe {
+            let parent_sched_id = rt::rust_get_sched_id();
 
-        do spawn_sched(SingleThreaded) {
-            let child_sched_id = rt::rust_get_sched_id();
-            assert parent_sched_id != child_sched_id;
-
-            if (i == 0) {
-                oldcomm::send(ch, ());
-            } else {
-                f(i - 1, ch);
-            }
-        };
+            do spawn_sched(SingleThreaded) {
+                unsafe {
+                    let child_sched_id = rt::rust_get_sched_id();
+                    assert parent_sched_id != child_sched_id;
+
+                    if (i == 0) {
+                        oldcomm::send(ch, ());
+                    } else {
+                        f(i - 1, ch);
+                    }
+                }
+            };
+        }
 
     }
     f(10, ch);
@@ -932,13 +958,17 @@ fn test_spawn_sched_childs_on_same_sched() {
     let ch = oldcomm::Chan(&po);
 
     do spawn_sched(SingleThreaded) {
-        let parent_sched_id = rt::rust_get_sched_id();
-        do spawn {
-            let child_sched_id = rt::rust_get_sched_id();
-            // This should be on the same scheduler
-            assert parent_sched_id == child_sched_id;
-            oldcomm::send(ch, ());
-        };
+        unsafe {
+            let parent_sched_id = rt::rust_get_sched_id();
+            do spawn {
+                unsafe {
+                    let child_sched_id = rt::rust_get_sched_id();
+                    // This should be on the same scheduler
+                    assert parent_sched_id == child_sched_id;
+                    oldcomm::send(ch, ());
+                }
+            };
+        }
     };
 
     oldcomm::recv(po);
@@ -1185,10 +1215,12 @@ fn test_sched_thread_per_core() {
     let (port, chan) = pipes::stream();
 
     do spawn_sched(ThreadPerCore) |move chan| {
-        let cores = rt::rust_num_threads();
-        let reported_threads = rt::rust_sched_threads();
-        assert(cores as uint == reported_threads as uint);
-        chan.send(());
+        unsafe {
+            let cores = rt::rust_num_threads();
+            let reported_threads = rt::rust_sched_threads();
+            assert(cores as uint == reported_threads as uint);
+            chan.send(());
+        }
     }
 
     port.recv();
@@ -1199,22 +1231,24 @@ fn test_spawn_thread_on_demand() {
     let (port, chan) = pipes::stream();
 
     do spawn_sched(ManualThreads(2)) |move chan| {
-        let max_threads = rt::rust_sched_threads();
-        assert(max_threads as int == 2);
-        let running_threads = rt::rust_sched_current_nonlazy_threads();
-        assert(running_threads as int == 1);
+        unsafe {
+            let max_threads = rt::rust_sched_threads();
+            assert(max_threads as int == 2);
+            let running_threads = rt::rust_sched_current_nonlazy_threads();
+            assert(running_threads as int == 1);
 
-        let (port2, chan2) = pipes::stream();
+            let (port2, chan2) = pipes::stream();
 
-        do spawn() |move chan2| {
-            chan2.send(());
-        }
+            do spawn() |move chan2| {
+                chan2.send(());
+            }
 
-        let running_threads2 = rt::rust_sched_current_nonlazy_threads();
-        assert(running_threads2 as int == 2);
+            let running_threads2 = rt::rust_sched_current_nonlazy_threads();
+            assert(running_threads2 as int == 2);
 
-        port2.recv();
-        chan.send(());
+            port2.recv();
+            chan.send(());
+        }
     }
 
     port.recv();