How to Automate Builds with `make` and `CMake` on FreeBSD Operating System

Introduction

In the world of software development, automation is key to improving productivity, ensuring consistency, and reducing the likelihood of human error. One of the most common tasks that developers automate is the build process. On Unix-like operating systems, such as FreeBSD, make and CMake are two powerful tools that can be used to automate the build process. This article will provide a detailed guide on how to use make and CMake to automate builds on the FreeBSD operating system.

Understanding make and CMake

make

make is a build automation tool that automatically builds executable programs and libraries from source code by reading files called Makefiles. A Makefile contains a set of directives that describe how to compile and link a program. make is particularly useful for managing large projects where multiple source files need to be compiled and linked together.

CMake

CMake is a cross-platform build system generator. It does not build the project directly but generates build files (such as Makefiles) that can be used with make or other build tools. CMake is designed to be platform-independent, making it easier to manage builds across different operating systems and compilers.

Setting Up the Environment on FreeBSD

Before diving into the automation process, it’s essential to ensure that the necessary tools are installed on your FreeBSD system.

Installing make

make is typically included by default on FreeBSD. However, if it is not installed, you can install it using the pkg package manager:

sudo pkg install gmake

Installing CMake

To install CMake on FreeBSD, use the following command:

sudo pkg install cmake

Installing a Compiler

You will also need a C/C++ compiler. The most common choice is gcc or clang. To install gcc, use:

sudo pkg install gcc

Alternatively, to install clang, use:

sudo pkg install llvm

Automating Builds with make

Creating a Simple Makefile

Let’s start by creating a simple Makefile for a C project. Suppose you have a project with the following structure:

my_project/
├── src/
│   ├── main.c
│   ├── utils.c
│   └── utils.h
└── Makefile

Here is a basic Makefile that you can use to build this project:

# Compiler
CC = gcc

# Compiler flags
CFLAGS = -Wall -g

# Source files
SRCS = src/main.c src/utils.c

# Object files
OBJS = $(SRCS:.c=.o)

# Executable name
TARGET = my_program

# Default target
all: $(TARGET)

# Link the object files to create the executable
$(TARGET): $(OBJS)
 $(CC) $(CFLAGS) -o $(TARGET) $(OBJS)

# Compile source files into object files
%.o: %.c
 $(CC) $(CFLAGS) -c $< -o $@

# Clean up build files
clean:
 rm -f $(OBJS) $(TARGET)

Building the Project

To build the project, navigate to the my_project directory and run:

make

This will compile the source files and link them to create the executable my_program.

Cleaning the Build

To remove the compiled object files and the executable, run:

make clean

Automating Builds with CMake

Creating a Simple CMakeLists.txt

CMake uses a file named CMakeLists.txt to describe the build process. Let’s create a CMakeLists.txt file for the same project structure:

my_project/
├── src/
│   ├── main.c
│   ├── utils.c
│   └── utils.h
└── CMakeLists.txt

Here is a basic CMakeLists.txt file:

# Minimum required version of CMake
cmake_minimum_required(VERSION 3.10)

# Project name
project(MyProject)

# Set C standard
set(CMAKE_C_STANDARD 99)

# Add executable
add_executable(my_program src/main.c src/utils.c)

Generating Build Files with CMake

To generate the build files, create a build directory and run cmake:

mkdir build
cd build
cmake ..

This will generate the necessary build files (e.g., Makefile) in the build directory.

Building the Project

To build the project, run:

make

This will compile the source files and link them to create the executable my_program.

Cleaning the Build

To clean the build, run:

make clean

Advanced CMake Features

Adding Include Directories

If your project has header files in a separate directory, you can add the include directory using the include_directories command:

include_directories(include)

Adding Libraries

If your project depends on external libraries, you can link them using the target_link_libraries command:

target_link_libraries(my_program m)

This example links the math library (libm).

Conditional Compilation

CMake allows you to add conditions to your build process. For example, you can enable or disable certain features based on the operating system:

if(CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
    add_definitions(-DFREEBSD)
endif()

Building in Debug or Release Mode

CMake supports different build types, such as Debug and Release. You can specify the build type when generating the build files:

cmake -DCMAKE_BUILD_TYPE=Debug ..

or

cmake -DCMAKE_BUILD_TYPE=Release ..

Integrating make and CMake

While CMake generates Makefiles, you can still use make to build your project. This integration allows you to leverage the simplicity of make with the power of CMake.

Example Workflow

1. Generate Build Files: Use CMake to generate the Makefile.
2. Build the Project: Use make to compile and link the project.
3. Clean the Build: Use make clean to remove build artifacts.

Automating the Entire Process

You can create a shell script to automate the entire build process:

#!/bin/sh

# Create build directory
mkdir -p build
cd build

# Generate build files
cmake ..

# Build the project
make

# Run the executable
./my_program

Save this script as build.sh, make it executable, and run it:

chmod +x build.sh
./build.sh

Conclusion

Automating builds with make and CMake on FreeBSD can significantly streamline your development workflow. make provides a straightforward way to define and execute build tasks, while CMake offers a more flexible and platform-independent approach to managing complex builds. By combining these tools, you can create a robust and efficient build system for your projects on FreeBSD.

Whether you are working on a small personal project or a large-scale application, mastering make and CMake will undoubtedly enhance your productivity and ensure that your builds are consistent and reliable. With the knowledge gained from this article, you should be well-equipped to automate your build processes on FreeBSD using these powerful tools.