Compiling directory of C files

Here project also consists of 2 source files (utils.c and main.c) and one header (utils.h). Buildscript rebuilds both source files in parallel and also caches objects that do not need to be changed.

This example is much more complex. It automatically detects all files that have .c extension and are placed somewhere in directory tree starting from src.

Code inside of function main is much simpler now. It prepares link_cmd variable, then walks the directory tree, then waits for all processes, then runs link command and then cleans all allocated memory.

Function walker is much more interesting - this is where all magic happens. This function will be called for each file and directory by cbuild_dir_walk. This function consists of 4 parts - preparation, generation of output path, check and command call.

Preparation: This part constructs string view out of args.path and then checks if suffix is .c, so this filters-out files that are not C source files.
Output path generation: This part appends .o to source path and then replaces all slashes with dots. This will allocate from CBuild’s temporary allocator (arena), and it does this in loop, but such loops will be quite small and that arena has size of 8M, so cleaning it on each iteration is not that important.
Check: This part consists of call to cbuild_compare_mtime and 3 if checks. If this function returns 0 it means that output file is newer than input one. If it returns something lower than 0 it means that error has happened. If it returns value greater than 0 it means that input is newer than output, so recompilation is needed.
Command call: If previous check decided that recompilation is needed it runs new command and appends to procs array, same as previous example.

Object files to linker command is appended by walker function, because their paths are known only there. This is also a reason why temporary allocator can not be cleaned during loop execution.

Code

Directory structure:

examples/build/4.dir
├── src
│   ├── main.c
│   ├── utils.c
│   └── utils.h
├── cbuild.c
└── cbuild.h

App’s source code.

main.c

#include "stdio.h"
#include "utils.h"
int main(int argc, char** argv) {
	printf("Hello, world!\nSum: %d\n", sum(1, 1));
	return 0;
}

utils.h

#ifndef UTILS_H
#define UTILS_H
int sum(int a, int b);
#endif // UTILS_H

utils.c

#include "utils.h"
int sum(int a, int b) {
    return a + b;
}

cbuild.c - Your buildscript:

#define CBUILD_IMPLEMENTATION
#define CBUILD_LOG_MIN_LEVEL CBUILD_LOG_TRACE
#include "cbuild.h"
cbuild_proclist_t procs = {0};
cbuild_cmd_t cmd = {0};
cbuild_cmd_t link_cmd = {0};
bool walker(cbuild_dir_walk_func_args_t args) {
	cbuild_sv_t path = cbuild_sv_from_cstr(args.path);
	if (!cbuild_sv_suffix(path, cbuild_sv_from_lit(".c"))) return true;
	char* opath = cbuild_temp_sprintf("%s.o", args.path);
	for (size_t i = 0; i < strlen(opath) - 2; i++) if (opath[i] == '/') opath[i] = '.';
	int change = cbuild_compare_mtime(opath, args.path);
	cbuild_cmd_append(&link_cmd, opath);
	if (change == 0) return true;
	if (change < 0) return false;
	if (change > 0) {
		cbuild_cmd_append_many(&cmd, CC, "-c", args.path, "-o", opath);
		if (!cbuild_cmd_run(&cmd, .procs = &procs)) return false;
		cmd.size = 0;
	}
	return true;
}
int main(int argc, char** argv) {
	cbuild_selfrebuild(argc, argv);
	cbuild_cmd_append_many(&link_cmd, CC, "-o", "app.run");
	cbuild_dir_walk("src", walker);
	cbuild_procs_wait(procs);
	if (!cbuild_cmd_run(&link_cmd)) return 1;
	cbuild_proclist_clear(&procs);
	cbuild_cmd_clear(&cmd);
	cbuild_cmd_clear(&link_cmd);
	cbuild_temp_reset(0);
	return 0;
}

cbuild.h - Build system core.

How to run

cc -o cbuild.run cbuild.c
./cbuild.run
./app.run