Struct libffi::middle::Cif

pub struct Cif { /* fields omitted */ }

Describes the calling convention and types for calling a function.

This is the middle layer’s wrapping of the low and raw layers’ ffi_cif. An initialized CIF contains references to an array of argument types and a result type, each of which may be allocated on the heap. Cif manages the memory of those referenced objects.

Construct with Cif::new or Cif::from_type_array.

Examples

extern "C" fn add(x: f64, y: &f64) -> f64 {
    return x + y;
}

use libffi::middle::*;

let args = vec![Type::f64(), Type::pointer()];
let cif = Cif::new(args.into_iter(), Type::f64());

let n = unsafe { cif.call(CodePtr(add as *mut _), &[arg(&5), arg(&&6)]) };
assert_eq!(11, n);

Methods

impl Cif

fn new<I>(args: I, result: Type) -> Self where I: ExactSizeIterator<Item=Type>

Creates a new CIF for the given argument and result types.

Takes ownership of the argument and result Types, because the resulting Cif retains references to them. Defaults to the platform’s default calling convention; this can be adjusted using set_abi.

unsafe fn call<R>(&self, fun: CodePtr, args: &[Arg]) -> R

Calls a function with the given arguments.

In particular, this method invokes function fun passing it arguments args, and returns the result.

Safety

There is no checking that the calling convention and types in the Cif match the actual calling convention and types of fun, nor that they match the types of args.

fn set_abi(&mut self, abi: FfiAbi)

Sets the CIF to use the given calling convention.

fn as_raw_ptr(&self) -> *mut ffi_cif

Gets a raw pointer to the underlying ffi_cif.

This can be used for passing a middle::Cif to functions from the low and raw modules.

Trait Implementations

impl Debug for Cif

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Clone for Cif

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.