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
|
//! Rust interface for Objective-C's `@throw` and `@try`/`@catch` statements.
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;
}
/// An opaque type representing any Objective-C object thrown as an exception.
pub enum Exception { }
/// Throws an Objective-C exception.
/// The argument must be a pointer to an Objective-C object.
///
/// Unsafe because this unwinds from Objective-C.
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() {
// This is always passed Some, so it's safe to unwrap
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);
// Wrap the closure in an Option so it can be taken
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 _)
}
}
/// Tries to execute the given closure and catches an Objective-C exception
/// if one is thrown.
///
/// Returns a `Result` that is either `Ok` if the closure succeeded without an
/// exception being thrown, or an `Err` with a pointer to an exception if one
/// was thrown. The exception is retained and so must be released.
///
/// Unsafe because this encourages unwinding through the closure from
/// Objective-C, which is not safe.
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());
})
};
// If the try succeeded, this was set so it's safe to unwrap
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!");
}
}
}
|
