mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

core: Remove all but one drop block in favor of finally

Browse Source
This commit is contained in:
Brian Anderson 2013-04-08 16:07:54 -07:00
parent 5a0f628501
commit 2e907a3ac2
2 changed files with 23 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
src/libcore/task/mod.rs
View File

@ -42,6 +42,7 @@ use result;
use task::rt::{task_id, sched_id, rust_task};
use util;
use util::replace;
use unstable::finally::Finally;
#[cfg(test)] use comm::SharedChan;
@ -565,51 +566,27 @@ pub fn get_scheduler() -> Scheduler {
* ~~~
*/
pub unsafe fn unkillable<U>(f: &fn() -> U) -> U {
struct AllowFailure {
t: *rust_task,
drop {
unsafe {
rt::rust_task_allow_kill(self.t);
}
}
}
fn AllowFailure(t: *rust_task) -> AllowFailure{
AllowFailure {
t: t
}
}
unsafe {
let t = rt::rust_get_task();
let _allow_failure = AllowFailure(t);
rt::rust_task_inhibit_kill(t);
f()
do (|| {
f()
}).finally {
rt::rust_task_allow_kill(t);
}
}
}
/// 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 {
unsafe {
rt::rust_task_inhibit_kill(self.t);
}
}
}
fn DisallowFailure(t: *rust_task) -> DisallowFailure {
DisallowFailure {
t: t
}
}
unsafe {
let t = rt::rust_get_task();
let _allow_failure = DisallowFailure(t);
rt::rust_task_allow_kill(t);
f()
do (|| {
f()
}).finally {
rt::rust_task_inhibit_kill(t);
}
}
}
@ -618,28 +595,16 @@ pub unsafe fn rekillable<U>(f: &fn() -> U) -> U {
* For use with exclusive ARCs, which use pthread mutexes directly.
*/
pub unsafe fn atomically<U>(f: &fn() -> U) -> U {
struct DeferInterrupts {
t: *rust_task,
drop {
unsafe {
rt::rust_task_allow_yield(self.t);
rt::rust_task_allow_kill(self.t);
}
}
}
fn DeferInterrupts(t: *rust_task) -> DeferInterrupts {
DeferInterrupts {
t: t
}
}
unsafe {
let t = rt::rust_get_task();
let _interrupts = DeferInterrupts(t);
rt::rust_task_inhibit_kill(t);
rt::rust_task_inhibit_yield(t);
f()
do (|| {
f()
}).finally {
rt::rust_task_allow_yield(t);
rt::rust_task_allow_kill(t);
}
}
}

23
src/libcore/unstable.rs
View File

@ -16,6 +16,7 @@ use comm::{GenericChan, GenericPort};
use prelude::*;
use task;
use task::atomically;
use self::finally::Finally;
#[path = "unstable/at_exit.rs"]
pub mod at_exit;
@ -229,25 +230,13 @@ fn LittleLock() -> LittleLock {
pub impl LittleLock {
#[inline(always)]
unsafe fn lock<T>(&self, f: &fn() -> T) -> T {
struct Unlock {
l: rust_little_lock,
drop {
unsafe {
rustrt::rust_unlock_little_lock(self.l);
}
}
}
fn Unlock(l: rust_little_lock) -> Unlock {
Unlock {
l: l
}
}
do atomically {
rustrt::rust_lock_little_lock(self.l);
let _r = Unlock(self.l);
f()
do (|| {
f()
}).finally {
rustrt::rust_unlock_little_lock(self.l);
}
}
}
}