Cross-Language Interop

In this lesson, you will learn how to leverage procedural macros to automatically generate the boilerplate glue code required to bridge Rust functions with foreign environments like C or C++.

When working with FFI (Foreign Function Interface), we often face a tedious mapping problem: Rust’s rich error types (like Result<T, E>) cannot pass across the ABI boundary. To safely interop, we must manually convert these into primitive status codes or pointers that the foreign caller expects. Automating this via a procedural macro allows us to enforce consistent error handling without bloating our domain logic.

The Macro Strategy

Instead of writing manual wrappers for every exported function, we define an attribute macro, #[ffi_export], which intercepts the function definition, generates a C-compatible shim, and handles the conversion of Result types into a uniform error integer.

Consider this illustration:

#[ffi_export]
fn process_data(input: *const c_char) -> Result<i32, MyError> {
    // Domain logic...
    Ok(42)
}

The macro expands this into two parts:

1. The original Rust function, kept as-is (but perhaps made private or renamed).
2. An extern "C" wrapper that catches potential panic!s using catch_unwind and maps the Result into a numeric error code:

#[no_mangle]
pub extern "C" fn process_data_ffi(input: *const c_char) -> i32 {
    let result = std::panic::catch_unwind(|| process_data(input));
    match result {
        Ok(Ok(val)) => val,
        Ok(Err(e)) => e.to_int_code(), // Map custom error to FFI code
        Err(_) => -1,                 // Panic caught, return generic error
    }
}

Why This Matters

By using a procedural macro to transform the function signature, you ensure that every exported symbol follows the exact same safety protocol. If your internal error enum grows, you only need to update the macro’s mapping logic rather than refactoring dozens of manual extern "C" wrappers. This approach effectively treats the FFI layer as a generated contract, reducing the risk of memory unsafety or unhandled exceptions leaking across the language barrier.

Key Takeaway: Use procedural macros to transform idiomatic Rust functions into safe, standardized C-compatible wrappers, ensuring consistent error mapping and panic boundary protection at the FFI edge.