$ ldd /usr/bin/bash
    linux-vdso.so.1 (0x000075e7daf61000)
    libreadline.so.8 => /usr/lib/libreadline.so.8 (0x000075e7dadbc000)
    libc.so.6 => /usr/lib/libc.so.6 (0x000075e7dabcb000)
    libncursesw.so.6 => /usr/lib/libncursesw.so.6 (0x000075e7dab5c000)
    /lib64/ld-linux-x86-64.so.2 => /usr/lib64/ld-linux-x86-64.so.2 (0x000075e7daf63000)

int main() {
    char buff[256] = /* file contents */;

    lua_State* L = luaL_newstate();
    luaL_openlibs(L);

    int error;
    error = luaL_loadbuffer(L, buff, strlen(buff), "file");
    if (error) { /* error handling */ }

    error = lua_pcall(L, 0, 0, 0);
    if (error) { /* error handling */ }

    lua_close(L);
    return 0;
}

$ nm --dynamic --defined-only /usr/lib64/liblua.so.5.4
0000000000006750 T lua_absindex
0000000000006e00 T lua_arith
0000000000006720 T lua_atpanic
000000000000dea0 T lua_callk
000000000000de20 T lua_checkstack
0000000000014500 T lua_close
...

Disassembly of section .text:

0000000000028050 <luaL_newstate@@Base>:
   28050:    f3 0f 1e fa             endbr64
   28054:    55                      push   %rbp
   28055:    31 f6                   xor    %esi,%esi
   28057:    48 8d 3d 12 5a ff ff    lea    -0xa5ee(%rip),%rdi        # 1da70 <lua_close@@Base+0x9570>
   2805e:    48 89 e5                mov    %rsp,%rbp
   28061:    53                      push   %rbx
   28062:    48 83 ec 08             sub    $0x8,%rsp
   28066:    ff 15 24 ac 01 00       call   *0x1ac24(%rip)        # 42c90 <lua_newstate@@Base+0x2ea30>
   2806c:    48 89 c3                mov    %rax,%rbx
   2806f:    48 85 c0                test   %rax,%rax
   28072:    74 23                   je     28097 <luaL_newstate@@Base+0x47>
   28074:    48 8d 35 d5 ce ff ff    lea    -0x312b(%rip),%rsi        # 24f50 <lua_close@@Base+0x10a50>
   2807b:    48 89 c7                mov    %rax,%rdi
   2807e:    ff 15 74 ac 01 00       call   *0x1ac74(%rip)        # 42cf8 <lua_atpanic@@Base+0x3c5d8>
   28084:    48 89 da                mov    %rbx,%rdx
   28087:    48 8d 35 a2 f0 ff ff    lea    -0xf5e(%rip),%rsi        # 27130 <luaL_requiref@@Base+0x110>
   2808e:    48 89 df                mov    %rbx,%rdi
   28091:    ff 15 19 ae 01 00       call   *0x1ae19(%rip)        # 42eb0 <lua_setwarnf@@Base+0x3a2b0>
   28097:    48 89 d8                mov    %rbx,%rax
   2809a:    48 8b 5d f8             mov    -0x8(%rbp),%rbx
   2809e:    c9                      leave
   2809f:    c3                      ret

lua_State *luaL_newstate(void);

int luaL_loadbuffer(lua_State *L,
                    const char *buff,
                    size_t sz,
                    const char *name);

use std::ffi::{c_void, c_char, c_int};

#[repr(transparent)]
pub struct LuaState(pub *mut c_void);

extern "C" {
    fn luaL_newstate() -> LuaState;
    fn luaL_openlibs(state: LuaState);
    fn luaL_loadbuffer(
        state: LuaState,
        buff: *const c_char,
        sz: usize,
        name: *const c_char
    ) -> c_int;
    fn lua_pcall(state: LuaState, nargs: c_int, nresults: c_int, msgh: c_int) -> c_int;
}

use std::ffi::c_int;

pub enum LuaState {}

extern "C" {
    fn luaL_newstate() -> *mut LuaState;
    fn luaL_openlibs(state: *mut LuaState);
    fn luaL_loadbuffer(
        state: *mut LuaState,
        buff: *const u8,
        sz: usize,
        name: *const i8
    ) -> c_int;
    fn lua_pcall(state: *mut LuaState, nargs: c_int, nresults: c_int, msgh: c_int) -> c_int;
}

extern "C" {
    fn add_in_c(a: c_int, b: c_int) -> c_int;
}

// може да се пропусне - подразбира се "C".
extern {
    fn mul_in_c(a: c_int, b: c_int) -> c_int;
}

// някои функции могат да имат различна конвенция за извикване - например winapi функциите.
extern "system" {
    fn SetEnvironmentVariableA(n: *const u8, v: *const u8) -> c_int;
}

fn main() {
    let file_name = "my_file.lua";
    let file_contents = std::fs::read_to_string(file_name).unwrap();

    unsafe {
        let lua_state = luaL_newstate();
        luaL_openlibs(lua_state);

        let error = luaL_loadbuffer(
            lua_state,
            file_contents.as_bytes().as_ptr(),
            file_contents.as_bytes().len(),
            b"file\0".as_ptr() as *const i8,
        );
        if error != 0 {
            panic!("failed loading lua code");
        }

        let error = lua_pcall(lua_state, 0, 0, 0);
        if error != 0 {
            panic!("failed running lua code");
        }
    }
}

use std::ffi::CStr;

let hello = CStr::from_bytes_with_nul(b"hello, world!\0").unwrap();
// hello: &'static CStr

let hello = c"hello, world!";
// hello: &'static CStr

// Do this:
let cstr = CString::new("Hello").unwrap();
unsafe { c_func(cstr.as_ptr()) };

// Do not do this:
unsafe {
    c_func(CString::new("Hello").unwrap().as_ptr()); 
}

fn main() {
    let file_name = "my_file.lua";
    let file_contents = std::fs::read_to_string(file_name).unwrap();

    unsafe {
        let lua_state = luaL_newstate();
        luaL_openlibs(lua_state);

        let error = luaL_loadbuffer(
            lua_state,
            file_contents.as_bytes().as_ptr(),
            file_contents.as_bytes().len(),
            b"file\0".as_ptr() as *const i8,
        );
        if error != 0 {
            panic!("failed loading lua code");
        }

        let error = lua_pcall(lua_state, 0, 0, 0);
        if error != 0 {
            panic!("failed running lua code");
        }
    }
}

use std::ffi::c_int;

pub enum LuaState {}

#[link(name = "lua")]
extern "C" {
    fn luaL_newstate() -> *mut LuaState;
    fn luaL_openlibs(state: *mut LuaState);
    fn luaL_loadbuffer(state: *mut LuaState, buff: *const u8, sz: usize, name: *const i8) -> c_int;
    fn lua_pcall(state: *mut LuaState, nargs: c_int, nresults: c_int, msgh: c_int) -> c_int;
}

use std::ffi::c_int;

pub enum LuaState {}

#[link(name = "lua")]
extern {}

extern "C" {
    fn luaL_newstate() -> *mut LuaState;
    fn luaL_openlibs(state: *mut LuaState);
    fn luaL_loadbuffer(state: *mut LuaState, buff: *const u8, sz: usize, name: *const i8) -> c_int;
    fn lua_pcall(state: *mut LuaState, nargs: c_int, nresults: c_int, msgh: c_int) -> c_int;
}

cargo rustc -- -l lua

[build]
rustflags = ["-l", "lua"]

undefined reference to `luaL_loadbuffer'
undefined reference to `lua_pcall'

#define luaL_loadbuffer(L,s,sz,n)    luaL_loadbufferx(L,s,sz,n,NULL)
#define lua_pcall(L,n,r,f)    lua_pcallk(L, (n), (r), (f), 0, NULL)

use std::ffi::c_int;
use std::ptr;

pub enum LuaState {}
type LuaKContext = isize;
type LuaKFunction = Option<extern "C" fn (*const LuaState, c_int, LuaKContext) -> c_int>;

#[allow(non_snake_case)]
unsafe fn luaL_loadbuffer(state: *mut LuaState, buff: *const u8, sz: usize, name: *const i8) -> c_int {
    luaL_loadbufferx(state, buff, sz, name, ptr::null())
}

unsafe fn lua_pcall(state: *mut LuaState, nargs: c_int, nresults: c_int, msgh: c_int) -> c_int {
    lua_pcallk(state, nargs, nresults, msgh, 0, None)
}

#[link(name = "lua")]
extern "C" {
    fn luaL_newstate() -> *mut LuaState;
    fn luaL_openlibs(state: *mut LuaState);
    fn luaL_loadbufferx(state: *mut LuaState, buff: *const u8, sz: usize, name: *const i8, mode: *const i8) -> c_int;
    fn lua_pcallk(state: *mut LuaState, nargs: c_int, nresults: c_int, msgh: c_int, ctx: LuaKContext, k: LuaKFunction) -> c_int;
}

use std::ffi::c_int;
use std::ptr;

pub enum LuaState {}
type LuaKContext = isize;
type LuaKFunction = Option<extern "C" fn (*const LuaState, c_int, LuaKContext) -> c_int>;

#[allow(non_snake_case)]
unsafe fn luaL_loadbuffer(state: *mut LuaState, buff: *const u8, sz: usize, name: *const i8) -> c_int {
    luaL_loadbufferx(state, buff, sz, name, ptr::null())
}

unsafe fn lua_pcall(state: *mut LuaState, nargs: c_int, nresults: c_int, msgh: c_int) -> c_int {
    lua_pcallk(state, nargs, nresults, msgh, 0, None)
}

#[link(name = "lua")]
extern "C" {
    fn luaL_newstate() -> *mut LuaState;
    fn luaL_openlibs(state: *mut LuaState);
    fn luaL_loadbufferx(state: *mut LuaState, buff: *const u8, sz: usize, name: *const i8, mode: *const i8) -> c_int;
    fn lua_pcallk(state: *mut LuaState, nargs: c_int, nresults: c_int, msgh: c_int, ctx: LuaKContext, k: LuaKFunction) -> c_int;
}

fn main() {
    let file_name = "my_file.lua";
    let file_contents = std::fs::read_to_string(file_name).unwrap();

    unsafe {
        let lua_state = luaL_newstate();
        luaL_openlibs(lua_state);

        let error = luaL_loadbuffer(
            lua_state,
            file_contents.as_bytes().as_ptr(),
            file_contents.as_bytes().len(),
            b"file\0".as_ptr(),
        );
        if error != 0 {
            panic!("failed loading lua code");
        }

        let error = lua_pcall(lua_state, 0, 0, 0);
        if error != 0 {
            panic!("failed running lua code");
        }
    }
}

use std::ffi::CStr;

mod ffi {
    /* генерирани binding-и */
}

#[derive(Debug)]
pub enum LuaError {
    RuntimeError,
    InvalidSyntax,
    OutOfMemory,
    Unknown(i32),
}

// ownership - няма clone/copy
pub struct LuaState {
    state: *mut ffi::LuaState,
}

impl LuaState {
    // error handling
    pub fn new() -> Option<Self> {
        let state_ptr = unsafe { ffi::luaL_newstate() };
        if state_ptr.is_null() {
            None
        } else {
            Some(LuaState { state: state_ptr })
        }
    }

    // използване на конкретни типове, носещи допълнителна информация:
    // - `&[u8]` вместо `*const u8, usize` - буфер от байтове, няма терминираща нула
    // - `&CStr` вместо `*const i8` - низа трябва да завършва с терминираща нула
    //
    // конвертиране на резултата до ръстски Result
    pub fn load_buffer(&mut self, buff: &[u8], name: &CStr) -> Result<(), LuaError> {
        let res = unsafe { ffi::luaL_loadbuffer(self.state, buff.as_ptr(), buff.len(), name.as_ptr()) };
        match res {
            ffi::LUA_OK => Ok(()),
            ffi::LUA_ERRSYNTAX => Err(LuaError::InvalidSyntax),
            ffi::LUA_ERRMEM => Err(LuaError::OutOfMemory),
            n => Err(LuaError::Unknown(n)),
        }
    }

    // връща низ с коректния lifetime (низа се държи от lua_State)
    // и коректното ограничение (lua_State не трябва да се модифицира, докато се използва низа)
    pub fn to_string(&mut self, index: i32) -> Option<&CStr> {
        unsafe {
            let mut out_len = 0;
            let ptr = ffi::lua_tolstring(self.state, index, &mut out_len);

            if ptr.is_null() {
                None
            } else {
                let cstr_bytes = std::slice::from_raw_parts(ptr as *const u8, out_len + 1);
                Some(CStr::from_bytes_with_nul_unchecked(cstr_bytes))
            }
        }
    }
}

// автоматично деструктиране
impl Drop for LuaState {
    fn drop(&mut self) {
        unsafe { ffi::lua_close(self.state) };
    }
}

[package]
name = "project-name"
version = "0.1.0"

[lib]
crate-type = ["..."]

[dependencies]

[package]
name = "project-name"
version = "0.1.0"

[lib]
crate-type = ["cdylib"]

[dependencies]

#[no_mangle]
pub extern "C" fn add_from_rust(left: i32, right: i32) -> i32 {
    left + right
}

#[export_name = "mul_from_rust"]
pub extern "C" fn my_mul(left: i32, right: i32) -> i32 {
    left * right
}

$ nm --dynamic --defined-only target/debug/libdylib_test.so
0000000000006330 T add_from_rust
0000000000006370 T mul_from_rust

#[unsafe(no_mangle)]
pub extern "C" fn add_from_rust(left: i32, right: i32) -> i32 {
    left + right
}

#[unsafe(export_name = "mul_from_rust")]
pub extern "C" fn my_mul(left: i32, right: i32) -> i32 {
    left * right
}

int32_t add_from_rust(int32_t a, int32_t b);
int32_t mul_from_rust(int32_t a, int32_t b);

int main() {
    int seven = add_from_rust(5, 2);
    int ten = mul_from_rust(5, 2);
}

// на Rust

struct FooBar {
    foo: c_int,
    bar: c_short,
}

extern "C" {
    fn foobar(foobar: FooBar); 
}