Foreign Function Interface

Rust provides a Foreign Function Interface (FFI) to C libraries. Foreign
functions must be declared inside an extern block annotated with a #[link]
attribute containing the name of the foreign library.

  1. use std::fmt;
  3. // this extern block links to the libm library
  4. #[link(name = "m")]
  5. extern {
  6.     // this is a foreign function
  7.     // that computes the square root of a single precision complex number
  8.     fn csqrtf(z: Complex) -> Complex;
  10.     fn ccosf(z: Complex) -> Complex;
  11. }
  13. // Since calling foreign functions is considered unsafe,
  14. // it's common to write safe wrappers around them.
  15. fn cos(z: Complex) -> Complex {
  16.     unsafe { ccosf(z) }
  17. }
  19. fn main() {
  20.     // z = -1 + 0i
  21.     let z = Complex { re: -1., im: 0. };
  23.     // calling a foreign function is an unsafe operation
  24.     let z_sqrt = unsafe { csqrtf(z) };
  26.     println!("the square root of {:?} is {:?}", z, z_sqrt);
  28.     // calling safe API wrapped around unsafe operation
  29.     println!("cos({:?}) = {:?}", z, cos(z));
  30. }
  32. // Minimal implementation of single precision complex numbers
  33. #[repr(C)]
  34. #[derive(Clone, Copy)]
  35. struct Complex {
  36.     re: f32,
  37.     im: f32,
  38. }
  40. impl fmt::Debug for Complex {
  41.     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  42.         if self.im < 0. {
  43.             write!(f, "{}-{}i", self.re, -self.im)
  44.         } else {
  45.             write!(f, "{}+{}i", self.re, self.im)
  46.         }
  47.     }
  48. }