Files
embbed-rust/src/interoperability/index.md
Adam Green 6e9007e144 Have mdBook not wrap code snippets in "fn main() {}"
This is the same change as in commit c5caa3b but for the instances I
noticed in the rest of the chapters.

Before this change, clicking on the icon to copy the code snippet to
the clipboard would result in:
```rust
fn main() {
// Exception handler for the SysTick (System Timer) exception
fn SysTick() {
    // ..
}
}
```
After this change, the following is copied to the clipboard instead:
```rust
// Exception handler for the SysTick (System Timer) exception
fn SysTick() {
    // ..
}
```
2018-11-17 23:54:10 -08:00

2.1 KiB

Interoperability

Interoperability between Rust and C code is always dependent on transforming data between the two languages. For this purposes there are two dedicated modules in the stdlib called std::ffi and std::os::raw.

std::os::raw deals with low-level primitive types that can be converted implicitly by the compiler because the memory layout between Rust and C is similar enough or the same.

std::ffi provides some utility for converting more complex types such as Strings, mapping both &str and String to C-types that are easier and safer to handle.

Neither of these modules are available in core, but you can find a #![no_std] compatible version of std::ffi::{CStr,CString} in the cstr_core crate, and most of the std::os::raw types in the cty crate.

Rust type Intermediate C type
String CString *char
&str CStr *const char
() c_void void
u32 or u64 c_uint unsigned int
etc ... ...

As mentioned above, primitive types can be converted by the compiler implicitly.

unsafe fn foo(num: u32) {
    let c_num: c_uint = num;
    let r_num: u32 = c_num;
}

Interoperability with other build systems

A common requirement for including Rust in your embedded project is combining Cargo with your existing build system, such as make or cmake.

We are collecting examples and use cases for this on our issue tracker in issue #61.

Interoperability with RTOSs

Integrating Rust with an RTOS such as FreeRTOS or ChibiOS is still a work in progress; especially calling RTOS functions from Rust can be tricky.

We are collecting examples and use cases for this on our issue tracker in issue #62.