Struct RUnwind 

pub(crate) struct RUnwind {
    token: SEXP,
    boundary: u64,
}

An R non-local exit that call_unwinding carries out of its callback as a Rust unwind: an error, a condition caught by an exiting handler set up outside the call (tryCatch(warning = )), a restart, an interrupt.

The unwind runs the destructors of the Rust frames between the evaluation and the boundary that catches it. The boundary (run_r_unwind_protect, the worker’s main-thread loop, the FFI guards) then resumes the exit with R_ContinueUnwind, and R carries on to the context it was jumping to, with the condition object and call it was jumping with.

The continuation token is private to one evaluation and preserved until the exit resumes, so R code that a destructor runs during the unwind (a protected call of its own, which reuses the shared token) cannot overwrite the pending jump or let the collector reclaim it (#1507).

Fields

token: SEXP

R_MakeUnwindCont(), preserved: the jump target and the value R was jumping with.

boundary: u64

The Boundary that was innermost when the evaluation started.

Implementations

impl RUnwind

pub(crate) fn belongs_to(&self, boundary: &Boundary) -> bool

Whether boundary may resume this exit: the boundary its evaluation ran in, still on the stack.

pub(crate) unsafe fn resume(self) -> !

Continue the R exit where R_UnwindProtect stopped it. Never returns.

Safety

R’s main thread, at the boundary the exit belongs_to, after its Boundary::leave, with no Rust value left to drop between this call and the R context that owns the frame (the C entry point R called).

pub(crate) fn stray(self: Box<Self>) -> Box<dyn Any + Send>

The payload a boundary raises in place of an exit it may not resume (see Boundary). The exit is dropped.

Trait Implementations

impl Drop for RUnwind

fn drop(&mut self)

Reached when something other than the exit’s boundary caught the unwind and dropped it, or the boundary refused it (RUnwind::stray). The R exit is abandoned: R carries on from where the evaluation stopped, as after R_tryEval. Release the token, on R’s main thread: dropped on another thread (code that moved the caught payload there), it waits in ABANDONED_OFF_MAIN for the next evaluation.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 16 bytes