pub unsafe fn raise(interp: Artichoke, exception: impl RubyException) -> ! {
    // Ensure the borrow is out of scope by the time we eval code since
    // Rust-backed files and types may need to mutably borrow the `Artichoke` to
    // get access to the underlying `ArtichokeState`.
    let mrb = interp.0.borrow().mrb;

    let spec = exception.class();
    let borrow = spec.borrow();
    let eclass = if let Some(rclass) = borrow.rclass(&interp) {
        rclass
    } else {
        error!("unable to raise {}", borrow.name());
        panic!("unable to raise {}", borrow.name());
    };
    let formatargs = interp.convert(exception.message()).inner();
    // `mrb_sys_raise` will call longjmp which will unwind the stack.
    // Any non-`Copy` objects that we haven't cleaned up at this point will
    // leak, so drop everything.
    drop(borrow);
    drop(spec);
    drop(interp);
    drop(exception);

    sys::mrb_raisef(mrb, eclass, b"%S\0".as_ptr() as *const i8, formatargs);
    unreachable!("mrb_raisef will unwind the stack with longjmp");
}
/// Raise implementation for `RubyException` boxed trait objects.
///
/// # Safety
///
/// This function unwinds the stack with `longjmp`, which will ignore all Rust
/// landing pads for panics and exit routines for cleaning up borrows. Callers
/// should ensure that only [`Copy`] items are alive in the current stack frame.
///
/// Because this precondition must hold for all frames between the caller and
/// the closest [`sys::mrb_protect`] landing pad, this function should only be
/// called in the entrypoint into Rust from mruby.
Raise implementation for `RubyException` boxed trait objects.
Raise implementation for ` RubyException ` boxed trait objects .
pub unsafe fn raise(interp: Artichoke, exception: impl RubyException) -> ! {
    // Ensure the borrow is out of scope by the time we eval code since
    // Rust-backed files and types may need to mutably borrow the `Artichoke` to
    // get access to the underlying `ArtichokeState`.
    let mrb = interp.0.borrow().mrb;
    let spec = exception.class();
    let borrow = spec.borrow();
    let eclass = if let Some(rclass) = borrow.rclass(&interp) {
        rclass
    } else {
        error!("unable to raise {}", borrow.name());
        panic!("unable to raise {}", borrow.name());
    };
    let formatargs = interp.convert(exception.message()).inner();
    // `mrb_sys_raise` will call longjmp which will unwind the stack.
    // Any non-`Copy` objects that we haven't cleaned up at this point will
    // leak, so drop everything.
    drop(borrow);
    drop(spec);
    drop(interp);
    drop(exception);
    sys::mrb_raisef(mrb, eclass, b"%S\0".as_ptr() as *const i8, formatargs);
    unreachable!("mrb_raisef will unwind the stack with longjmp");
}
pub unsafe fn raise ( interp : Artichoke , exception : impl RubyException ) -> ! { // Ensure the borrow is out of scope by the time we eval code since // Rust-backed files and types may need to mutably borrow the `Artichoke` to // get access to the underlying `ArtichokeState`. let mrb = interp . 0 . borrow ( ) . mrb ; let spec = exception . class ( ) ; let borrow = spec . borrow ( ) ; let eclass = if let Some ( rclass ) = borrow . rclass ( & interp ) { rclass } else { error ! ( " " borrow name ( ) ) ; panic ! ( " " borrow name ( ) ) ; } ; let formatargs = interp . convert ( exception . message ( ) ) . inner ( ) ; // `mrb_sys_raise` will call longjmp which will unwind the stack. // Any non-`Copy` objects that we haven't cleaned up at this point will // leak, so drop everything. drop ( borrow ) ; drop ( spec ) ; drop ( interp ) ; drop ( exception ) ; sys :: mrb_raisef ( mrb , eclass , b" \0 " . as_ptr ( ) as * const i8 , formatargs ) ; unreachable ! ( " " ) ; }
Raise implementation for `RubyException` boxed trait objects.
Raise implementation for ` RubyException ` boxed trait objects .
interp
Artichoke
exception
impl RubyException
safety
This function unwinds the stack with `longjmp`, which will ignore all Rust
landing pads for panics and exit routines for cleaning up borrows. Callers
should ensure that only [`Copy`] items are alive in the current stack frame.

Because this precondition must hold for all frames between the caller and
the closest [`sys::mrb_protect`] landing pad, this function should only be
called in the entrypoint into Rust from mruby.
This function unwinds the stack with ` longjmp ` which will ignore all Rust landing pads for panics and exit routines for cleaning up borrows . Callers should ensure that only [ ` Copy ` ] items are alive in the current stack frame . Because this precondition must hold for all frames between the caller and the closest [ ` sys :: mrb_protect ` ] landing pad this function should only be called in the entrypoint into Rust from mruby .