1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
use std::mem;
use std::os::raw::{c_int, c_void};
use std::ptr;
#[link(name = "objc", kind = "dylib")]
extern { }
extern {
fn RustObjCExceptionThrow(exception: *mut c_void);
fn RustObjCExceptionTryCatch(try: extern fn(*mut c_void),
context: *mut c_void, error: *mut *mut c_void) -> c_int;
}
pub enum Exception { }
pub unsafe fn throw(exception: *mut Exception) -> ! {
RustObjCExceptionThrow(exception as *mut _);
unreachable!();
}
unsafe fn try_no_ret<F>(closure: F) -> Result<(), *mut Exception>
where F: FnOnce() {
extern fn try_objc_execute_closure<F>(closure: &mut Option<F>)
where F: FnOnce() {
let closure = closure.take().unwrap();
closure();
}
let f: extern fn(&mut Option<F>) = try_objc_execute_closure;
let f: extern fn(*mut c_void) = mem::transmute(f);
let mut closure = Some(closure);
let context = &mut closure as *mut _ as *mut c_void;
let mut exception = ptr::null_mut();
let success = RustObjCExceptionTryCatch(f, context, &mut exception);
if success == 0 {
Ok(())
} else {
Err(exception as *mut _)
}
}
pub unsafe fn try<F, R>(closure: F) -> Result<R, *mut Exception>
where F: FnOnce() -> R {
let mut value = None;
let result = {
let value_ref = &mut value;
try_no_ret(move || {
*value_ref = Some(closure());
})
};
result.map(|_| value.unwrap())
}
#[cfg(test)]
mod tests {
use std::ptr;
use super::{throw, try};
#[test]
fn test_try() {
unsafe {
let s = "Hello".to_string();
let result = try(move || {
if s.len() > 0 {
throw(ptr::null_mut());
}
s.len()
});
assert!(result.unwrap_err() == ptr::null_mut());
let mut s = "Hello".to_string();
let result = try(move || {
s.push_str(", World!");
s
});
assert!(result.unwrap() == "Hello, World!");
}
}
}