The Demo That Automatically Generates Rust Static Link Bindings For The C Project With bindgen and cc::Builder

[Euraxluo]

I have created a small demo project to showcase how to generate Rust static linking bindings for C projects. I have tested the project with the gcc compiler on Unix and the cl compiler on Windows, and it seems to be working fine.
PS:This is my pre-research for creating rust bindings for the LKH-3

the C project named LKHDemo in source_code dir：

.
├── CMakeLists.txt
├── Makefile
├── SRC
│   ├── GetTime.c
│   ├── INCLUDE
│   │   ├── demo.h
│   │   └── demo2.h
│   ├── LKHmain.c
│   ├── Makefile
│   ├── demo.c
│   └── demo2.c
└── test.sh

content:

file_name：.gitignore

build
SRC/OBJ/*

file_name：CMakeLists.txt

CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
MESSAGE(STATUS "CMAKE_VERSION:${CMAKE_VERSION}")
#set(CMAKE_CXX_FLAGS "-O3 -Og -Wall -g -fPIC -ggdb ")
#set(CFLAGS          "-O3 -Og -Wall -g -fPIC -ggdb ")
#MESSAGE(STATUS "CFLAGS:${CFLAGS}")
#MESSAGE(STATUS "CMAKE_CXX_FLAGS:${CMAKE_CXX_FLAGS}")
SET(TARGET_NAME LKHTool)
PROJECT(${TARGET_NAME})
MESSAGE(STATUS "TARGET_NAME:${TARGET_NAME}")
include_directories(${PROJECT_SOURCE_DIR}/SRC/INCLUDE)
SET(SRC_LISTS 
    ./SRC/GetTime.c
    ./SRC/demo.c
    ./SRC/demo2.c
    ./SRC/LKHmain.cpp
)
MESSAGE(STATUS "Build So")
add_library(${TARGET_NAME} SHARED ${SRC_LISTS})
#mkdir build && cd build
#cmake .. && make
#cd ../SRC && gcc -o ../build/LKH LKHmain.c -I./INCLUDE -L../build  -Wl,-rpath=../build  -l LKHTool
#OSX:cd ../SRC && gcc -o ../build/LKH LKHmain.c -I./INCLUDE -L../build    -l LKHTool
#../build/LKH

file_name：Makefile

all:
	make -C SRC
clean:
	make -C SRC clean

file_name：demo.c

#include "demo.h"
#include <stdio.h>
void hello() {
  printf("Hello from C!\n");
}
int add(int a, int b) {
  return a + b;
}

file_name：demo2.c

#include "demo2.h"
#include <stdio.h>
void bye() {
  printf("Bye from C!\n");
}
double multiply(double a, double b) {
  return a * b;
}

file_name：GetTime.c

#define HAVE_GETRUSAGE
/* Undefine if you don't have the getrusage function */
#undef HAVE_GETRUSAGE
/*
 * The GetTime function is used to measure execution time.
 *
 * The function is called before and after the code to be 
 * measured. The difference between the second and the
 * first call gives the number of seconds spent in executing
 * the code.
 *
 * If the system call getrusage() is supported, the difference 
 * gives the user time used; otherwise, the accounted real time.
 */
#ifdef HAVE_GETRUSAGE
#include <sys/time.h>
#include <sys/resource.h>
double GetTime()
{
    struct rusage ru;
    getrusage(RUSAGE_SELF, &ru);
    return ru.ru_utime.tv_sec + ru.ru_utime.tv_usec / 1000000.0;
}
#else
#include <time.h>
double GetTime()
{
    return (double) clock() / CLOCKS_PER_SEC;
}
#endif

file_name：demo.h

// demo.h
#ifndef DEMO_H 
#define DEMO_H
void hello();
int add(int a, int b);
#endif // DEMO_H

file_name：demo2.h

// demo.h
#ifndef DEMO2_H
#define DEMO2_H
void bye();
double multiply(double a, double b);
double GetTime(void);
#endif // DEMO2_H

file_name：LKHmain.c

//extern "C"{
#include "demo.h"
#include "demo2.h"
//}
#include <stdio.h>
int main() {
  hello();
  printf("%d\n", add(1, 2));
  bye();
  printf("%f\n", multiply(2.5, 3.0));
  printf("%f\n",GetTime());
  return 0;
}

file_name：Makefile

TREE_TYPE = TWO_LEVEL_TREE
# TREE_TYPE = THREE_LEVEL_TREE
# TREE_TYPE = ONE_LEVEL_TREE
# CC = gcc
IDIR = INCLUDE
ODIR = OBJ
CFLAGS = -O3 -Wall -I$(IDIR) -D$(TREE_TYPE) -g -fcommon
_DEPS = demo.h demo2.h
DEPS = $(patsubst %,$(IDIR)/%,$(_DEPS))
_OBJ = demo.o demo2.o LKHmain.o  GetTime.o
OBJ = $(patsubst %,$(ODIR)/%,$(_OBJ))
$(ODIR)/%.o: %.c $(DEPS)
	$(CC) -c -o $@ $< $(CFLAGS)
.PHONY: 
	all clean
all:
	$(MAKE) LKH
LKH: $(OBJ) $(DEPS)
	$(CC) -o ../LKH $(OBJ) $(CFLAGS) -lm
clean:
	/bin/rm -f $(ODIR)/*.o ../LKH *~ ._* $(IDIR)/*~ $(IDIR)/._* 

rust project tree:
.
├── Cargo.lock
├── Cargo.toml
├── READMD.md
├── build.rs
├── build.yaml
├── source_code
│   ├── LKHDemo
│   └── wrapper.h
└── src
├── bindings.rs
├── lib.rs
└── main.rs

the bindings.rs and wrapper.h is auto gen!

src code:
file_name：src/lib.rs

#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
include!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/bindings.rs"));

file_name：src/main.rs

use LKH::*;
fn main() {
    println!("hello lkh");
    unsafe {
        hello();
        println!("{}", add(1, 2));
        bye();
        bye();
        bye();
        bye();
        bye();
        bye();
        bye();
        bye();
        bye();
        bye();
        bye();
        bye();
        bye();
        bye();
        bye();
        bye();
        bye();
        bye();
        loop {
            println!("{}", multiply(2.5, 3.0));
            println!("{}", GetTime());
        }
    }
}

at cargo.toml dir,file content there
file_name：build.rs

#![allow(warnings, unused)]
use bindgen::Bindings;
use cc;
use dunce;
use serde::Deserialize;
use std::collections::hash_map;
use std::ffi::OsStr;
use std::fmt::Display;
use std::fs::File;
use std::hash::Hasher;
use std::io::Write;
use std::path::{Component, Path, PathBuf};
use std::{env, fs, io};
macro_rules! log {
    ($($tokens: tt)*) => {
        let config_str =format!($($tokens)*);
        for line in config_str.lines() {
            println!("cargo:info={}", line);
        }
    }
}
const CONFIG_FILE: &str = "build.yaml";
#[derive(Debug, Deserialize)]
struct Config {
    pub lkh_home: String,
    pub lkh_obj_dir: Option<String>,
    pub lkh_src_dir: String,
    pub lkh_header_dir: String,
    pub lkh_wrapper_header: String,
    pub compile_bin: Option<String>,
    pub flags: Vec<String>,
}
impl Config {
    // path normalize
    fn normalize_paths(&mut self) {
        let cargo_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
        log!("cargo_path:{:#?}", cargo_path);
        self.lkh_home = path_to_string(Path::new(&self.lkh_home), &cargo_path, true);
        self.lkh_obj_dir = match &self.lkh_obj_dir {
            Some(dir) => Some(path_to_string(Path::new(&dir), &cargo_path, true)),
            _ => Some(
                env::var_os("OUT_DIR")
                    .unwrap()
                    .to_str()
                    .unwrap()
                    .to_string(),
            ),
        };
        self.lkh_src_dir = path_to_string(Path::new(&self.lkh_src_dir), &cargo_path, true);
        self.lkh_header_dir = path_to_string(Path::new(&self.lkh_header_dir), &cargo_path, true);
        self.lkh_wrapper_header =
            path_to_string(Path::new(&self.lkh_wrapper_header), &cargo_path, true);
    }
    fn get_sources(&self) -> Vec<String> {
        let mut sources = vec![];
        for entry in fs::read_dir(&self.lkh_src_dir).expect("read sources failed") {
            let path = entry.unwrap().path();
            if path.extension() == Some("c".as_ref()) {
                sources.push(path_to_string(
                    Path::new(&path),
                    &PathBuf::from(env!("CARGO_MANIFEST_DIR")),
                    true,
                ));
            }
        }
        log!("sources:{:#?}", sources);
        sources
    }
    fn get_headers(&self) -> Vec<String> {
        let mut headers = vec![];
        for entry in fs::read_dir(&self.lkh_header_dir).expect("read headers failed") {
            let path = entry.unwrap().path();
            if path.extension() == Some("h".as_ref()) {
                headers.push(path_to_string(
                    Path::new(&path),
                    &PathBuf::from(env!("CARGO_MANIFEST_DIR")),
                    true,
                ));
            }
        }
        log!("headers:{:#?}", headers);
        headers
    }
}
fn main() {
    // parse config from CONFIG_FILE
    let config = parse_config();
    // gen wrapper header file
    wrapper_header_build(&config);
    // compile obj
    compile_obj(&config);
    // bindgen config and link to rust
    generate_bindings(&config);
}
// parse config from yaml
fn parse_config() -> Config {
    // rebuild if config file change
    println!("cargo:rerun-if-changed={}", CONFIG_FILE);
    // parse config file
    let config_string = std::fs::read_to_string(CONFIG_FILE)
        .unwrap_or_else(|e| panic!("Unable to read {} file: {}", CONFIG_FILE, e));
    let mut config: Config = serde_yaml::from_str(&config_string)
        .unwrap_or_else(|e| panic!("Unable to parse {} file: {}", CONFIG_FILE, e));
    config.normalize_paths();
    // log config to terminal
    log!("LKH-BUILD configuration {} :: {:#?}", CONFIG_FILE, config);
    log!("LKH-BUILD headers {:#?}", config.get_headers());
    config
}
// path to relative path
fn path_to_string(path: &Path, base: &Path, to_unix: bool) -> String {
    if fs::metadata(path).is_err() {
        log!("path_to_string: path:{:?} base:{:#?}", path, base);
        fs::create_dir_all(path).unwrap();
    }
    let path1 = dunce::canonicalize(path).expect("path not found,can not canonicalize");
    let path2 = dunce::canonicalize(base).expect("path not found,can not canonicalize");
    let mut relative = Path::new(&path1)
        .strip_prefix(&path2)
        .unwrap()
        .to_str()
        .unwrap()
        .to_string();
    if to_unix {
        relative = relative.replace("\\", "/");
    }
    log!(
        "path1:{:?} to relative_path:{:?} with path2:{:#?}",
        path1,
        relative,
        path2
    );
    relative
}
// scan header and gen wrapper header
fn wrapper_header_build(config: &Config) {
    // collect all header file from header dir path
    let entries = fs::read_dir(&config.lkh_header_dir).expect("read header file dir failed");
    let header_paths: Vec<PathBuf> = entries
        .filter_map(|entry| {
            let path = entry.ok()?.path();
            if path.is_file() && path.extension() == Some("h".as_ref()) {
                Some(path)
            } else {
                None
            }
        })
        .collect();
    // create wrapper file path
    let wrapper_file_path = Path::new(&config.lkh_wrapper_header);
    let mut file = match File::create(&wrapper_file_path) {
        Err(why) => panic!("couldn't create {}: {:?}", config.lkh_wrapper_header, why),
        Ok(file) => file,
    };
    // concat header file contents
    let mut contents = String::new();
    contents.push_str("/* automatically generated by LKH-rs */\n");
    for path in header_paths {
        let relative_path = path_to_string(&path, &wrapper_file_path.parent().unwrap(), true);
        contents.push_str(&format!("#include \"{}\"\n", relative_path));
    }
    // write content to wrapper file
    file.write_all(contents.as_bytes())
        .expect("write header file failed");
}
// compile obj
fn compile_obj(config: &Config) {
    let mut builder = cc::Build::new();
    // set flag
    for flag in &config.flags {
        builder.flag(flag);
    }
    // set other config
    builder
        .no_default_flags(true)
        .warnings(false)
        .extra_warnings(false)
        .out_dir(format!("{}/", &config.lkh_obj_dir.clone().unwrap()))
        .include(Path::new(&config.lkh_header_dir))
        .files(&config.get_sources());
    // set compile bin
    if let Some(bin) = &config.compile_bin {
        builder.compiler(bin);
    }
    // .compiler(Path::new(&config.compile_bin))
    log!("cc::Build::Config: {:?}", builder);
    builder.compile("lkh");
}
// bindgen config and generate
fn generate_bindings(config: &Config) {
    let bindings: Bindings = bindgen::Builder::default()
        .header(&config.lkh_wrapper_header)
        .parse_callbacks(Box::new(bindgen::CargoCallbacks))
        .generate()
        .expect("Unable to generate bindings");
    // Write the bindings to the CARGO_MANIFEST_DIR/src/bindings.rs file.
    let lkh_bind = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("src")
        .join("bindings.rs");
    bindings
        .write_to_file(lkh_bind)
        .expect("Couldn't write bindings!");
}

file_name：Unix build.yaml

lkh_home: source_code/LKHDemo
lkh_src_dir: source_code/LKHDemo/SRC
lkh_header_dir: source_code/LKHDemo/SRC/INCLUDE
lkh_obj_dir: target/out
lkh_wrapper_header: source_code/wrapper.h
compile_bin: gcc
flags:
  - '-O3' # for gcc
  - '-w' # for gcc
  - '-DDefineVAR' # for gcc
  - '-g' # for gcc
  - '-fno-unsafe-math-optimizations' # for gcc
  - '-fcommon' # for gcc

file_name：windows build.yaml
PS:if in windows ,you want use gcc,you must change cc::Builder compile flag,the default -Fo flag Not in line with expectations,you can use command mod use cc

lkh_home: source_code/LKHDemo
lkh_src_dir: source_code/LKHDemo/SRC
lkh_header_dir: source_code/LKHDemo/SRC/INCLUDE
lkh_obj_dir: target/out
lkh_wrapper_header: source_code/wrapper.h
compile_bin:
flags:
  - '/O2' # for win cl
  - '/fp:precise' # for win cl
  - '/Oi' # for win cl
  - '/Og' # for win cl
  - '/DDefineVAR' # for win cl

file_name：Cargo.toml

[package]
name = "LKH-rs"
version = "0.1.0"
edition = "2021"
build = "build.rs"
[[bin]]
name="main"
path="src/main.rs"
[lib]
name = "LKH"
crate-type = ["rlib"]
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[build-dependencies]
bindgen = "0.66.1"
envmnt = "0.10.4"
serde = { version = "1.0", features = ["derive"] }
serde_yaml = "0.9"
cc = { version = "1.0.79", features = ["parallel"] }
dunce = "1.0.4"
[dependencies]

cargo clean
cargo build -vv
./target/debug/main

test in WSL:

test in OSX(m2):

test in windows:

[Euraxluo]

code on repo:Euraxluo/LKH-rs@0694fa4