Rust Build Script for Project Compilation

This challenge involves creating a custom build script in Rust. You'll be tasked with writing a build.rs file that automates the process of compiling a small C library and linking it into a Rust project. This is a common scenario when integrating existing C codebases with Rust.

Problem Description

Your goal is to create a Rust project that includes a simple C library. The build process should automatically compile this C library using a build.rs script and then link it into the main Rust executable.

What needs to be achieved:

• Create a build.rs file in the root of your Rust project.
• This build.rs script should compile a provided C source file (lib.c) into a static library (.a file).
• The Rust compiler should be instructed to link against this compiled static library.
• The main Rust program should successfully call a function from the C library.

Key requirements:

• The build.rs script must be written in Rust.
• The C library should contain at least one simple function (e.g., an addition function).
• The Rust code should define FFI (Foreign Function Interface) bindings for the C function.
• The build.rs script must place the compiled library in a location where the Rust compiler can find it.
• The final Rust executable should run without errors and demonstrate the use of the C function.

Expected behavior: When you run cargo build or cargo run, the build.rs script will execute first. It will compile the C code. Then, cargo will proceed with building the Rust code, linking the compiled C library. Finally, running the executable should produce the correct output from the C function.

Important edge cases to consider:

• Ensure the C compiler is available on the system where the build is performed.
• Handle potential errors during C compilation gracefully within build.rs.

Examples

Let's assume you have the following C source file:

src/lib.c

#include <stdio.h>

int add(int a, int b) {
    return a + b;
}

void greet() {
    printf("Hello from C!\n");
}

Example 1:

• Cargo.toml (simplified)

  [package]
  name = "rust_c_integration"
  version = "0.1.0"
  edition = "2021"
  
  [build-dependencies]
  cc = "1.0" # A helpful crate for compiling C code
  

• build.rs

  // Your build.rs content here
  

• src/main.rs

  // Your main.rs content here
  

• Expected Output when running cargo run:

  Hello from C!
  The sum is: 10
  

• Explanation: The build.rs script compiles src/lib.c into a static library. The src/main.rs file declares and calls the add and greet functions from the C library. The cargo run command triggers the build process, including the C compilation, and then executes the Rust program.

Constraints

• The C code provided (src/lib.c) should be simple and self-contained.
• Your build.rs script should use a reliable method for compiling C code (e.g., the cc crate).
• The Rust project should be a binary crate.
• Performance of the build script itself is not a primary concern, but it should complete within a reasonable time for a small C file.

Notes

• You'll need to add the cc crate as a build dependency in your Cargo.toml. This crate simplifies the process of invoking C compilers.
• In build.rs, you'll use cc::Build::new().file("src/lib.c").compile("mylib"); to compile your C code. The compile method will create libmylib.a (or equivalent) and instruct Cargo to link against it.
• In src/main.rs, you'll use extern "C" { ... } to declare the C functions and then call them as if they were Rust functions.
• Remember to use #[link(name = "mylib")] in your src/main.rs to ensure the linker knows which library to use, although the cc crate often handles this automatically.
• Consider what happens if src/lib.c changes. Your build script should ideally recompile the C library when the source changes. The cc crate helps manage this.