From 90ded13e589b0089167ef25ca3d26be599dfec9b Mon Sep 17 00:00:00 2001
From: Tavian Barnes <tavianator@tavianator.com>
Date: Mon, 19 Jun 2023 12:11:36 -0400
Subject: alloc: New header for memory allocation utilities

---
 tests/alloc.c | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 tests/alloc.c

(limited to 'tests/alloc.c')

diff --git a/tests/alloc.c b/tests/alloc.c
new file mode 100644
index 0000000..91b1b43
--- /dev/null
+++ b/tests/alloc.c
@@ -0,0 +1,24 @@
+// Copyright © Tavian Barnes <tavianator@tavianator.com>
+// SPDX-License-Identifier: 0BSD
+
+#include "../src/alloc.h"
+#include "../src/diag.h"
+#include <stdlib.h>
+
+int main(void) {
+	// Check sizeof_flex()
+	struct flexible {
+		alignas(64) int foo;
+		int bar[];
+	};
+	bfs_verify(sizeof_flex(struct flexible, bar, 0) >= sizeof(struct flexible));
+	bfs_verify(sizeof_flex(struct flexible, bar, 16) % alignof(struct flexible) == 0);
+	bfs_verify(sizeof_flex(struct flexible, bar, SIZE_MAX / sizeof(int) + 1)
+	           == align_floor(alignof(struct flexible), SIZE_MAX));
+
+	// Corner case: sizeof(type) > align_ceil(alignof(type), offsetof(type, member))
+	// Doesn't happen in typical ABIs
+	bfs_verify(flex_size(8, 16, 4, 4, 1) == 16);
+
+	return EXIT_SUCCESS;
+}
-- 
cgit v1.2.3


From cbe2c473c9aee71f5f770dc7f41973d2ef4c273c Mon Sep 17 00:00:00 2001
From: Tavian Barnes <tavianator@tavianator.com>
Date: Mon, 19 Jun 2023 16:58:24 -0400
Subject: alloc: Implement an arena for flexible structs

---
 src/alloc.c   | 118 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/alloc.h   |  92 +++++++++++++++++++++++++++++++++++++++++++++
 tests/alloc.c |  14 ++++++-
 3 files changed, 223 insertions(+), 1 deletion(-)

(limited to 'tests/alloc.c')

diff --git a/src/alloc.c b/src/alloc.c
index b437975..a6910ce 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -157,5 +157,123 @@ void arena_destroy(struct arena *arena) {
 	for (size_t i = 0; i < arena->nslabs; ++i) {
 		free(arena->slabs[i]);
 	}
+	free(arena->slabs);
 	sanitize_uninit(arena);
 }
+
+void varena_init(struct varena *varena, size_t align, size_t min, size_t offset, size_t size) {
+	varena->align = align;
+	varena->offset = offset;
+	varena->size = size;
+	varena->narenas = 0;
+	varena->arenas = NULL;
+
+	// The smallest size class is at least as many as fit in the smallest
+	// aligned allocation size
+	size_t min_count = (flex_size(align, min, offset, size, 1) - offset + size - 1) / size;
+	varena->shift = bit_width(min_count - 1);
+}
+
+/** Get the size class for the given array length. */
+static size_t varena_size_class(struct varena *varena, size_t count) {
+	// Since powers of two are common array lengths, make them the
+	// (inclusive) upper bound for each size class
+	return bit_width((count - !!count) >> varena->shift);
+}
+
+/** Get the exact size of a flexible struct. */
+static size_t varena_exact_size(const struct varena *varena, size_t count) {
+	return flex_size(varena->align, 0, varena->offset, varena->size, count);
+}
+
+/** Get the arena for the given array length. */
+static struct arena *varena_get(struct varena *varena, size_t count) {
+	size_t i = varena_size_class(varena, count);
+
+	if (i >= varena->narenas) {
+		size_t narenas = i + 1;
+		struct arena *arenas = realloc(varena->arenas, sizeof_array(struct arena, narenas));
+		if (!arenas) {
+			return NULL;
+		}
+
+		for (size_t j = varena->narenas; j < narenas; ++j) {
+			size_t shift = j + varena->shift;
+			size_t size = varena_exact_size(varena, (size_t)1 << shift);
+			arena_init(&arenas[j], varena->align, size);
+		}
+
+		varena->narenas = narenas;
+		varena->arenas = arenas;
+	}
+
+	return &varena->arenas[i];
+}
+
+void *varena_alloc(struct varena *varena, size_t count) {
+	struct arena *arena = varena_get(varena, count);
+	if (!arena) {
+		return NULL;
+	}
+
+	void *ret = arena_alloc(arena);
+	if (!ret) {
+		return NULL;
+	}
+
+	// Tell the sanitizers the exact size of the allocated struct
+	sanitize_free(ret, arena->size);
+	sanitize_alloc(ret, varena_exact_size(varena, count));
+
+	return ret;
+}
+
+void *varena_realloc(struct varena *varena, void *ptr, size_t old_count, size_t new_count) {
+	struct arena *new_arena = varena_get(varena, new_count);
+	struct arena *old_arena = varena_get(varena, old_count);
+	if (!new_arena) {
+		return NULL;
+	}
+
+	size_t new_exact_size = varena_exact_size(varena, new_count);
+	size_t old_exact_size = varena_exact_size(varena, old_count);
+
+	if (new_arena == old_arena) {
+		if (new_count < old_count) {
+			sanitize_free((char *)ptr + new_exact_size, old_exact_size - new_exact_size);
+		} else if (new_count > old_count) {
+			sanitize_alloc((char *)ptr + old_exact_size, new_exact_size - old_exact_size);
+		}
+		return ptr;
+	}
+
+	void *ret = arena_alloc(new_arena);
+	if (!ret) {
+		return NULL;
+	}
+
+	size_t old_size = old_arena->size;
+	sanitize_alloc((char *)ptr + old_exact_size, old_size - old_exact_size);
+
+	size_t new_size = new_arena->size;
+	size_t min_size = new_size < old_size ? new_size : old_size;
+	memcpy(ret, ptr, min_size);
+
+	arena_free(old_arena, ptr);
+	sanitize_free((char *)ret + new_exact_size, new_size - new_exact_size);
+
+	return ret;
+}
+
+void varena_free(struct varena *varena, void *ptr, size_t count) {
+	struct arena *arena = varena_get(varena, count);
+	arena_free(arena, ptr);
+}
+
+void varena_destroy(struct varena *varena) {
+	for (size_t i = 0; i < varena->narenas; ++i) {
+		arena_destroy(&varena->arenas[i]);
+	}
+	free(varena->arenas);
+	sanitize_uninit(varena);
+}
diff --git a/src/alloc.h b/src/alloc.h
index 65edb92..c2ea09b 100644
--- a/src/alloc.h
+++ b/src/alloc.h
@@ -190,4 +190,96 @@ void arena_free(struct arena *arena, void *ptr);
  */
 void arena_destroy(struct arena *arena);
 
+/**
+ * An arena allocator for flexibly-sized types.
+ */
+struct varena {
+	/** The alignment of the struct. */
+	size_t align;
+	/** The offset of the flexible array. */
+	size_t offset;
+	/** The size of the flexible array elements. */
+	size_t size;
+	/** Shift amount for the smallest size class. */
+	size_t shift;
+	/** The number of arenas of different sizes. */
+	size_t narenas;
+	/** The array of differently-sized arenas. */
+	struct arena *arenas;
+};
+
+/**
+ * Initialize a varena for a struct with the given layout.
+ *
+ * @param varena
+ *         The varena to initialize.
+ * @param align
+ *         alignof(type)
+ * @param min
+ *         sizeof(type)
+ * @param offset
+ *         offsetof(type, flexible_array)
+ * @param size
+ *         sizeof(flexible_array[i])
+ */
+void varena_init(struct varena *varena, size_t align, size_t min, size_t offset, size_t size);
+
+/**
+ * Initialize a varena for the given type and flexible array.
+ *
+ * @param varena
+ *         The varena to initialize.
+ * @param type
+ *         A struct type containing a flexible array.
+ * @param member
+ *         The name of the flexible array member.
+ */
+#define VARENA_INIT(varena, type, member) \
+	varena_init(varena, alignof(type), sizeof(type), offsetof(type, member), sizeof_member(type, member[0]))
+
+/**
+ * Arena-allocate a flexible struct.
+ *
+ * @param varena
+ *         The varena to allocate from.
+ * @param count
+ *         The length of the flexible array.
+ * @return
+ *         The allocated struct, or NULL on failure.
+ */
+void *varena_alloc(struct varena *varena, size_t count);
+
+/**
+ * Resize a flexible struct.
+ *
+ * @param varena
+ *         The varena to allocate from.
+ * @param ptr
+ *         The object to resize.
+ * @param old_count
+ *         The old array lenth.
+ * @param new_count
+ *         The new array length.
+ * @return
+ *         The resized struct, or NULL on failure.
+ */
+void *varena_realloc(struct varena *varena, void *ptr, size_t old_count, size_t new_count);
+
+/**
+ * Free an arena-allocated flexible struct.
+ *
+ * @param varena
+ *         The that allocated the object.
+ * @param ptr
+ *         The object to free.
+ * @param count
+ *         The length of the flexible array.
+ */
+void varena_free(struct varena *varena, void *ptr, size_t count);
+
+/**
+ * Destroy a varena, freeing all allocations.
+ */
+void varena_destroy(struct varena *varena);
+
 #endif // BFS_ALLOC_H
diff --git a/tests/alloc.c b/tests/alloc.c
index 91b1b43..9e6e892 100644
--- a/tests/alloc.c
+++ b/tests/alloc.c
@@ -8,7 +8,7 @@
 int main(void) {
 	// Check sizeof_flex()
 	struct flexible {
-		alignas(64) int foo;
+		alignas(64) int foo[8];
 		int bar[];
 	};
 	bfs_verify(sizeof_flex(struct flexible, bar, 0) >= sizeof(struct flexible));
@@ -20,5 +20,17 @@ int main(void) {
 	// Doesn't happen in typical ABIs
 	bfs_verify(flex_size(8, 16, 4, 4, 1) == 16);
 
+	// varena tests
+	struct varena varena;
+	VARENA_INIT(&varena, struct flexible, bar);
+
+	for (size_t i = 0; i < 256; ++i) {
+		bfs_verify(varena_alloc(&varena, i));
+		struct arena *arena = &varena.arenas[varena.narenas - 1];
+		bfs_verify(arena->size >= sizeof_flex(struct flexible, bar, i));
+	}
+
+	varena_destroy(&varena);
+
 	return EXIT_SUCCESS;
 }
-- 
cgit v1.2.3


From 054ef7f719ce6fd2167f1c1b4433feaa438bebfc Mon Sep 17 00:00:00 2001
From: Tavian Barnes <tavianator@tavianator.com>
Date: Fri, 6 Oct 2023 12:37:01 -0400
Subject: alloc: Test allocation size overflows

---
 src/alloc.h   |  4 ++--
 tests/alloc.c | 12 ++++++++++--
 2 files changed, 12 insertions(+), 4 deletions(-)

(limited to 'tests/alloc.c')

diff --git a/src/alloc.h b/src/alloc.h
index 5f0c423..fd3e5f0 100644
--- a/src/alloc.h
+++ b/src/alloc.h
@@ -132,11 +132,11 @@ void *zalloc(size_t align, size_t size);
 
 /** Allocate memory for an array. */
 #define ALLOC_ARRAY(type, count) \
-	(type *)alloc(alignof(type), sizeof_array(type, count));
+	(type *)alloc(alignof(type), sizeof_array(type, count))
 
 /** Allocate zeroed memory for an array. */
 #define ZALLOC_ARRAY(type, count) \
-	(type *)zalloc(alignof(type), sizeof_array(type, count));
+	(type *)zalloc(alignof(type), sizeof_array(type, count))
 
 /** Allocate memory for a flexible struct. */
 #define ALLOC_FLEX(type, member, count) \
diff --git a/tests/alloc.c b/tests/alloc.c
index 9e6e892..382131f 100644
--- a/tests/alloc.c
+++ b/tests/alloc.c
@@ -3,6 +3,7 @@
 
 #include "../src/alloc.h"
 #include "../src/diag.h"
+#include <errno.h>
 #include <stdlib.h>
 
 int main(void) {
@@ -13,13 +14,20 @@ int main(void) {
 	};
 	bfs_verify(sizeof_flex(struct flexible, bar, 0) >= sizeof(struct flexible));
 	bfs_verify(sizeof_flex(struct flexible, bar, 16) % alignof(struct flexible) == 0);
-	bfs_verify(sizeof_flex(struct flexible, bar, SIZE_MAX / sizeof(int) + 1)
-	           == align_floor(alignof(struct flexible), SIZE_MAX));
+
+	size_t too_many = SIZE_MAX / sizeof(int) + 1;
+	bfs_verify(sizeof_flex(struct flexible, bar, too_many) == align_floor(alignof(struct flexible), SIZE_MAX));
 
 	// Corner case: sizeof(type) > align_ceil(alignof(type), offsetof(type, member))
 	// Doesn't happen in typical ABIs
 	bfs_verify(flex_size(8, 16, 4, 4, 1) == 16);
 
+	// Make sure we detect allocation size overflows
+	bfs_verify(ALLOC_ARRAY(int, too_many) == NULL && errno == EOVERFLOW);
+	bfs_verify(ZALLOC_ARRAY(int, too_many) == NULL && errno == EOVERFLOW);
+	bfs_verify(ALLOC_FLEX(struct flexible, bar, too_many) == NULL && errno == EOVERFLOW);
+	bfs_verify(ZALLOC_FLEX(struct flexible, bar, too_many) == NULL && errno == EOVERFLOW);
+
 	// varena tests
 	struct varena varena;
 	VARENA_INIT(&varena, struct flexible, bar);
-- 
cgit v1.2.3


From da5c9dd34f65989c842cfb831b8592157dd8ed34 Mon Sep 17 00:00:00 2001
From: Tavian Barnes <tavianator@tavianator.com>
Date: Thu, 12 Oct 2023 13:09:11 -0400
Subject: diag: Move enum debug_flags out of ctx.h

---
 src/ctx.c     | 25 -------------------------
 src/ctx.h     | 28 +---------------------------
 src/diag.c    | 25 +++++++++++++++++++++++++
 src/diag.h    | 29 ++++++++++++++++++++++++++++-
 tests/alloc.c |  1 +
 5 files changed, 55 insertions(+), 53 deletions(-)

(limited to 'tests/alloc.c')

diff --git a/src/ctx.c b/src/ctx.c
index 9a24a33..561ecae 100644
--- a/src/ctx.c
+++ b/src/ctx.c
@@ -17,31 +17,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-const char *debug_flag_name(enum debug_flags flag) {
-	switch (flag) {
-	case DEBUG_COST:
-		return "cost";
-	case DEBUG_EXEC:
-		return "exec";
-	case DEBUG_OPT:
-		return "opt";
-	case DEBUG_RATES:
-		return "rates";
-	case DEBUG_SEARCH:
-		return "search";
-	case DEBUG_STAT:
-		return "stat";
-	case DEBUG_TREE:
-		return "tree";
-
-	case DEBUG_ALL:
-		break;
-	}
-
-	bfs_bug("Unrecognized debug flag");
-	return "???";
-}
-
 struct bfs_ctx *bfs_ctx_new(void) {
 	struct bfs_ctx *ctx = ZALLOC(struct bfs_ctx);
 	if (!ctx) {
diff --git a/src/ctx.h b/src/ctx.h
index 2b8e8cb..96406bd 100644
--- a/src/ctx.h
+++ b/src/ctx.h
@@ -10,38 +10,12 @@
 
 #include "bftw.h"
 #include "config.h"
+#include "diag.h"
 #include "trie.h"
 #include <stddef.h>
 #include <sys/resource.h>
 #include <time.h>
 
-/**
- * Various debugging flags.
- */
-enum debug_flags {
-	/** Print cost estimates. */
-	DEBUG_COST   = 1 << 0,
-	/** Print executed command details. */
-	DEBUG_EXEC   = 1 << 1,
-	/** Print optimization details. */
-	DEBUG_OPT    = 1 << 2,
-	/** Print rate information. */
-	DEBUG_RATES  = 1 << 3,
-	/** Trace the filesystem traversal. */
-	DEBUG_SEARCH = 1 << 4,
-	/** Trace all stat() calls. */
-	DEBUG_STAT   = 1 << 5,
-	/** Print the parse tree. */
-	DEBUG_TREE   = 1 << 6,
-	/** All debug flags. */
-	DEBUG_ALL    = (1 << 7) - 1,
-};
-
-/**
- * Convert a debug flag to a string.
- */
-const char *debug_flag_name(enum debug_flags flag);
-
 /**
  * The execution context for bfs.
  */
diff --git a/src/diag.c b/src/diag.c
index fa66525..bf2343d 100644
--- a/src/diag.c
+++ b/src/diag.c
@@ -27,6 +27,31 @@ noreturn void bfs_abortf(const struct bfs_loc *loc, const char *format, ...) {
 	abort();
 }
 
+const char *debug_flag_name(enum debug_flags flag) {
+	switch (flag) {
+	case DEBUG_COST:
+		return "cost";
+	case DEBUG_EXEC:
+		return "exec";
+	case DEBUG_OPT:
+		return "opt";
+	case DEBUG_RATES:
+		return "rates";
+	case DEBUG_SEARCH:
+		return "search";
+	case DEBUG_STAT:
+		return "stat";
+	case DEBUG_TREE:
+		return "tree";
+
+	case DEBUG_ALL:
+		break;
+	}
+
+	bfs_bug("Unrecognized debug flag");
+	return "???";
+}
+
 void bfs_perror(const struct bfs_ctx *ctx, const char *str) {
 	bfs_error(ctx, "%s: %m.\n", str);
 }
diff --git a/src/diag.h b/src/diag.h
index fea8847..838a794 100644
--- a/src/diag.h
+++ b/src/diag.h
@@ -9,7 +9,6 @@
 #define BFS_DIAG_H
 
 #include "config.h"
-#include "ctx.h"
 #include <stdarg.h>
 
 /**
@@ -84,8 +83,36 @@ noreturn void bfs_abortf(const struct bfs_loc *loc, const char *format, ...);
 #  define bfs_assert bfs_verify
 #endif
 
+struct bfs_ctx;
 struct bfs_expr;
 
+/**
+ * Various debugging flags.
+ */
+enum debug_flags {
+	/** Print cost estimates. */
+	DEBUG_COST   = 1 << 0,
+	/** Print executed command details. */
+	DEBUG_EXEC   = 1 << 1,
+	/** Print optimization details. */
+	DEBUG_OPT    = 1 << 2,
+	/** Print rate information. */
+	DEBUG_RATES  = 1 << 3,
+	/** Trace the filesystem traversal. */
+	DEBUG_SEARCH = 1 << 4,
+	/** Trace all stat() calls. */
+	DEBUG_STAT   = 1 << 5,
+	/** Print the parse tree. */
+	DEBUG_TREE   = 1 << 6,
+	/** All debug flags. */
+	DEBUG_ALL    = (1 << 7) - 1,
+};
+
+/**
+ * Convert a debug flag to a string.
+ */
+const char *debug_flag_name(enum debug_flags flag);
+
 /**
  * Like perror(), but decorated like bfs_error().
  */
diff --git a/tests/alloc.c b/tests/alloc.c
index 382131f..2334241 100644
--- a/tests/alloc.c
+++ b/tests/alloc.c
@@ -5,6 +5,7 @@
 #include "../src/diag.h"
 #include <errno.h>
 #include <stdlib.h>
+#include <stdint.h>
 
 int main(void) {
 	// Check sizeof_flex()
-- 
cgit v1.2.3


From e25261a90222de75781726a93ab809c660208afd Mon Sep 17 00:00:00 2001
From: Tavian Barnes <tavianator@tavianator.com>
Date: Thu, 9 Nov 2023 15:16:04 -0500
Subject: config: Add (de)allocator attributes

---
 src/alloc.h   | 40 +++++++++++++++++++++++-----------------
 src/config.h  | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
 src/dstring.h | 21 +++++++++++++--------
 tests/alloc.c |  4 ++++
 4 files changed, 89 insertions(+), 25 deletions(-)

(limited to 'tests/alloc.c')

diff --git a/src/alloc.h b/src/alloc.h
index fd3e5f0..34f6949 100644
--- a/src/alloc.h
+++ b/src/alloc.h
@@ -9,7 +9,7 @@
 #define BFS_ALLOC_H
 
 #include "config.h"
-#include <stddef.h>
+#include <stdlib.h>
 
 /** Round down to a multiple of an alignment. */
 static inline size_t align_floor(size_t align, size_t size) {
@@ -108,6 +108,8 @@ static inline size_t flex_size(size_t align, size_t min, size_t offset, size_t s
  * @return
  *         The allocated memory, or NULL on failure.
  */
+attr_malloc(free, 1)
+attr_aligned_alloc(1, 2)
 void *alloc(size_t align, size_t size);
 
 /**
@@ -120,6 +122,8 @@ void *alloc(size_t align, size_t size);
  * @return
  *         The allocated memory, or NULL on failure.
  */
+attr_malloc(free, 1)
+attr_aligned_alloc(1, 2)
 void *zalloc(size_t align, size_t size);
 
 /** Allocate memory for the given type. */
@@ -176,14 +180,15 @@ void arena_init(struct arena *arena, size_t align, size_t size);
 	arena_init((arena), alignof(type), sizeof(type))
 
 /**
- * Allocate an object out of the arena.
+ * Free an object from the arena.
  */
-void *arena_alloc(struct arena *arena);
+void arena_free(struct arena *arena, void *ptr);
 
 /**
- * Free an object from the arena.
+ * Allocate an object out of the arena.
  */
-void arena_free(struct arena *arena, void *ptr);
+attr_malloc(arena_free, 2)
+void *arena_alloc(struct arena *arena);
 
 /**
  * Free all allocations from an arena.
@@ -242,6 +247,18 @@ void varena_init(struct varena *varena, size_t align, size_t min, size_t offset,
 #define VARENA_INIT(varena, type, member) \
 	varena_init(varena, alignof(type), sizeof(type), offsetof(type, member), sizeof_member(type, member[0]))
 
+/**
+ * Free an arena-allocated flexible struct.
+ *
+ * @param varena
+ *         The that allocated the object.
+ * @param ptr
+ *         The object to free.
+ * @param count
+ *         The length of the flexible array.
+ */
+void varena_free(struct varena *varena, void *ptr, size_t count);
+
 /**
  * Arena-allocate a flexible struct.
  *
@@ -252,6 +269,7 @@ void varena_init(struct varena *varena, size_t align, size_t min, size_t offset,
  * @return
  *         The allocated struct, or NULL on failure.
  */
+attr_malloc(varena_free, 2)
 void *varena_alloc(struct varena *varena, size_t count);
 
 /**
@@ -284,18 +302,6 @@ void *varena_realloc(struct varena *varena, void *ptr, size_t old_count, size_t
  */
 void *varena_grow(struct varena *varena, void *ptr, size_t *count);
 
-/**
- * Free an arena-allocated flexible struct.
- *
- * @param varena
- *         The that allocated the object.
- * @param ptr
- *         The object to free.
- * @param count
- *         The length of the flexible array.
- */
-void varena_free(struct varena *varena, void *ptr, size_t count);
-
 /**
  * Free all allocations from a varena.
  */
diff --git a/src/config.h b/src/config.h
index b95abaa..db62ef8 100644
--- a/src/config.h
+++ b/src/config.h
@@ -184,6 +184,17 @@
 #  define fallthru ((void)0)
 #endif
 
+/**
+ * Warn if a value is unused.
+ */
+#if __has_c_attribute(nodiscard)
+#  define attr_nodiscard [[nodiscard]]
+#elif __has_attribute(nodiscard)
+#  define attr_nodiscard __attribute__((nodiscard))
+#else
+#  define attr_nodiscard
+#endif
+
 /**
  * Hint to avoid inlining a function.
  */
@@ -211,6 +222,44 @@
 #  define attr_format(fmt, args)
 #endif
 
+/**
+ * Annotates allocator-like functions.
+ */
+#if __has_attribute(malloc)
+#  if __clang__
+#    define attr_malloc(...) attr_nodiscard __attribute__((malloc))
+#  else
+#    define attr_malloc(...) attr_nodiscard __attribute__((malloc(__VA_ARGS__)))
+#  endif
+#else
+#  define attr_malloc(...) attr_nodiscard
+#endif
+
+/**
+ * Specifies that a function returns allocations with a given alignment.
+ */
+#if __has_attribute(alloc_align)
+#  define attr_alloc_align(param) __attribute__((alloc_align(param)))
+#else
+#  define attr_alloc_align(param)
+#endif
+
+/**
+ * Specifies that a function returns allocations with a given size.
+ */
+#if __has_attribute(alloc_size)
+#  define attr_alloc_size(...) __attribute__((alloc_size(__VA_ARGS__)))
+#else
+#  define attr_alloc_size(...)
+#endif
+
+/**
+ * Shorthand for attr_alloc_align() and attr_alloc_size().
+ */
+#define attr_aligned_alloc(align, ...) \
+	attr_alloc_align(align) \
+	attr_alloc_size(__VA_ARGS__)
+
 /**
  * Check if function multiversioning via GNU indirect functions (ifunc) is supported.
  */
diff --git a/src/dstring.h b/src/dstring.h
index fd98df8..07b4ee9 100644
--- a/src/dstring.h
+++ b/src/dstring.h
@@ -27,12 +27,21 @@ typedef __attribute__((aligned(alignof(size_t)))) char dchar;
 typedef char dchar;
 #endif
 
+/**
+ * Free a dynamic string.
+ *
+ * @param dstr
+ *         The string to free.
+ */
+void dstrfree(dchar *dstr);
+
 /**
  * Allocate a dynamic string.
  *
  * @param capacity
  *         The initial capacity of the string.
  */
+attr_malloc(dstrfree, 1)
 dchar *dstralloc(size_t capacity);
 
 /**
@@ -41,6 +50,7 @@ dchar *dstralloc(size_t capacity);
  * @param str
  *         The NUL-terminated string to copy.
  */
+attr_malloc(dstrfree, 1)
 dchar *dstrdup(const char *str);
 
 /**
@@ -51,6 +61,7 @@ dchar *dstrdup(const char *str);
  * @param n
  *         The maximum number of characters to copy from str.
  */
+attr_malloc(dstrfree, 1)
 dchar *dstrndup(const char *str, size_t n);
 
 /**
@@ -59,6 +70,7 @@ dchar *dstrndup(const char *str, size_t n);
  * @param dstr
  *         The dynamic string to copy.
  */
+attr_malloc(dstrfree, 1)
 dchar *dstrddup(const dchar *dstr);
 
 /**
@@ -69,6 +81,7 @@ dchar *dstrddup(const dchar *dstr);
  * @param len
  *         The length of the string, which may include internal NUL bytes.
  */
+attr_malloc(dstrfree, 1)
 dchar *dstrxdup(const char *str, size_t len);
 
 /**
@@ -306,12 +319,4 @@ int dstrescat(dchar **dest, const char *str, enum wesc_flags flags);
  */
 int dstrnescat(dchar **dest, const char *str, size_t n, enum wesc_flags flags);
 
-/**
- * Free a dynamic string.
- *
- * @param dstr
- *         The string to free.
- */
-void dstrfree(dchar *dstr);
-
 #endif // BFS_DSTRING_H
diff --git a/tests/alloc.c b/tests/alloc.c
index 2334241..37b70bf 100644
--- a/tests/alloc.c
+++ b/tests/alloc.c
@@ -24,6 +24,10 @@ int main(void) {
 	bfs_verify(flex_size(8, 16, 4, 4, 1) == 16);
 
 	// Make sure we detect allocation size overflows
+#if __GNUC__ && !__clang__
+#  pragma GCC diagnostic ignored "-Walloc-size-larger-than="
+#endif
+
 	bfs_verify(ALLOC_ARRAY(int, too_many) == NULL && errno == EOVERFLOW);
 	bfs_verify(ZALLOC_ARRAY(int, too_many) == NULL && errno == EOVERFLOW);
 	bfs_verify(ALLOC_FLEX(struct flexible, bar, too_many) == NULL && errno == EOVERFLOW);
-- 
cgit v1.2.3


From a9c9fc392bf2c3803251e5f63c944cd221a1ca67 Mon Sep 17 00:00:00 2001
From: Tavian Barnes <tavianator@tavianator.com>
Date: Fri, 12 Jan 2024 12:01:07 -0500
Subject: tests: Merge unit test executables into one

---
 GNUmakefile     |  27 +++++++++------
 tests/alloc.c   |   6 ++--
 tests/bfstd.c   |   5 +--
 tests/bit.c     |   5 +--
 tests/main.c    | 106 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 tests/tests.h   |  26 ++++++++++++++
 tests/trie.c    |   5 +--
 tests/xtime.c   |  95 ++++++++++++++++++++++++++++++++++++++++++++++++++
 tests/xtimegm.c |  94 -------------------------------------------------
 9 files changed, 256 insertions(+), 113 deletions(-)
 create mode 100644 tests/main.c
 create mode 100644 tests/tests.h
 create mode 100644 tests/xtime.c
 delete mode 100644 tests/xtimegm.c

(limited to 'tests/alloc.c')

diff --git a/GNUmakefile b/GNUmakefile
index 66af797..34c7f37 100644
--- a/GNUmakefile
+++ b/GNUmakefile
@@ -269,32 +269,39 @@ LIBBFS := \
 # The main executable
 $(BIN)/bfs: $(OBJ)/src/main.o $(LIBBFS)
 
-# Standalone unit tests
-UNITS := alloc bfstd bit trie xtimegm
-UNIT_TESTS := $(UNITS:%=$(BIN)/tests/%)
-UNIT_CHECKS := $(UNITS:%=check-%)
-
 # Testing utilities
 TEST_UTILS := $(BIN)/tests/mksock $(BIN)/tests/xtouch
 
-TESTS := $(UNIT_TESTS) $(TEST_UTILS)
+$(BIN)/tests/mksock: $(OBJ)/tests/mksock.o $(LIBBFS)
+
+$(BIN)/tests/xtouch: $(OBJ)/tests/xtouch.o $(LIBBFS)
+
+# All test binaries
+TESTS := $(BIN)/tests/units $(TEST_UTILS)
+
+$(BIN)/tests/units: \
+    $(OBJ)/tests/alloc.o \
+    $(OBJ)/tests/bfstd.o \
+    $(OBJ)/tests/bit.o \
+    $(OBJ)/tests/main.o \
+    $(OBJ)/tests/trie.o \
+    $(OBJ)/tests/xtime.o \
+    $(LIBBFS)
 
 tests: $(TESTS)
 .PHONY: tests
 
-$(TESTS): $(BIN)/tests/%: $(OBJ)/tests/%.o $(LIBBFS)
-
 # The different search strategies that we test
 STRATEGIES := bfs dfs ids eds
 STRATEGY_CHECKS := $(STRATEGIES:%=check-%)
 
 # All the different checks we run
-CHECKS := $(UNIT_CHECKS) $(STRATEGY_CHECKS)
+CHECKS := check-units $(STRATEGY_CHECKS)
 
 check: $(CHECKS)
 .PHONY: check $(CHECKS)
 
-$(UNIT_CHECKS): check-%: $(BIN)/tests/%
+check-units: $(BIN)/tests/units
 	$<
 
 JOBS := $(filter -j%,$(MAKEFLAGS))
diff --git a/tests/alloc.c b/tests/alloc.c
index 37b70bf..e14f131 100644
--- a/tests/alloc.c
+++ b/tests/alloc.c
@@ -1,13 +1,14 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "tests.h"
 #include "../src/alloc.h"
 #include "../src/diag.h"
 #include <errno.h>
 #include <stdlib.h>
 #include <stdint.h>
 
-int main(void) {
+bool check_alloc(void) {
 	// Check sizeof_flex()
 	struct flexible {
 		alignas(64) int foo[8];
@@ -44,6 +45,5 @@ int main(void) {
 	}
 
 	varena_destroy(&varena);
-
-	return EXIT_SUCCESS;
+	return true;
 }
diff --git a/tests/bfstd.c b/tests/bfstd.c
index c386279..d385c6b 100644
--- a/tests/bfstd.c
+++ b/tests/bfstd.c
@@ -1,6 +1,7 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "tests.h"
 #include "../src/bfstd.h"
 #include "../src/config.h"
 #include "../src/diag.h"
@@ -34,7 +35,7 @@ static void check_wordesc(const char *str, const char *exp, enum wesc_flags flag
 	bfs_verify(strcmp(buf, exp) == 0, "wordesc(%s) == %s (!= %s)", str, buf, exp);
 }
 
-int main(void) {
+bool check_bfstd(void) {
 	// Try to set a UTF-8 locale
 	if (!setlocale(LC_ALL, "C.UTF-8")) {
 		setlocale(LC_ALL, "");
@@ -69,5 +70,5 @@ int main(void) {
 		check_wordesc("\xF0\x9F\x98\x80", "\xF0\x9F\x98\x80", WESC_SHELL | WESC_TTY);
 	}
 
-	return EXIT_SUCCESS;
+	return true;
 }
diff --git a/tests/bit.c b/tests/bit.c
index f9071be..1c6a4de 100644
--- a/tests/bit.c
+++ b/tests/bit.c
@@ -1,6 +1,7 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "tests.h"
 #include "../src/bit.h"
 #include "../src/diag.h"
 #include <limits.h>
@@ -54,7 +55,7 @@ bfs_static_assert(INTMAX_MAX == IWIDTH_MAX(INTMAX_WIDTH));
 #define verify_eq(a, b) \
 	bfs_verify((a) == (b), "(0x%jX) %s != %s (0x%jX)", (uintmax_t)(a), #a, #b, (uintmax_t)(b))
 
-int main(void) {
+bool check_bit(void) {
 	verify_eq(bswap((uint8_t)0x12), 0x12);
 	verify_eq(bswap((uint16_t)0x1234), 0x3412);
 	verify_eq(bswap((uint32_t)0x12345678), 0x78563412);
@@ -121,5 +122,5 @@ int main(void) {
 	bfs_verify(!has_single_bit(UINT32_MAX));
 	bfs_verify(has_single_bit((uint32_t)1 << (UINT_WIDTH - 1)));
 
-	return EXIT_SUCCESS;
+	return true;
 }
diff --git a/tests/main.c b/tests/main.c
new file mode 100644
index 0000000..b7292b4
--- /dev/null
+++ b/tests/main.c
@@ -0,0 +1,106 @@
+// Copyright © Tavian Barnes <tavianator@tavianator.com>
+// SPDX-License-Identifier: 0BSD
+
+/**
+ * Entry point for unit tests.
+ */
+
+#include "tests.h"
+#include "../src/bfstd.h"
+#include "../src/color.h"
+#include "../src/config.h"
+#include "../src/diag.h"
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/**
+ * Test context.
+ */
+struct test_ctx {
+	/** Number of command line arguments. */
+	int argc;
+	/** The arguments themselves. */
+	char **argv;
+
+	/** Parsed colors. */
+	struct colors *colors;
+	/** Colorized output stream. */
+	CFILE *cout;
+
+	/** Eventual exit status. */
+	int ret;
+};
+
+/** Initialize the test context. */
+static int test_init(struct test_ctx *ctx, int argc, char **argv) {
+	ctx->argc = argc;
+	ctx->argv = argv;
+
+	ctx->colors = parse_colors();
+	ctx->cout = cfwrap(stdout, ctx->colors, false);
+	if (!ctx->cout) {
+		ctx->ret = EXIT_FAILURE;
+		return -1;
+	}
+
+	ctx->ret = EXIT_SUCCESS;
+	return 0;
+}
+
+/** Finalize the test context. */
+static int test_fini(struct test_ctx *ctx) {
+	if (ctx->cout) {
+		cfclose(ctx->cout);
+	}
+
+	free_colors(ctx->colors);
+
+	return ctx->ret;
+}
+
+/** Check if a test case is enabled for this run. */
+static bool should_run(const struct test_ctx *ctx, const char *test) {
+	// Run all tests by default
+	if (ctx->argc < 2) {
+		return true;
+	}
+
+	// With args, run only specified tests
+	for (int i = 1; i < ctx->argc; ++i) {
+		if (strcmp(test, ctx->argv[i]) == 0) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+/** Run a test if it's enabled. */
+static void run_test(struct test_ctx *ctx, const char *test, test_fn *fn) {
+	if (should_run(ctx, test)) {
+		if (fn()) {
+			cfprintf(ctx->cout, "${grn}[PASS]${rs} ${bld}%s${rs}\n", test);
+		} else {
+			cfprintf(ctx->cout, "${red}[FAIL]${rs} ${bld}%s${rs}\n", test);
+			ctx->ret = EXIT_FAILURE;
+		}
+	}
+}
+
+int main(int argc, char *argv[]) {
+	struct test_ctx ctx;
+	if (test_init(&ctx, argc, argv) != 0) {
+		goto done;
+	}
+
+	run_test(&ctx, "alloc", check_alloc);
+	run_test(&ctx, "bfstd", check_bfstd);
+	run_test(&ctx, "bit", check_bit);
+	run_test(&ctx, "trie", check_trie);
+	run_test(&ctx, "xtime", check_xtime);
+
+done:
+	return test_fini(&ctx);
+}
diff --git a/tests/tests.h b/tests/tests.h
new file mode 100644
index 0000000..34c58b7
--- /dev/null
+++ b/tests/tests.h
@@ -0,0 +1,26 @@
+// Copyright © Tavian Barnes <tavianator@tavianator.com>
+// SPDX-License-Identifier: 0BSD
+
+/**
+ * Unit tests.
+ */
+
+#include "../src/config.h"
+
+/** Unit test function type. */
+typedef bool test_fn(void);
+
+/** Memory allocation tests. */
+bool check_alloc(void);
+
+/** Standard library wrapper tests. */
+bool check_bfstd(void);
+
+/** Bit manipulation tests. */
+bool check_bit(void);
+
+/** Trie tests. */
+bool check_trie(void);
+
+/** Time tests. */
+bool check_xtime(void);
diff --git a/tests/trie.c b/tests/trie.c
index 656fd85..f94d7c8 100644
--- a/tests/trie.c
+++ b/tests/trie.c
@@ -1,6 +1,7 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "tests.h"
 #include "../src/trie.h"
 #include "../src/config.h"
 #include "../src/diag.h"
@@ -38,7 +39,7 @@ const char *keys[] = {
 
 const size_t nkeys = countof(keys);
 
-int main(void) {
+bool check_trie(void) {
 	struct trie trie;
 	trie_init(&trie);
 
@@ -130,5 +131,5 @@ int main(void) {
 
 	free(longstr);
 	trie_destroy(&trie);
-	return EXIT_SUCCESS;
+	return true;
 }
diff --git a/tests/xtime.c b/tests/xtime.c
new file mode 100644
index 0000000..53ecbc4
--- /dev/null
+++ b/tests/xtime.c
@@ -0,0 +1,95 @@
+// Copyright © Tavian Barnes <tavianator@tavianator.com>
+// SPDX-License-Identifier: 0BSD
+
+#include "tests.h"
+#include "../src/xtime.h"
+#include "../src/config.h"
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+static bool tm_equal(const struct tm *tma, const struct tm *tmb) {
+	if (tma->tm_year != tmb->tm_year) {
+		return false;
+	}
+	if (tma->tm_mon != tmb->tm_mon) {
+		return false;
+	}
+	if (tma->tm_mday != tmb->tm_mday) {
+		return false;
+	}
+	if (tma->tm_hour != tmb->tm_hour) {
+		return false;
+	}
+	if (tma->tm_min != tmb->tm_min) {
+		return false;
+	}
+	if (tma->tm_sec != tmb->tm_sec) {
+		return false;
+	}
+	if (tma->tm_wday != tmb->tm_wday) {
+		return false;
+	}
+	if (tma->tm_yday != tmb->tm_yday) {
+		return false;
+	}
+	if (tma->tm_isdst != tmb->tm_isdst) {
+		return false;
+	}
+
+	return true;
+}
+
+static void tm_print(FILE *file, const struct tm *tm) {
+	fprintf(file, "Y%d M%d D%d  h%d m%d s%d  wd%d yd%d%s\n",
+		tm->tm_year, tm->tm_mon, tm->tm_mday,
+		tm->tm_hour, tm->tm_min, tm->tm_sec,
+		tm->tm_wday, tm->tm_yday,
+		tm->tm_isdst ? (tm->tm_isdst < 0 ? " (DST?)" : " (DST)") : "");
+}
+
+bool check_xtime(void) {
+	if (setenv("TZ", "UTC0", true) != 0) {
+		perror("setenv()");
+		return false;
+	}
+
+	struct tm tm = {
+		.tm_isdst = -1,
+	};
+
+	for (tm.tm_year = 10; tm.tm_year <= 200; tm.tm_year += 10)
+	for (tm.tm_mon = -3; tm.tm_mon <= 15; tm.tm_mon += 3)
+	for (tm.tm_mday = -31; tm.tm_mday <= 61; tm.tm_mday += 4)
+	for (tm.tm_hour = -1; tm.tm_hour <= 24; tm.tm_hour += 5)
+	for (tm.tm_min = -1; tm.tm_min <= 60; tm.tm_min += 31)
+	for (tm.tm_sec = -60; tm.tm_sec <= 120; tm.tm_sec += 5) {
+		struct tm tma = tm, tmb = tm;
+		time_t ta, tb;
+		ta = mktime(&tma);
+		if (xtimegm(&tmb, &tb) != 0) {
+			tb = -1;
+		}
+
+		bool fail = false;
+		if (ta != tb) {
+			printf("Mismatch:  %jd != %jd\n", (intmax_t)ta, (intmax_t)tb);
+			fail = true;
+		}
+		if (ta != -1 && !tm_equal(&tma, &tmb)) {
+			printf("mktime():  ");
+			tm_print(stdout, &tma);
+			printf("xtimegm(): ");
+			tm_print(stdout, &tmb);
+			fail = true;
+		}
+		if (fail) {
+			printf("Input:     ");
+			tm_print(stdout, &tm);
+			return false;
+		}
+	}
+
+	return true;
+}
diff --git a/tests/xtimegm.c b/tests/xtimegm.c
deleted file mode 100644
index 973b2eb..0000000
--- a/tests/xtimegm.c
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright © Tavian Barnes <tavianator@tavianator.com>
-// SPDX-License-Identifier: 0BSD
-
-#include "../src/xtime.h"
-#include "../src/config.h"
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <time.h>
-
-static bool tm_equal(const struct tm *tma, const struct tm *tmb) {
-	if (tma->tm_year != tmb->tm_year) {
-		return false;
-	}
-	if (tma->tm_mon != tmb->tm_mon) {
-		return false;
-	}
-	if (tma->tm_mday != tmb->tm_mday) {
-		return false;
-	}
-	if (tma->tm_hour != tmb->tm_hour) {
-		return false;
-	}
-	if (tma->tm_min != tmb->tm_min) {
-		return false;
-	}
-	if (tma->tm_sec != tmb->tm_sec) {
-		return false;
-	}
-	if (tma->tm_wday != tmb->tm_wday) {
-		return false;
-	}
-	if (tma->tm_yday != tmb->tm_yday) {
-		return false;
-	}
-	if (tma->tm_isdst != tmb->tm_isdst) {
-		return false;
-	}
-
-	return true;
-}
-
-static void tm_print(FILE *file, const struct tm *tm) {
-	fprintf(file, "Y%d M%d D%d  h%d m%d s%d  wd%d yd%d%s\n",
-		tm->tm_year, tm->tm_mon, tm->tm_mday,
-		tm->tm_hour, tm->tm_min, tm->tm_sec,
-		tm->tm_wday, tm->tm_yday,
-		tm->tm_isdst ? (tm->tm_isdst < 0 ? " (DST?)" : " (DST)") : "");
-}
-
-int main(void) {
-	if (setenv("TZ", "UTC0", true) != 0) {
-		perror("setenv()");
-		return EXIT_FAILURE;
-	}
-
-	struct tm tm = {
-		.tm_isdst = -1,
-	};
-
-	for (tm.tm_year = 10; tm.tm_year <= 200; tm.tm_year += 10)
-	for (tm.tm_mon = -3; tm.tm_mon <= 15; tm.tm_mon += 3)
-	for (tm.tm_mday = -31; tm.tm_mday <= 61; tm.tm_mday += 4)
-	for (tm.tm_hour = -1; tm.tm_hour <= 24; tm.tm_hour += 5)
-	for (tm.tm_min = -1; tm.tm_min <= 60; tm.tm_min += 31)
-	for (tm.tm_sec = -60; tm.tm_sec <= 120; tm.tm_sec += 5) {
-		struct tm tma = tm, tmb = tm;
-		time_t ta, tb;
-		ta = mktime(&tma);
-		if (xtimegm(&tmb, &tb) != 0) {
-			tb = -1;
-		}
-
-		bool fail = false;
-		if (ta != tb) {
-			printf("Mismatch:  %jd != %jd\n", (intmax_t)ta, (intmax_t)tb);
-			fail = true;
-		}
-		if (ta != -1 && !tm_equal(&tma, &tmb)) {
-			printf("mktime():  ");
-			tm_print(stdout, &tma);
-			printf("xtimegm(): ");
-			tm_print(stdout, &tmb);
-			fail = true;
-		}
-		if (fail) {
-			printf("Input:     ");
-			tm_print(stdout, &tm);
-			return EXIT_FAILURE;
-		}
-	}
-
-	return EXIT_SUCCESS;
-}
-- 
cgit v1.2.3


From 4e2f094d29ff8140f2b46a059128c780560db0f1 Mon Sep 17 00:00:00 2001
From: Tavian Barnes <tavianator@tavianator.com>
Date: Thu, 29 Feb 2024 13:23:02 -0500
Subject: tests: New bfs_check() macro

We now report failures and continue, rather than aborting after the
first failure.
---
 tests/alloc.c |  22 +++---
 tests/bfstd.c |  65 +++++++++--------
 tests/bit.c   | 108 ++++++++++++++--------------
 tests/tests.h |  20 ++++++
 tests/trie.c  |  46 ++++++------
 tests/xtime.c | 220 ++++++++++++++++++++++++++--------------------------------
 6 files changed, 247 insertions(+), 234 deletions(-)

(limited to 'tests/alloc.c')

diff --git a/tests/alloc.c b/tests/alloc.c
index e14f131..4ce23d4 100644
--- a/tests/alloc.c
+++ b/tests/alloc.c
@@ -9,30 +9,32 @@
 #include <stdint.h>
 
 bool check_alloc(void) {
+	bool ret = true;
+
 	// Check sizeof_flex()
 	struct flexible {
 		alignas(64) int foo[8];
 		int bar[];
 	};
-	bfs_verify(sizeof_flex(struct flexible, bar, 0) >= sizeof(struct flexible));
-	bfs_verify(sizeof_flex(struct flexible, bar, 16) % alignof(struct flexible) == 0);
+	ret &= bfs_check(sizeof_flex(struct flexible, bar, 0) >= sizeof(struct flexible));
+	ret &= bfs_check(sizeof_flex(struct flexible, bar, 16) % alignof(struct flexible) == 0);
 
 	size_t too_many = SIZE_MAX / sizeof(int) + 1;
-	bfs_verify(sizeof_flex(struct flexible, bar, too_many) == align_floor(alignof(struct flexible), SIZE_MAX));
+	ret &= bfs_check(sizeof_flex(struct flexible, bar, too_many) == align_floor(alignof(struct flexible), SIZE_MAX));
 
 	// Corner case: sizeof(type) > align_ceil(alignof(type), offsetof(type, member))
 	// Doesn't happen in typical ABIs
-	bfs_verify(flex_size(8, 16, 4, 4, 1) == 16);
+	ret &= bfs_check(flex_size(8, 16, 4, 4, 1) == 16);
 
 	// Make sure we detect allocation size overflows
 #if __GNUC__ && !__clang__
 #  pragma GCC diagnostic ignored "-Walloc-size-larger-than="
 #endif
 
-	bfs_verify(ALLOC_ARRAY(int, too_many) == NULL && errno == EOVERFLOW);
-	bfs_verify(ZALLOC_ARRAY(int, too_many) == NULL && errno == EOVERFLOW);
-	bfs_verify(ALLOC_FLEX(struct flexible, bar, too_many) == NULL && errno == EOVERFLOW);
-	bfs_verify(ZALLOC_FLEX(struct flexible, bar, too_many) == NULL && errno == EOVERFLOW);
+	ret &= bfs_check(ALLOC_ARRAY(int, too_many) == NULL && errno == EOVERFLOW);
+	ret &= bfs_check(ZALLOC_ARRAY(int, too_many) == NULL && errno == EOVERFLOW);
+	ret &= bfs_check(ALLOC_FLEX(struct flexible, bar, too_many) == NULL && errno == EOVERFLOW);
+	ret &= bfs_check(ZALLOC_FLEX(struct flexible, bar, too_many) == NULL && errno == EOVERFLOW);
 
 	// varena tests
 	struct varena varena;
@@ -41,9 +43,9 @@ bool check_alloc(void) {
 	for (size_t i = 0; i < 256; ++i) {
 		bfs_verify(varena_alloc(&varena, i));
 		struct arena *arena = &varena.arenas[varena.narenas - 1];
-		bfs_verify(arena->size >= sizeof_flex(struct flexible, bar, i));
+		ret &= bfs_check(arena->size >= sizeof_flex(struct flexible, bar, i));
 	}
 
 	varena_destroy(&varena);
-	return true;
+	return ret;
 }
diff --git a/tests/bfstd.c b/tests/bfstd.c
index d385c6b..4d0ec23 100644
--- a/tests/bfstd.c
+++ b/tests/bfstd.c
@@ -14,61 +14,68 @@
 #include <string.h>
 
 /** Check the result of xdirname()/xbasename(). */
-static void check_base_dir(const char *path, const char *dir, const char *base) {
+static bool check_base_dir(const char *path, const char *dir, const char *base) {
+	bool ret = true;
+
 	char *xdir = xdirname(path);
 	bfs_verify(xdir, "xdirname(): %s", xstrerror(errno));
-	bfs_verify(strcmp(xdir, dir) == 0, "xdirname('%s') == '%s' (!= '%s')", path, xdir, dir);
+	ret &= bfs_check(strcmp(xdir, dir) == 0, "xdirname('%s') == '%s' (!= '%s')", path, xdir, dir);
 	free(xdir);
 
 	char *xbase = xbasename(path);
 	bfs_verify(xbase, "xbasename(): %s", xstrerror(errno));
-	bfs_verify(strcmp(xbase, base) == 0, "xbasename('%s') == '%s' (!= '%s')", path, xbase, base);
+	ret &= bfs_check(strcmp(xbase, base) == 0, "xbasename('%s') == '%s' (!= '%s')", path, xbase, base);
 	free(xbase);
+
+	return ret;
 }
 
 /** Check the result of wordesc(). */
-static void check_wordesc(const char *str, const char *exp, enum wesc_flags flags) {
+static bool check_wordesc(const char *str, const char *exp, enum wesc_flags flags) {
 	char buf[256];
 	char *end = buf + sizeof(buf);
-	char *ret = wordesc(buf, end, str, flags);
-	bfs_verify(ret != end);
-	bfs_verify(strcmp(buf, exp) == 0, "wordesc(%s) == %s (!= %s)", str, buf, exp);
+	char *esc = wordesc(buf, end, str, flags);
+
+	return bfs_check(esc != end)
+		&& bfs_check(strcmp(buf, exp) == 0, "wordesc('%s') == '%s' (!= '%s')", str, buf, exp);
 }
 
 bool check_bfstd(void) {
+	bool ret = true;
+
 	// Try to set a UTF-8 locale
 	if (!setlocale(LC_ALL, "C.UTF-8")) {
 		setlocale(LC_ALL, "");
 	}
 
 	// From man 3p basename
-	check_base_dir("usr", ".", "usr");
-	check_base_dir("usr/", ".", "usr");
-	check_base_dir("", ".", ".");
-	check_base_dir("/", "/", "/");
+	ret &= check_base_dir("usr", ".", "usr");
+	ret &= check_base_dir("usr/", ".", "usr");
+	ret &= check_base_dir("", ".", ".");
+	ret &= check_base_dir("/", "/", "/");
 	// check_base_dir("//", "/" or "//", "/" or "//");
-	check_base_dir("///", "/", "/");
-	check_base_dir("/usr/", "/", "usr");
-	check_base_dir("/usr/lib", "/usr", "lib");
-	check_base_dir("//usr//lib//", "//usr", "lib");
-	check_base_dir("/home//dwc//test", "/home//dwc", "test");
+	ret &= check_base_dir("///", "/", "/");
+	ret &= check_base_dir("/usr/", "/", "usr");
+	ret &= check_base_dir("/usr/lib", "/usr", "lib");
+	ret &= check_base_dir("//usr//lib//", "//usr", "lib");
+	ret &= check_base_dir("/home//dwc//test", "/home//dwc", "test");
 
-	check_wordesc("", "\"\"", WESC_SHELL);
-	check_wordesc("word", "word", WESC_SHELL);
-	check_wordesc("two words", "\"two words\"", WESC_SHELL);
-	check_wordesc("word's", "\"word's\"", WESC_SHELL);
-	check_wordesc("\"word\"", "'\"word\"'", WESC_SHELL);
-	check_wordesc("\"word's\"", "'\"word'\\''s\"'", WESC_SHELL);
-	check_wordesc("\033[1mbold's\033[0m", "$'\\e[1mbold\\'s\\e[0m'", WESC_SHELL | WESC_TTY);
-	check_wordesc("\x7F", "$'\\x7F'", WESC_SHELL | WESC_TTY);
+	ret &= check_wordesc("", "\"\"", WESC_SHELL);
+	ret &= check_wordesc("word", "word", WESC_SHELL);
+	ret &= check_wordesc("two words", "\"two words\"", WESC_SHELL);
+	ret &= check_wordesc("word's", "\"word's\"", WESC_SHELL);
+	ret &= check_wordesc("\"word\"", "'\"word\"'", WESC_SHELL);
+	ret &= check_wordesc("\"word's\"", "'\"word'\\''s\"'", WESC_SHELL);
+	ret &= check_wordesc("\033[1mbold's\033[0m", "$'\\e[1mbold\\'s\\e[0m'", WESC_SHELL | WESC_TTY);
+	ret &= check_wordesc("\x7F", "$'\\x7F'", WESC_SHELL | WESC_TTY);
 
 	const char *charmap = nl_langinfo(CODESET);
 	if (strcmp(charmap, "UTF-8") == 0) {
-		check_wordesc("\xF0", "$'\\xF0'", WESC_SHELL | WESC_TTY);
-		check_wordesc("\xF0\x9F", "$'\\xF0\\x9F'", WESC_SHELL | WESC_TTY);
-		check_wordesc("\xF0\x9F\x98", "$'\\xF0\\x9F\\x98'", WESC_SHELL | WESC_TTY);
-		check_wordesc("\xF0\x9F\x98\x80", "\xF0\x9F\x98\x80", WESC_SHELL | WESC_TTY);
+		ret &= check_wordesc("\xF0", "$'\\xF0'", WESC_SHELL | WESC_TTY);
+		ret &= check_wordesc("\xF0\x9F", "$'\\xF0\\x9F'", WESC_SHELL | WESC_TTY);
+		ret &= check_wordesc("\xF0\x9F\x98", "$'\\xF0\\x9F\\x98'", WESC_SHELL | WESC_TTY);
+		ret &= check_wordesc("\xF0\x9F\x98\x80", "\xF0\x9F\x98\x80", WESC_SHELL | WESC_TTY);
 	}
 
-	return true;
+	return ret;
 }
diff --git a/tests/bit.c b/tests/bit.c
index 1c6a4de..b944748 100644
--- a/tests/bit.c
+++ b/tests/bit.c
@@ -52,75 +52,77 @@ bfs_static_assert(UINTMAX_MAX == UWIDTH_MAX(UINTMAX_WIDTH));
 bfs_static_assert(INTMAX_MIN == IWIDTH_MIN(INTMAX_WIDTH));
 bfs_static_assert(INTMAX_MAX == IWIDTH_MAX(INTMAX_WIDTH));
 
-#define verify_eq(a, b) \
-	bfs_verify((a) == (b), "(0x%jX) %s != %s (0x%jX)", (uintmax_t)(a), #a, #b, (uintmax_t)(b))
+#define check_eq(a, b) \
+	bfs_check((a) == (b), "(0x%jX) %s != %s (0x%jX)", (uintmax_t)(a), #a, #b, (uintmax_t)(b))
 
 bool check_bit(void) {
-	verify_eq(bswap((uint8_t)0x12), 0x12);
-	verify_eq(bswap((uint16_t)0x1234), 0x3412);
-	verify_eq(bswap((uint32_t)0x12345678), 0x78563412);
-	verify_eq(bswap((uint64_t)0x1234567812345678), 0x7856341278563412);
-
-	verify_eq(count_ones(0x0), 0);
-	verify_eq(count_ones(0x1), 1);
-	verify_eq(count_ones(0x2), 1);
-	verify_eq(count_ones(0x3), 2);
-	verify_eq(count_ones(0x137F), 10);
-
-	verify_eq(count_zeros(0), INT_WIDTH);
-	verify_eq(count_zeros(0L), LONG_WIDTH);
-	verify_eq(count_zeros(0LL), LLONG_WIDTH);
-	verify_eq(count_zeros((uint8_t)0), 8);
-	verify_eq(count_zeros((uint16_t)0), 16);
-	verify_eq(count_zeros((uint32_t)0), 32);
-	verify_eq(count_zeros((uint64_t)0), 64);
-
-	verify_eq(rotate_left((uint8_t)0xA1, 4), 0x1A);
-	verify_eq(rotate_left((uint16_t)0x1234, 12), 0x4123);
-	verify_eq(rotate_left((uint32_t)0x12345678, 20), 0x67812345);
-	verify_eq(rotate_left((uint32_t)0x12345678, 0), 0x12345678);
-
-	verify_eq(rotate_right((uint8_t)0xA1, 4), 0x1A);
-	verify_eq(rotate_right((uint16_t)0x1234, 12), 0x2341);
-	verify_eq(rotate_right((uint32_t)0x12345678, 20), 0x45678123);
-	verify_eq(rotate_right((uint32_t)0x12345678, 0), 0x12345678);
+	bool ret = true;
+
+	ret &= check_eq(bswap((uint8_t)0x12), 0x12);
+	ret &= check_eq(bswap((uint16_t)0x1234), 0x3412);
+	ret &= check_eq(bswap((uint32_t)0x12345678), 0x78563412);
+	ret &= check_eq(bswap((uint64_t)0x1234567812345678), 0x7856341278563412);
+
+	ret &= check_eq(count_ones(0x0), 0);
+	ret &= check_eq(count_ones(0x1), 1);
+	ret &= check_eq(count_ones(0x2), 1);
+	ret &= check_eq(count_ones(0x3), 2);
+	ret &= check_eq(count_ones(0x137F), 10);
+
+	ret &= check_eq(count_zeros(0), INT_WIDTH);
+	ret &= check_eq(count_zeros(0L), LONG_WIDTH);
+	ret &= check_eq(count_zeros(0LL), LLONG_WIDTH);
+	ret &= check_eq(count_zeros((uint8_t)0), 8);
+	ret &= check_eq(count_zeros((uint16_t)0), 16);
+	ret &= check_eq(count_zeros((uint32_t)0), 32);
+	ret &= check_eq(count_zeros((uint64_t)0), 64);
+
+	ret &= check_eq(rotate_left((uint8_t)0xA1, 4), 0x1A);
+	ret &= check_eq(rotate_left((uint16_t)0x1234, 12), 0x4123);
+	ret &= check_eq(rotate_left((uint32_t)0x12345678, 20), 0x67812345);
+	ret &= check_eq(rotate_left((uint32_t)0x12345678, 0), 0x12345678);
+
+	ret &= check_eq(rotate_right((uint8_t)0xA1, 4), 0x1A);
+	ret &= check_eq(rotate_right((uint16_t)0x1234, 12), 0x2341);
+	ret &= check_eq(rotate_right((uint32_t)0x12345678, 20), 0x45678123);
+	ret &= check_eq(rotate_right((uint32_t)0x12345678, 0), 0x12345678);
 
 	for (int i = 0; i < 16; ++i) {
 		uint16_t n = (uint16_t)1 << i;
 		for (int j = i; j < 16; ++j) {
 			uint16_t m = (uint16_t)1 << j;
 			uint16_t nm = n | m;
-			verify_eq(count_ones(nm), 1 + (n != m));
-			verify_eq(count_zeros(nm), 15 - (n != m));
-			verify_eq(leading_zeros(nm), 15 - j);
-			verify_eq(trailing_zeros(nm), i);
-			verify_eq(first_leading_one(nm), j + 1);
-			verify_eq(first_trailing_one(nm), i + 1);
-			verify_eq(bit_width(nm), j + 1);
-			verify_eq(bit_floor(nm), m);
+			ret &= check_eq(count_ones(nm), 1 + (n != m));
+			ret &= check_eq(count_zeros(nm), 15 - (n != m));
+			ret &= check_eq(leading_zeros(nm), 15 - j);
+			ret &= check_eq(trailing_zeros(nm), i);
+			ret &= check_eq(first_leading_one(nm), j + 1);
+			ret &= check_eq(first_trailing_one(nm), i + 1);
+			ret &= check_eq(bit_width(nm), j + 1);
+			ret &= check_eq(bit_floor(nm), m);
 			if (n == m) {
-				verify_eq(bit_ceil(nm), m);
-				bfs_verify(has_single_bit(nm));
+				ret &= check_eq(bit_ceil(nm), m);
+				ret &= bfs_check(has_single_bit(nm));
 			} else {
 				if (j < 15) {
-					verify_eq(bit_ceil(nm), (m << 1));
+					ret &= check_eq(bit_ceil(nm), (m << 1));
 				}
-				bfs_verify(!has_single_bit(nm));
+				ret &= bfs_check(!has_single_bit(nm));
 			}
 		}
 	}
 
-	verify_eq(leading_zeros((uint16_t)0), 16);
-	verify_eq(trailing_zeros((uint16_t)0), 16);
-	verify_eq(first_leading_one(0), 0);
-	verify_eq(first_trailing_one(0), 0);
-	verify_eq(bit_width(0), 0);
-	verify_eq(bit_floor(0), 0);
-	verify_eq(bit_ceil(0), 1);
+	ret &= check_eq(leading_zeros((uint16_t)0), 16);
+	ret &= check_eq(trailing_zeros((uint16_t)0), 16);
+	ret &= check_eq(first_leading_one(0), 0);
+	ret &= check_eq(first_trailing_one(0), 0);
+	ret &= check_eq(bit_width(0), 0);
+	ret &= check_eq(bit_floor(0), 0);
+	ret &= check_eq(bit_ceil(0), 1);
 
-	bfs_verify(!has_single_bit(0));
-	bfs_verify(!has_single_bit(UINT32_MAX));
-	bfs_verify(has_single_bit((uint32_t)1 << (UINT_WIDTH - 1)));
+	ret &= bfs_check(!has_single_bit(0));
+	ret &= bfs_check(!has_single_bit(UINT32_MAX));
+	ret &= bfs_check(has_single_bit((uint32_t)1 << (UINT_WIDTH - 1)));
 
-	return true;
+	return ret;
 }
diff --git a/tests/tests.h b/tests/tests.h
index d8adbb9..6629dcf 100644
--- a/tests/tests.h
+++ b/tests/tests.h
@@ -9,6 +9,7 @@
 #define BFS_TESTS_H
 
 #include "../src/config.h"
+#include "../src/diag.h"
 
 /** Unit test function type. */
 typedef bool test_fn(void);
@@ -31,4 +32,23 @@ bool check_trie(void);
 /** Time tests. */
 bool check_xtime(void);
 
+/** Don't ignore the bfs_check() return value. */
+attr(nodiscard)
+static inline bool bfs_check(bool ret) {
+	return ret;
+}
+
+/**
+ * Check a condition, logging a message on failure but continuing.
+ */
+#define bfs_check(...) \
+	bfs_check(bfs_check_(#__VA_ARGS__, __VA_ARGS__, "", ""))
+
+#define bfs_check_(str, cond, format, ...) \
+	((cond) ? true : (bfs_diag( \
+		sizeof(format) > 1 \
+			? "%.0s" format "%s%s" \
+			: "Check failed: `%s`%s", \
+		str, __VA_ARGS__), false))
+
 #endif // BFS_TESTS_H
diff --git a/tests/trie.c b/tests/trie.c
index f94d7c8..fec0de2 100644
--- a/tests/trie.c
+++ b/tests/trie.c
@@ -40,11 +40,13 @@ const char *keys[] = {
 const size_t nkeys = countof(keys);
 
 bool check_trie(void) {
+	bool ret = true;
+
 	struct trie trie;
 	trie_init(&trie);
 
 	for (size_t i = 0; i < nkeys; ++i) {
-		bfs_verify(!trie_find_str(&trie, keys[i]));
+		ret &= bfs_check(!trie_find_str(&trie, keys[i]));
 
 		const char *prefix = NULL;
 		for (size_t j = 0; j < i; ++j) {
@@ -58,37 +60,37 @@ bool check_trie(void) {
 		struct trie_leaf *leaf = trie_find_prefix(&trie, keys[i]);
 		if (prefix) {
 			bfs_verify(leaf);
-			bfs_verify(strcmp(prefix, leaf->key) == 0);
+			ret &= bfs_check(strcmp(prefix, leaf->key) == 0);
 		} else {
-			bfs_verify(!leaf);
+			ret &= bfs_check(!leaf);
 		}
 
 		leaf = trie_insert_str(&trie, keys[i]);
 		bfs_verify(leaf);
-		bfs_verify(strcmp(keys[i], leaf->key) == 0);
-		bfs_verify(leaf->length == strlen(keys[i]) + 1);
+		ret &= bfs_check(strcmp(keys[i], leaf->key) == 0);
+		ret &= bfs_check(leaf->length == strlen(keys[i]) + 1);
 	}
 
 	{
 		size_t i = 0;
 		for_trie (leaf, &trie) {
-			bfs_verify(leaf == trie_find_str(&trie, keys[i]));
-			bfs_verify(!leaf->prev || leaf->prev->next == leaf);
-			bfs_verify(!leaf->next || leaf->next->prev == leaf);
+			ret &= bfs_check(leaf == trie_find_str(&trie, keys[i]));
+			ret &= bfs_check(!leaf->prev || leaf->prev->next == leaf);
+			ret &= bfs_check(!leaf->next || leaf->next->prev == leaf);
 			++i;
 		}
-		bfs_verify(i == nkeys);
+		ret &= bfs_check(i == nkeys);
 	}
 
 	for (size_t i = 0; i < nkeys; ++i) {
 		struct trie_leaf *leaf = trie_find_str(&trie, keys[i]);
 		bfs_verify(leaf);
-		bfs_verify(strcmp(keys[i], leaf->key) == 0);
-		bfs_verify(leaf->length == strlen(keys[i]) + 1);
+		ret &= bfs_check(strcmp(keys[i], leaf->key) == 0);
+		ret &= bfs_check(leaf->length == strlen(keys[i]) + 1);
 
 		trie_remove(&trie, leaf);
 		leaf = trie_find_str(&trie, keys[i]);
-		bfs_verify(!leaf);
+		ret &= bfs_check(!leaf);
 
 		const char *postfix = NULL;
 		for (size_t j = i + 1; j < nkeys; ++j) {
@@ -102,14 +104,14 @@ bool check_trie(void) {
 		leaf = trie_find_postfix(&trie, keys[i]);
 		if (postfix) {
 			bfs_verify(leaf);
-			bfs_verify(strcmp(postfix, leaf->key) == 0);
+			ret &= bfs_check(strcmp(postfix, leaf->key) == 0);
 		} else {
-			bfs_verify(!leaf);
+			ret &= bfs_check(!leaf);
 		}
 	}
 
 	for_trie (leaf, &trie) {
-		bfs_verify(false);
+		ret &= bfs_check(false, "trie should be empty");
 	}
 
 	// This tests the "jump" node handling on 32-bit platforms
@@ -118,18 +120,18 @@ bool check_trie(void) {
 	bfs_verify(longstr);
 
 	memset(longstr, 0xAC, longsize);
-	bfs_verify(!trie_find_mem(&trie, longstr, longsize));
-	bfs_verify(trie_insert_mem(&trie, longstr, longsize));
+	ret &= bfs_check(!trie_find_mem(&trie, longstr, longsize));
+	ret &= bfs_check(trie_insert_mem(&trie, longstr, longsize));
 
 	memset(longstr + longsize / 2, 0xAB, longsize / 2);
-	bfs_verify(!trie_find_mem(&trie, longstr, longsize));
-	bfs_verify(trie_insert_mem(&trie, longstr, longsize));
+	ret &= bfs_check(!trie_find_mem(&trie, longstr, longsize));
+	ret &= bfs_check(trie_insert_mem(&trie, longstr, longsize));
 
 	memset(longstr, 0xAA, longsize / 2);
-	bfs_verify(!trie_find_mem(&trie, longstr, longsize));
-	bfs_verify(trie_insert_mem(&trie, longstr, longsize));
+	ret &= bfs_check(!trie_find_mem(&trie, longstr, longsize));
+	ret &= bfs_check(trie_insert_mem(&trie, longstr, longsize));
 
 	free(longstr);
 	trie_destroy(&trie);
-	return true;
+	return ret;
 }
diff --git a/tests/xtime.c b/tests/xtime.c
index 4a7d55c..f853428 100644
--- a/tests/xtime.c
+++ b/tests/xtime.c
@@ -12,121 +12,122 @@
 #include <time.h>
 
 static bool tm_equal(const struct tm *tma, const struct tm *tmb) {
-	if (tma->tm_year != tmb->tm_year) {
-		return false;
-	}
-	if (tma->tm_mon != tmb->tm_mon) {
-		return false;
-	}
-	if (tma->tm_mday != tmb->tm_mday) {
-		return false;
-	}
-	if (tma->tm_hour != tmb->tm_hour) {
-		return false;
-	}
-	if (tma->tm_min != tmb->tm_min) {
-		return false;
-	}
-	if (tma->tm_sec != tmb->tm_sec) {
-		return false;
-	}
-	if (tma->tm_wday != tmb->tm_wday) {
-		return false;
-	}
-	if (tma->tm_yday != tmb->tm_yday) {
-		return false;
-	}
-	if (tma->tm_isdst != tmb->tm_isdst) {
-		return false;
-	}
-
-	return true;
-}
-
-static void tm_print(FILE *file, const struct tm *tm) {
-	fprintf(file, "Y%d M%d D%d  h%d m%d s%d  wd%d yd%d%s\n",
-		tm->tm_year, tm->tm_mon, tm->tm_mday,
-		tm->tm_hour, tm->tm_min, tm->tm_sec,
-		tm->tm_wday, tm->tm_yday,
-		tm->tm_isdst ? (tm->tm_isdst < 0 ? " (DST?)" : " (DST)") : "");
+	return tma->tm_year == tmb->tm_year
+		&& tma->tm_mon == tmb->tm_mon
+		&& tma->tm_mday == tmb->tm_mday
+		&& tma->tm_hour == tmb->tm_hour
+		&& tma->tm_min == tmb->tm_min
+		&& tma->tm_sec == tmb->tm_sec
+		&& tma->tm_wday == tmb->tm_wday
+		&& tma->tm_yday == tmb->tm_yday
+		&& tma->tm_isdst == tmb->tm_isdst;
 }
 
 /** Check one xgetdate() result. */
-static bool compare_xgetdate(const char *str, int error, time_t expected) {
+static bool check_one_xgetdate(const char *str, int error, time_t expected) {
 	struct timespec ts;
 	int ret = xgetdate(str, &ts);
 
 	if (error) {
-		if (ret != -1 || errno != error) {
-			fprintf(stderr, "xgetdate('%s'): %s\n", str, xstrerror(errno));
-			return false;
-		}
-	} else if (ret != 0) {
-		fprintf(stderr, "xgetdate('%s'): %s\n", str, xstrerror(errno));
-		return false;
-	} else if (ts.tv_sec != expected || ts.tv_nsec != 0) {
-		fprintf(stderr, "xgetdate('%s'): %jd.%09jd != %jd\n", str, (intmax_t)ts.tv_sec, (intmax_t)ts.tv_nsec, (intmax_t)expected);
-		return false;
+		return bfs_check(ret == -1 && errno == error, "xgetdate('%s'): %s", str, xstrerror(errno));
+	} else {
+		return bfs_check(ret == 0, "xgetdate('%s'): %s", str, xstrerror(errno))
+			&& bfs_check(ts.tv_sec == expected && ts.tv_nsec == 0,
+				"xgetdate('%s'): %jd.%09jd != %jd",
+				str, (intmax_t)ts.tv_sec, (intmax_t)ts.tv_nsec, (intmax_t)expected);
 	}
-
-	return true;
 }
 
 /** xgetdate() tests. */
 static bool check_xgetdate(void) {
-	return compare_xgetdate("", EINVAL, 0)
-		& compare_xgetdate("????", EINVAL, 0)
-		& compare_xgetdate("1991", EINVAL, 0)
-		& compare_xgetdate("1991-??", EINVAL, 0)
-		& compare_xgetdate("1991-12", EINVAL, 0)
-		& compare_xgetdate("1991-12-", EINVAL, 0)
-		& compare_xgetdate("1991-12-??", EINVAL, 0)
-		& compare_xgetdate("1991-12-14", 0, 692668800)
-		& compare_xgetdate("1991-12-14-", EINVAL, 0)
-		& compare_xgetdate("1991-12-14T", EINVAL, 0)
-		& compare_xgetdate("1991-12-14T??", EINVAL, 0)
-		& compare_xgetdate("1991-12-14T10", 0, 692704800)
-		& compare_xgetdate("1991-12-14T10:??", EINVAL, 0)
-		& compare_xgetdate("1991-12-14T10:11", 0, 692705460)
-		& compare_xgetdate("1991-12-14T10:11:??", EINVAL, 0)
-		& compare_xgetdate("1991-12-14T10:11:12", 0, 692705472)
-		& compare_xgetdate("1991-12-14T10Z", 0, 692704800)
-		& compare_xgetdate("1991-12-14T10:11Z", 0, 692705460)
-		& compare_xgetdate("1991-12-14T10:11:12Z", 0, 692705472)
-		& compare_xgetdate("1991-12-14T10:11:12?", EINVAL, 0)
-		& compare_xgetdate("1991-12-14T03-07", 0, 692704800)
-		& compare_xgetdate("1991-12-14T06:41-03:30", 0, 692705460)
-		& compare_xgetdate("1991-12-14T03:11:12-07:00", 0, 692705472)
-		& compare_xgetdate("19911214 031112-0700", 0, 692705472);
+	bool ret = true;
+
+	ret &= check_one_xgetdate("", EINVAL, 0);
+	ret &= check_one_xgetdate("????", EINVAL, 0);
+	ret &= check_one_xgetdate("1991", EINVAL, 0);
+	ret &= check_one_xgetdate("1991-??", EINVAL, 0);
+	ret &= check_one_xgetdate("1991-12", EINVAL, 0);
+	ret &= check_one_xgetdate("1991-12-", EINVAL, 0);
+	ret &= check_one_xgetdate("1991-12-??", EINVAL, 0);
+	ret &= check_one_xgetdate("1991-12-14", 0, 692668800);
+	ret &= check_one_xgetdate("1991-12-14-", EINVAL, 0);
+	ret &= check_one_xgetdate("1991-12-14T", EINVAL, 0);
+	ret &= check_one_xgetdate("1991-12-14T??", EINVAL, 0);
+	ret &= check_one_xgetdate("1991-12-14T10", 0, 692704800);
+	ret &= check_one_xgetdate("1991-12-14T10:??", EINVAL, 0);
+	ret &= check_one_xgetdate("1991-12-14T10:11", 0, 692705460);
+	ret &= check_one_xgetdate("1991-12-14T10:11:??", EINVAL, 0);
+	ret &= check_one_xgetdate("1991-12-14T10:11:12", 0, 692705472);
+	ret &= check_one_xgetdate("1991-12-14T10Z", 0, 692704800);
+	ret &= check_one_xgetdate("1991-12-14T10:11Z", 0, 692705460);
+	ret &= check_one_xgetdate("1991-12-14T10:11:12Z", 0, 692705472);
+	ret &= check_one_xgetdate("1991-12-14T10:11:12?", EINVAL, 0);
+	ret &= check_one_xgetdate("1991-12-14T03-07", 0, 692704800);
+	ret &= check_one_xgetdate("1991-12-14T06:41-03:30", 0, 692705460);
+	ret &= check_one_xgetdate("1991-12-14T03:11:12-07:00", 0, 692705472);
+	ret &= check_one_xgetdate("19911214 031112-0700", 0, 692705472);;
+
+	return ret;
+}
+
+#define TM_FORMAT "%04d-%02d-%02d %02d:%02d:%02d (%d/7, %d/365%s)"
+
+#define TM_PRINTF(tm) \
+	(1900 + (tm).tm_year), (tm).tm_mon, (tm).tm_mday, \
+	(tm).tm_hour, (tm).tm_min, (tm).tm_sec, \
+	((tm).tm_wday + 1), ((tm).tm_yday + 1), \
+	((tm).tm_isdst ? ((tm).tm_isdst < 0 ? ", DST?" : ", DST") : "")
+
+/** Check one xmktime() result. */
+static bool check_one_xmktime(time_t expected) {
+	struct tm tm;
+	if (xlocaltime(&expected, &tm) != 0) {
+		bfs_diag("xlocaltime(%jd): %s", (intmax_t)expected, xstrerror(errno));
+		return false;
+	}
+
+	time_t actual;
+	return bfs_check(xmktime(&tm, &actual) == 0, "xmktime(" TM_FORMAT "): %s", TM_PRINTF(tm), xstrerror(errno))
+		&& bfs_check(actual == expected, "xmktime(" TM_FORMAT "): %jd != %jd", TM_PRINTF(tm), (intmax_t)actual, (intmax_t)expected);
 }
 
 /** xmktime() tests. */
 static bool check_xmktime(void) {
+	bool ret = true;
+
 	for (time_t time = -10; time <= 10; ++time) {
-		struct tm tm;
-		if (xlocaltime(&time, &tm) != 0) {
-			perror("xlocaltime()");
-			return false;
-		}
-
-		time_t made;
-		if (xmktime(&tm, &made) != 0) {
-			perror("xmktime()");
-			return false;
-		}
-
-		if (time != made) {
-			fprintf(stderr, "Mismatch: %jd != %jd\n", (intmax_t)time, (intmax_t)made);
-			tm_print(stderr, &tm);
-			return false;
-		}
+		ret &= check_one_xmktime(time);
+	}
+
+	return ret;
+}
+
+/** Check one xtimegm() result. */
+static bool check_one_xtimegm(const struct tm *tm) {
+	struct tm tma = *tm, tmb = *tm;
+	time_t ta, tb;
+	ta = mktime(&tma);
+	if (xtimegm(&tmb, &tb) != 0) {
+		tb = -1;
 	}
 
-	return true;
+	bool ret = true;
+	ret &= bfs_check(ta == tb, "%jd != %jd", (intmax_t)ta, (intmax_t)tb);
+	ret &= bfs_check(ta == -1 || tm_equal(&tma, &tmb));
+
+	if (!ret) {
+		bfs_diag("mktime():  " TM_FORMAT, TM_PRINTF(tma));
+		bfs_diag("xtimegm(): " TM_FORMAT, TM_PRINTF(tmb));
+		bfs_diag("(input):   " TM_FORMAT, TM_PRINTF(*tm));
+	}
+
+	return ret;
 }
 
 /** xtimegm() tests. */
 static bool check_xtimegm(void) {
+	bool ret = true;
+
 	struct tm tm = {
 		.tm_isdst = -1,
 	};
@@ -137,33 +138,10 @@ static bool check_xtimegm(void) {
 	for (tm.tm_hour =  -1; tm.tm_hour <=  24; tm.tm_hour +=  5)
 	for (tm.tm_min  =  -1; tm.tm_min  <=  60; tm.tm_min  += 31)
 	for (tm.tm_sec  = -60; tm.tm_sec  <= 120; tm.tm_sec  +=  5) {
-		struct tm tma = tm, tmb = tm;
-		time_t ta, tb;
-		ta = mktime(&tma);
-		if (xtimegm(&tmb, &tb) != 0) {
-			tb = -1;
-		}
-
-		bool fail = false;
-		if (ta != tb) {
-			printf("Mismatch:  %jd != %jd\n", (intmax_t)ta, (intmax_t)tb);
-			fail = true;
-		}
-		if (ta != -1 && !tm_equal(&tma, &tmb)) {
-			printf("mktime():  ");
-			tm_print(stdout, &tma);
-			printf("xtimegm(): ");
-			tm_print(stdout, &tmb);
-			fail = true;
-		}
-		if (fail) {
-			printf("Input:     ");
-			tm_print(stdout, &tm);
-			return false;
-		}
+		ret &= check_one_xtimegm(&tm);
 	}
 
-	return true;
+	return ret;
 }
 
 bool check_xtime(void) {
@@ -173,7 +151,9 @@ bool check_xtime(void) {
 	}
 	tzset();
 
-	return check_xgetdate()
-		& check_xmktime()
-		& check_xtimegm();
+	bool ret = true;
+	ret &= check_xgetdate();
+	ret &= check_xmktime();
+	ret &= check_xtimegm();
+	return ret;
 }
-- 
cgit v1.2.3


From 2c3ef3a06ee1f951f6d68be6d0d3f6a1822b05b7 Mon Sep 17 00:00:00 2001
From: Tavian Barnes <tavianator@tavianator.com>
Date: Mon, 11 Mar 2024 09:51:03 -0400
Subject: Re-run include-what-you-use

---
 src/alloc.h    | 1 +
 src/bfstd.c    | 6 +++---
 src/bftw.c     | 1 +
 src/color.h    | 1 -
 src/ctx.c      | 1 +
 src/ctx.h      | 2 ++
 src/diag.c     | 2 +-
 src/dir.h      | 4 ++--
 src/dstring.c  | 2 ++
 src/eval.c     | 4 ++--
 src/expr.c     | 4 ++--
 src/expr.h     | 1 -
 src/ioq.c      | 5 +++--
 src/main.c     | 1 +
 src/opt.c      | 3 ++-
 src/parse.c    | 3 +--
 src/printf.c   | 3 ++-
 src/trie.c     | 2 --
 src/trie.h     | 1 -
 src/xspawn.c   | 1 -
 src/xtime.c    | 1 -
 tests/alloc.c  | 1 +
 tests/bfstd.c  | 3 ---
 tests/bit.c    | 2 +-
 tests/ioq.c    | 2 ++
 tests/main.c   | 3 ---
 tests/xtime.c  | 4 ++--
 tests/xtouch.c | 1 +
 28 files changed, 33 insertions(+), 32 deletions(-)

(limited to 'tests/alloc.c')

diff --git a/src/alloc.h b/src/alloc.h
index 60dd738..ae055bc 100644
--- a/src/alloc.h
+++ b/src/alloc.h
@@ -10,6 +10,7 @@
 
 #include "config.h"
 #include <errno.h>
+#include <stddef.h>
 #include <stdlib.h>
 
 /** Check if a size is properly aligned. */
diff --git a/src/bfstd.c b/src/bfstd.c
index ce4aa49..c6c2e7f 100644
--- a/src/bfstd.c
+++ b/src/bfstd.c
@@ -2,18 +2,19 @@
 // SPDX-License-Identifier: 0BSD
 
 #include "bfstd.h"
-#include "bit.h"
 #include "config.h"
 #include "diag.h"
 #include "sanity.h"
 #include "thread.h"
 #include "xregex.h"
-#include <ctype.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <langinfo.h>
+#include <limits.h>
 #include <locale.h>
 #include <nl_types.h>
+#include <pthread.h>
+#include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -24,7 +25,6 @@
 #include <sys/wait.h>
 #include <unistd.h>
 #include <wchar.h>
-#include <wctype.h>
 
 #if BFS_USE_SYS_SYSMACROS_H
 #  include <sys/sysmacros.h>
diff --git a/src/bftw.c b/src/bftw.c
index 6f52299..50b8b02 100644
--- a/src/bftw.c
+++ b/src/bftw.c
@@ -35,6 +35,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
+#include <sys/types.h>
 
 /** Initialize a bftw_stat cache. */
 static void bftw_stat_init(struct bftw_stat *bufs, struct bfs_stat *stat_buf, struct bfs_stat *lstat_buf) {
diff --git a/src/color.h b/src/color.h
index 85633a4..e3e7973 100644
--- a/src/color.h
+++ b/src/color.h
@@ -10,7 +10,6 @@
 
 #include "config.h"
 #include "dstring.h"
-#include <stdarg.h>
 #include <stdio.h>
 
 /**
diff --git a/src/ctx.c b/src/ctx.c
index 6c84f75..f5b28c7 100644
--- a/src/ctx.c
+++ b/src/ctx.c
@@ -6,6 +6,7 @@
 #include "color.h"
 #include "diag.h"
 #include "expr.h"
+#include "list.h"
 #include "mtab.h"
 #include "pwcache.h"
 #include "stat.h"
diff --git a/src/ctx.h b/src/ctx.h
index aa91f2c..e14db21 100644
--- a/src/ctx.h
+++ b/src/ctx.h
@@ -18,6 +18,8 @@
 #include <sys/resource.h>
 #include <time.h>
 
+struct CFILE;
+
 /**
  * The execution context for bfs.
  */
diff --git a/src/diag.c b/src/diag.c
index 656fa89..cb27b92 100644
--- a/src/diag.c
+++ b/src/diag.c
@@ -11,8 +11,8 @@
 #include "expr.h"
 #include <errno.h>
 #include <stdarg.h>
+#include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 
 /** bfs_diagf() implementation. */
 attr(printf(2, 0))
diff --git a/src/dir.h b/src/dir.h
index b11d454..18d907e 100644
--- a/src/dir.h
+++ b/src/dir.h
@@ -8,8 +8,6 @@
 #ifndef BFS_DIR_H
 #define BFS_DIR_H
 
-#include "alloc.h"
-#include "config.h"
 #include <sys/types.h>
 
 /**
@@ -78,6 +76,8 @@ struct bfs_dirent {
  */
 struct bfs_dir *bfs_allocdir(void);
 
+struct arena;
+
 /**
  * Initialize an arena for directories.
  *
diff --git a/src/dstring.c b/src/dstring.c
index bc18308..10b0fad 100644
--- a/src/dstring.c
+++ b/src/dstring.c
@@ -7,6 +7,8 @@
 #include "config.h"
 #include "diag.h"
 #include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
diff --git a/src/eval.c b/src/eval.c
index 1711001..9e55964 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -25,7 +25,6 @@
 #include "stat.h"
 #include "trie.h"
 #include "xregex.h"
-#include "xtime.h"
 #include <errno.h>
 #include <fcntl.h>
 #include <fnmatch.h>
@@ -36,8 +35,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <strings.h>
 #include <sys/resource.h>
-#include <sys/stat.h>
+#include <sys/types.h>
 #include <time.h>
 #include <unistd.h>
 #include <wchar.h>
diff --git a/src/expr.c b/src/expr.c
index 3e0033f..5784220 100644
--- a/src/expr.c
+++ b/src/expr.c
@@ -4,12 +4,12 @@
 #include "expr.h"
 #include "alloc.h"
 #include "ctx.h"
+#include "diag.h"
 #include "eval.h"
 #include "exec.h"
+#include "list.h"
 #include "printf.h"
 #include "xregex.h"
-#include <stdio.h>
-#include <stdlib.h>
 #include <string.h>
 
 struct bfs_expr *bfs_expr_new(struct bfs_ctx *ctx, bfs_eval_fn *eval_fn, size_t argc, char **argv) {
diff --git a/src/expr.h b/src/expr.h
index 957b04a..75cb5fd 100644
--- a/src/expr.h
+++ b/src/expr.h
@@ -12,7 +12,6 @@
 #include "config.h"
 #include "eval.h"
 #include "stat.h"
-#include <stddef.h>
 #include <sys/types.h>
 #include <time.h>
 
diff --git a/src/ioq.c b/src/ioq.c
index 00c3b86..37eed7d 100644
--- a/src/ioq.c
+++ b/src/ioq.c
@@ -126,13 +126,14 @@
 #include "config.h"
 #include "diag.h"
 #include "dir.h"
-#include "sanity.h"
 #include "stat.h"
 #include "thread.h"
-#include <assert.h>
 #include <errno.h>
+#include <fcntl.h>
 #include <pthread.h>
+#include <stdint.h>
 #include <stdlib.h>
+#include <sys/stat.h>
 
 #if BFS_USE_LIBURING
 #  include <liburing.h>
diff --git a/src/main.c b/src/main.c
index 16a2576..e120f03 100644
--- a/src/main.c
+++ b/src/main.c
@@ -48,6 +48,7 @@
 #include "bfstd.h"
 #include "config.h"
 #include "ctx.h"
+#include "diag.h"
 #include "eval.h"
 #include "parse.h"
 #include <errno.h>
diff --git a/src/opt.c b/src/opt.c
index 74145ac..76965de 100644
--- a/src/opt.c
+++ b/src/opt.c
@@ -26,11 +26,13 @@
  */
 
 #include "opt.h"
+#include "bftw.h"
 #include "bit.h"
 #include "color.h"
 #include "config.h"
 #include "ctx.h"
 #include "diag.h"
+#include "dir.h"
 #include "eval.h"
 #include "exec.h"
 #include "expr.h"
@@ -40,7 +42,6 @@
 #include <limits.h>
 #include <stdarg.h>
 #include <stdio.h>
-#include <string.h>
 #include <unistd.h>
 
 static char *fake_and_arg = "-and";
diff --git a/src/parse.c b/src/parse.c
index b26a50f..3b7386d 100644
--- a/src/parse.c
+++ b/src/parse.c
@@ -42,8 +42,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
-#include <sys/time.h>
-#include <sys/wait.h>
+#include <sys/types.h>
 #include <time.h>
 #include <unistd.h>
 
diff --git a/src/printf.c b/src/printf.c
index 34ed606..487f039 100644
--- a/src/printf.c
+++ b/src/printf.c
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: 0BSD
 
 #include "printf.h"
+#include "alloc.h"
 #include "bfstd.h"
 #include "bftw.h"
 #include "color.h"
@@ -14,10 +15,10 @@
 #include "mtab.h"
 #include "pwcache.h"
 #include "stat.h"
-#include "xtime.h"
 #include <errno.h>
 #include <grp.h>
 #include <pwd.h>
+#include <stdarg.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
diff --git a/src/trie.c b/src/trie.c
index bd5300d..1ffb23a 100644
--- a/src/trie.c
+++ b/src/trie.c
@@ -87,9 +87,7 @@
 #include "config.h"
 #include "diag.h"
 #include "list.h"
-#include <limits.h>
 #include <stdint.h>
-#include <stdlib.h>
 #include <string.h>
 
 bfs_static_assert(CHAR_WIDTH == 8);
diff --git a/src/trie.h b/src/trie.h
index 02088f1..4288d76 100644
--- a/src/trie.h
+++ b/src/trie.h
@@ -5,7 +5,6 @@
 #define BFS_TRIE_H
 
 #include "alloc.h"
-#include "config.h"
 #include "list.h"
 #include <stddef.h>
 #include <stdint.h>
diff --git a/src/xspawn.c b/src/xspawn.c
index 8d6108b..6a94d3d 100644
--- a/src/xspawn.c
+++ b/src/xspawn.c
@@ -12,7 +12,6 @@
 #include <string.h>
 #include <sys/resource.h>
 #include <sys/types.h>
-#include <sys/wait.h>
 #include <unistd.h>
 
 #if BFS_USE_PATHS_H
diff --git a/src/xtime.c b/src/xtime.c
index 05f0e1a..5b259ab 100644
--- a/src/xtime.c
+++ b/src/xtime.c
@@ -7,7 +7,6 @@
 #include "diag.h"
 #include <errno.h>
 #include <limits.h>
-#include <stdlib.h>
 #include <sys/time.h>
 #include <time.h>
 #include <unistd.h>
diff --git a/tests/alloc.c b/tests/alloc.c
index 4ce23d4..9f08111 100644
--- a/tests/alloc.c
+++ b/tests/alloc.c
@@ -3,6 +3,7 @@
 
 #include "tests.h"
 #include "../src/alloc.h"
+#include "../src/config.h"
 #include "../src/diag.h"
 #include <errno.h>
 #include <stdlib.h>
diff --git a/tests/bfstd.c b/tests/bfstd.c
index 0ded5de..26abdb6 100644
--- a/tests/bfstd.c
+++ b/tests/bfstd.c
@@ -7,9 +7,6 @@
 #include "../src/diag.h"
 #include <errno.h>
 #include <langinfo.h>
-#include <locale.h>
-#include <stdint.h>
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
diff --git a/tests/bit.c b/tests/bit.c
index b944748..3d66ce3 100644
--- a/tests/bit.c
+++ b/tests/bit.c
@@ -3,10 +3,10 @@
 
 #include "tests.h"
 #include "../src/bit.h"
+#include "../src/config.h"
 #include "../src/diag.h"
 #include <limits.h>
 #include <stdint.h>
-#include <stdlib.h>
 
 bfs_static_assert(UMAX_WIDTH(0x1) == 1);
 bfs_static_assert(UMAX_WIDTH(0x3) == 2);
diff --git a/tests/ioq.c b/tests/ioq.c
index 56e1886..1ce8f75 100644
--- a/tests/ioq.c
+++ b/tests/ioq.c
@@ -4,10 +4,12 @@
 #include "tests.h"
 #include "../src/ioq.h"
 #include "../src/bfstd.h"
+#include "../src/config.h"
 #include "../src/diag.h"
 #include "../src/dir.h"
 #include <errno.h>
 #include <fcntl.h>
+#include <stdlib.h>
 
 /**
  * Test for blocking within ioq_slot_push().
diff --git a/tests/main.c b/tests/main.c
index 38438b2..8849e8c 100644
--- a/tests/main.c
+++ b/tests/main.c
@@ -6,11 +6,8 @@
  */
 
 #include "tests.h"
-#include "../src/bfstd.h"
 #include "../src/color.h"
 #include "../src/config.h"
-#include "../src/diag.h"
-#include <errno.h>
 #include <locale.h>
 #include <stdio.h>
 #include <stdlib.h>
diff --git a/tests/xtime.c b/tests/xtime.c
index 3f1fec2..c8dc00b 100644
--- a/tests/xtime.c
+++ b/tests/xtime.c
@@ -5,10 +5,10 @@
 #include "../src/xtime.h"
 #include "../src/bfstd.h"
 #include "../src/config.h"
+#include "../src/diag.h"
 #include <errno.h>
+#include <limits.h>
 #include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
 #include <time.h>
 
 static bool tm_equal(const struct tm *tma, const struct tm *tmb) {
diff --git a/tests/xtouch.c b/tests/xtouch.c
index 8c5c5f3..fad272f 100644
--- a/tests/xtouch.c
+++ b/tests/xtouch.c
@@ -11,6 +11,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
+#include <sys/types.h>
 #include <time.h>
 #include <unistd.h>
 
-- 
cgit v1.2.3


From 1501910dd0d09c50057c8358901663a87333bd8f Mon Sep 17 00:00:00 2001
From: Tavian Barnes <tavianator@tavianator.com>
Date: Thu, 18 Apr 2024 14:51:42 -0400
Subject: tests: Add ../src to the include path

---
 config/flags.mk |  1 +
 tests/alloc.c   |  6 +++---
 tests/bfstd.c   |  6 +++---
 tests/bit.c     |  6 +++---
 tests/ioq.c     | 10 +++++-----
 tests/main.c    |  6 +++---
 tests/mksock.c  |  2 +-
 tests/tests.h   |  4 ++--
 tests/trie.c    |  6 +++---
 tests/xspawn.c  | 10 +++++-----
 tests/xtime.c   |  8 ++++----
 tests/xtouch.c  |  8 ++++----
 12 files changed, 37 insertions(+), 36 deletions(-)

(limited to 'tests/alloc.c')

diff --git a/config/flags.mk b/config/flags.mk
index 1043779..d02cc8b 100644
--- a/config/flags.mk
+++ b/config/flags.mk
@@ -28,6 +28,7 @@ export XLDLIBS=${LDLIBS}
 
 # Immutable flags
 export BFS_CPPFLAGS= \
+    -Isrc \
     -D__EXTENSIONS__ \
     -D_ATFILE_SOURCE \
     -D_BSD_SOURCE \
diff --git a/tests/alloc.c b/tests/alloc.c
index 9f08111..54b84ba 100644
--- a/tests/alloc.c
+++ b/tests/alloc.c
@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: 0BSD
 
 #include "tests.h"
-#include "../src/alloc.h"
-#include "../src/config.h"
-#include "../src/diag.h"
+#include "alloc.h"
+#include "config.h"
+#include "diag.h"
 #include <errno.h>
 #include <stdlib.h>
 #include <stdint.h>
diff --git a/tests/bfstd.c b/tests/bfstd.c
index dc5ceaa..5e408ca 100644
--- a/tests/bfstd.c
+++ b/tests/bfstd.c
@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: 0BSD
 
 #include "tests.h"
-#include "../src/bfstd.h"
-#include "../src/config.h"
-#include "../src/diag.h"
+#include "bfstd.h"
+#include "config.h"
+#include "diag.h"
 #include <errno.h>
 #include <langinfo.h>
 #include <stdlib.h>
diff --git a/tests/bit.c b/tests/bit.c
index 6548c30..b444e50 100644
--- a/tests/bit.c
+++ b/tests/bit.c
@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: 0BSD
 
 #include "tests.h"
-#include "../src/bit.h"
-#include "../src/config.h"
-#include "../src/diag.h"
+#include "bit.h"
+#include "config.h"
+#include "diag.h"
 #include <limits.h>
 #include <stdint.h>
 #include <string.h>
diff --git a/tests/ioq.c b/tests/ioq.c
index 1ce8f75..a69f2bf 100644
--- a/tests/ioq.c
+++ b/tests/ioq.c
@@ -2,11 +2,11 @@
 // SPDX-License-Identifier: 0BSD
 
 #include "tests.h"
-#include "../src/ioq.h"
-#include "../src/bfstd.h"
-#include "../src/config.h"
-#include "../src/diag.h"
-#include "../src/dir.h"
+#include "ioq.h"
+#include "bfstd.h"
+#include "config.h"
+#include "diag.h"
+#include "dir.h"
 #include <errno.h>
 #include <fcntl.h>
 #include <stdlib.h>
diff --git a/tests/main.c b/tests/main.c
index 69903d4..281c417 100644
--- a/tests/main.c
+++ b/tests/main.c
@@ -6,9 +6,9 @@
  */
 
 #include "tests.h"
-#include "../src/bfstd.h"
-#include "../src/color.h"
-#include "../src/config.h"
+#include "bfstd.h"
+#include "color.h"
+#include "config.h"
 #include <errno.h>
 #include <locale.h>
 #include <stdio.h>
diff --git a/tests/mksock.c b/tests/mksock.c
index f3b61da..5786cb6 100644
--- a/tests/mksock.c
+++ b/tests/mksock.c
@@ -6,7 +6,7 @@
  * program does the job.
  */
 
-#include "../src/bfstd.h"
+#include "bfstd.h"
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
diff --git a/tests/tests.h b/tests/tests.h
index 351badb..d61ffd7 100644
--- a/tests/tests.h
+++ b/tests/tests.h
@@ -8,8 +8,8 @@
 #ifndef BFS_TESTS_H
 #define BFS_TESTS_H
 
-#include "../src/config.h"
-#include "../src/diag.h"
+#include "config.h"
+#include "diag.h"
 
 /** Unit test function type. */
 typedef bool test_fn(void);
diff --git a/tests/trie.c b/tests/trie.c
index fec0de2..2a6eb48 100644
--- a/tests/trie.c
+++ b/tests/trie.c
@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: 0BSD
 
 #include "tests.h"
-#include "../src/trie.h"
-#include "../src/config.h"
-#include "../src/diag.h"
+#include "trie.h"
+#include "config.h"
+#include "diag.h"
 #include <stdlib.h>
 #include <string.h>
 
diff --git a/tests/xspawn.c b/tests/xspawn.c
index c1bac36..fd8362e 100644
--- a/tests/xspawn.c
+++ b/tests/xspawn.c
@@ -2,11 +2,11 @@
 // SPDX-License-Identifier: 0BSD
 
 #include "tests.h"
-#include "../src/alloc.h"
-#include "../src/bfstd.h"
-#include "../src/config.h"
-#include "../src/dstring.h"
-#include "../src/xspawn.h"
+#include "alloc.h"
+#include "bfstd.h"
+#include "config.h"
+#include "dstring.h"
+#include "xspawn.h"
 #include <stdlib.h>
 #include <string.h>
 #include <sys/wait.h>
diff --git a/tests/xtime.c b/tests/xtime.c
index f85402e..fd7aa0f 100644
--- a/tests/xtime.c
+++ b/tests/xtime.c
@@ -2,10 +2,10 @@
 // SPDX-License-Identifier: 0BSD
 
 #include "tests.h"
-#include "../src/xtime.h"
-#include "../src/bfstd.h"
-#include "../src/config.h"
-#include "../src/diag.h"
+#include "xtime.h"
+#include "bfstd.h"
+#include "config.h"
+#include "diag.h"
 #include <errno.h>
 #include <limits.h>
 #include <stdint.h>
diff --git a/tests/xtouch.c b/tests/xtouch.c
index fad272f..b1daec7 100644
--- a/tests/xtouch.c
+++ b/tests/xtouch.c
@@ -1,10 +1,10 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
-#include "../src/bfstd.h"
-#include "../src/config.h"
-#include "../src/sanity.h"
-#include "../src/xtime.h"
+#include "bfstd.h"
+#include "config.h"
+#include "sanity.h"
+#include "xtime.h"
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
-- 
cgit v1.2.3


From c66379749f423413913b406609dfe9311ba6e555 Mon Sep 17 00:00:00 2001
From: Tavian Barnes <tavianator@tavianator.com>
Date: Thu, 18 Apr 2024 14:53:56 -0400
Subject: Rename config.h to prelude.h

---
 src/alloc.c    |   2 +-
 src/alloc.h    |   2 +-
 src/bar.c      |   2 +-
 src/bfstd.c    |   2 +-
 src/bfstd.h    |   2 +-
 src/bftw.c     |   2 +-
 src/bit.h      |   2 +-
 src/color.c    |   2 +-
 src/color.h    |   2 +-
 src/config.h   | 377 ---------------------------------------------------------
 src/ctx.h      |   2 +-
 src/diag.c     |   2 +-
 src/diag.h     |   2 +-
 src/dir.c      |   2 +-
 src/dstring.c  |   2 +-
 src/dstring.h  |   2 +-
 src/eval.c     |   2 +-
 src/eval.h     |   2 +-
 src/exec.c     |   2 +-
 src/expr.h     |   2 +-
 src/fsade.c    |   2 +-
 src/fsade.h    |   2 +-
 src/ioq.c      |   2 +-
 src/ioq.h      |   2 +-
 src/main.c     |   4 +-
 src/mtab.c     |   2 +-
 src/mtab.h     |   2 +-
 src/opt.c      |   2 +-
 src/parse.c    |   2 +-
 src/prelude.h  | 377 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/printf.c   |   2 +-
 src/pwcache.c  |   2 +-
 src/sanity.h   |   2 +-
 src/stat.c     |   2 +-
 src/stat.h     |   2 +-
 src/thread.c   |   2 +-
 src/thread.h   |   2 +-
 src/trie.c     |   2 +-
 src/xregex.c   |   2 +-
 src/xspawn.c   |   2 +-
 src/xspawn.h   |   2 +-
 src/xtime.c    |   2 +-
 tests/alloc.c  |   2 +-
 tests/bfstd.c  |   2 +-
 tests/bit.c    |   2 +-
 tests/ioq.c    |   2 +-
 tests/main.c   |   2 +-
 tests/tests.h  |   2 +-
 tests/trie.c   |   2 +-
 tests/xspawn.c |   2 +-
 tests/xtime.c  |   2 +-
 tests/xtouch.c |   2 +-
 52 files changed, 428 insertions(+), 428 deletions(-)
 delete mode 100644 src/config.h
 create mode 100644 src/prelude.h

(limited to 'tests/alloc.c')

diff --git a/src/alloc.c b/src/alloc.c
index b65d0c5..ec8608f 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -1,9 +1,9 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "alloc.h"
 #include "bit.h"
-#include "config.h"
 #include "diag.h"
 #include "sanity.h"
 #include <errno.h>
diff --git a/src/alloc.h b/src/alloc.h
index ae055bc..095134a 100644
--- a/src/alloc.h
+++ b/src/alloc.h
@@ -8,7 +8,7 @@
 #ifndef BFS_ALLOC_H
 #define BFS_ALLOC_H
 
-#include "config.h"
+#include "prelude.h"
 #include <errno.h>
 #include <stddef.h>
 #include <stdlib.h>
diff --git a/src/bar.c b/src/bar.c
index 8ab4112..184d9a0 100644
--- a/src/bar.c
+++ b/src/bar.c
@@ -1,11 +1,11 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "bar.h"
 #include "atomic.h"
 #include "bfstd.h"
 #include "bit.h"
-#include "config.h"
 #include "dstring.h"
 #include <errno.h>
 #include <fcntl.h>
diff --git a/src/bfstd.c b/src/bfstd.c
index 2499f00..e1b4804 100644
--- a/src/bfstd.c
+++ b/src/bfstd.c
@@ -1,9 +1,9 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "bfstd.h"
 #include "bit.h"
-#include "config.h"
 #include "diag.h"
 #include "sanity.h"
 #include "thread.h"
diff --git a/src/bfstd.h b/src/bfstd.h
index fc22971..42f5d5b 100644
--- a/src/bfstd.h
+++ b/src/bfstd.h
@@ -8,7 +8,7 @@
 #ifndef BFS_BFSTD_H
 #define BFS_BFSTD_H
 
-#include "config.h"
+#include "prelude.h"
 #include "sanity.h"
 #include <stddef.h>
 
diff --git a/src/bftw.c b/src/bftw.c
index 6130c44..c4d3c17 100644
--- a/src/bftw.c
+++ b/src/bftw.c
@@ -18,10 +18,10 @@
  *   various helper functions to take fewer parameters.
  */
 
+#include "prelude.h"
 #include "bftw.h"
 #include "alloc.h"
 #include "bfstd.h"
-#include "config.h"
 #include "diag.h"
 #include "dir.h"
 #include "dstring.h"
diff --git a/src/bit.h b/src/bit.h
index 69df21e..17cfbcf 100644
--- a/src/bit.h
+++ b/src/bit.h
@@ -8,7 +8,7 @@
 #ifndef BFS_BIT_H
 #define BFS_BIT_H
 
-#include "config.h"
+#include "prelude.h"
 #include <limits.h>
 #include <stdint.h>
 
diff --git a/src/color.c b/src/color.c
index 8c32a68..f004bf2 100644
--- a/src/color.c
+++ b/src/color.c
@@ -1,11 +1,11 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "color.h"
 #include "alloc.h"
 #include "bfstd.h"
 #include "bftw.h"
-#include "config.h"
 #include "diag.h"
 #include "dir.h"
 #include "dstring.h"
diff --git a/src/color.h b/src/color.h
index e3e7973..3278cd6 100644
--- a/src/color.h
+++ b/src/color.h
@@ -8,7 +8,7 @@
 #ifndef BFS_COLOR_H
 #define BFS_COLOR_H
 
-#include "config.h"
+#include "prelude.h"
 #include "dstring.h"
 #include <stdio.h>
 
diff --git a/src/config.h b/src/config.h
deleted file mode 100644
index 2eff1fc..0000000
--- a/src/config.h
+++ /dev/null
@@ -1,377 +0,0 @@
-// Copyright © Tavian Barnes <tavianator@tavianator.com>
-// SPDX-License-Identifier: 0BSD
-
-/**
- * Configuration and feature/platform detection.
- */
-
-#ifndef BFS_CONFIG_H
-#define BFS_CONFIG_H
-
-// Possible __STDC_VERSION__ values
-
-#define C95 199409L
-#define C99 199901L
-#define C11 201112L
-#define C17 201710L
-#define C23 202311L
-
-#include <stddef.h>
-
-#if __STDC_VERSION__ < C23
-#  include <stdalign.h>
-#  include <stdbool.h>
-#  include <stdnoreturn.h>
-#endif
-
-// bfs packaging configuration
-
-#ifndef BFS_COMMAND
-#  define BFS_COMMAND "bfs"
-#endif
-#ifndef BFS_HOMEPAGE
-#  define BFS_HOMEPAGE "https://tavianator.com/projects/bfs.html"
-#endif
-
-// This is a symbol instead of a literal so we don't have to rebuild everything
-// when the version number changes
-extern const char bfs_version[];
-
-// Check for system headers
-
-#ifdef __has_include
-
-#if __has_include(<mntent.h>)
-#  define BFS_HAS_MNTENT_H true
-#endif
-#if __has_include(<paths.h>)
-#  define BFS_HAS_PATHS_H true
-#endif
-#if __has_include(<sys/acl.h>)
-#  define BFS_HAS_SYS_ACL_H true
-#endif
-#if __has_include(<sys/capability.h>)
-#  define BFS_HAS_SYS_CAPABILITY_H true
-#endif
-#if __has_include(<sys/extattr.h>)
-#  define BFS_HAS_SYS_EXTATTR_H true
-#endif
-#if __has_include(<sys/mkdev.h>)
-#  define BFS_HAS_SYS_MKDEV_H true
-#endif
-#if __has_include(<sys/param.h>)
-#  define BFS_HAS_SYS_PARAM_H true
-#endif
-#if __has_include(<sys/sysmacros.h>)
-#  define BFS_HAS_SYS_SYSMACROS_H true
-#endif
-#if __has_include(<sys/xattr.h>)
-#  define BFS_HAS_SYS_XATTR_H true
-#endif
-#if __has_include(<threads.h>)
-#  define BFS_HAS_THREADS_H true
-#endif
-#if __has_include(<util.h>)
-#  define BFS_HAS_UTIL_H true
-#endif
-
-#else // !__has_include
-
-#define BFS_HAS_MNTENT_H __GLIBC__
-#define BFS_HAS_PATHS_H true
-#define BFS_HAS_SYS_ACL_H true
-#define BFS_HAS_SYS_CAPABILITY_H __linux__
-#define BFS_HAS_SYS_EXTATTR_H __FreeBSD__
-#define BFS_HAS_SYS_MKDEV_H false
-#define BFS_HAS_SYS_PARAM_H true
-#define BFS_HAS_SYS_SYSMACROS_H __GLIBC__
-#define BFS_HAS_SYS_XATTR_H __linux__
-#define BFS_HAS_THREADS_H (!__STDC_NO_THREADS__)
-#define BFS_HAS_UTIL_H __NetBSD__
-
-#endif // !__has_include
-
-#ifndef BFS_USE_MNTENT_H
-#  define BFS_USE_MNTENT_H BFS_HAS_MNTENT_H
-#endif
-#ifndef BFS_USE_PATHS_H
-#  define BFS_USE_PATHS_H BFS_HAS_PATHS_H
-#endif
-#ifndef BFS_USE_SYS_ACL_H
-#  define BFS_USE_SYS_ACL_H (BFS_HAS_SYS_ACL_H && !__illumos__ && (!__linux__ || BFS_USE_LIBACL))
-#endif
-#ifndef BFS_USE_SYS_CAPABILITY_H
-#  define BFS_USE_SYS_CAPABILITY_H (BFS_HAS_SYS_CAPABILITY_H && !__FreeBSD__ && (!__linux__ || BFS_USE_LIBCAP))
-#endif
-#ifndef BFS_USE_SYS_EXTATTR_H
-#  define BFS_USE_SYS_EXTATTR_H (BFS_HAS_SYS_EXTATTR_H && !__DragonFly__)
-#endif
-#ifndef BFS_USE_SYS_MKDEV_H
-#  define BFS_USE_SYS_MKDEV_H BFS_HAS_SYS_MKDEV_H
-#endif
-#ifndef BFS_USE_SYS_PARAM_H
-#  define BFS_USE_SYS_PARAM_H BFS_HAS_SYS_PARAM_H
-#endif
-#ifndef BFS_USE_SYS_SYSMACROS_H
-#  define BFS_USE_SYS_SYSMACROS_H BFS_HAS_SYS_SYSMACROS_H
-#endif
-#ifndef BFS_USE_SYS_XATTR_H
-#  define BFS_USE_SYS_XATTR_H BFS_HAS_SYS_XATTR_H
-#endif
-#ifndef BFS_USE_THREADS_H
-#  define BFS_USE_THREADS_H BFS_HAS_THREADS_H
-#endif
-#ifndef BFS_USE_UTIL_H
-#  define BFS_USE_UTIL_H BFS_HAS_UTIL_H
-#endif
-
-// Stub out feature detection on old/incompatible compilers
-
-#ifndef __has_feature
-#  define __has_feature(feat) false
-#endif
-
-#ifndef __has_c_attribute
-#  define __has_c_attribute(attr) false
-#endif
-
-#ifndef __has_attribute
-#  define __has_attribute(attr) false
-#endif
-
-// Platform detection
-
-// Get the definition of BSD if available
-#if BFS_USE_SYS_PARAM_H
-#  include <sys/param.h>
-#endif
-
-#ifndef __GLIBC_PREREQ
-#  define __GLIBC_PREREQ(maj, min) false
-#endif
-
-#ifndef __NetBSD_Prereq__
-#  define __NetBSD_Prereq__(maj, min, patch) false
-#endif
-
-// Fundamental utilities
-
-/**
- * Get the length of an array.
- */
-#define countof(array) (sizeof(array) / sizeof(0[array]))
-
-/**
- * False sharing/destructive interference/largest cache line size.
- */
-#ifdef __GCC_DESTRUCTIVE_SIZE
-#  define FALSE_SHARING_SIZE __GCC_DESTRUCTIVE_SIZE
-#else
-#  define FALSE_SHARING_SIZE 64
-#endif
-
-/**
- * True sharing/constructive interference/smallest cache line size.
- */
-#ifdef __GCC_CONSTRUCTIVE_SIZE
-#  define TRUE_SHARING_SIZE __GCC_CONSTRUCTIVE_SIZE
-#else
-#  define TRUE_SHARING_SIZE 64
-#endif
-
-/**
- * Alignment specifier that avoids false sharing.
- */
-#define cache_align alignas(FALSE_SHARING_SIZE)
-
-#if __COSMOPOLITAN__
-typedef long double max_align_t;
-#endif
-
-// Wrappers for attributes
-
-/**
- * Silence warnings about switch/case fall-throughs.
- */
-#if __has_attribute(fallthrough)
-#  define fallthru __attribute__((fallthrough))
-#else
-#  define fallthru ((void)0)
-#endif
-
-/**
- * Silence warnings about unused declarations.
- */
-#if __has_attribute(unused)
-#  define attr_maybe_unused __attribute__((unused))
-#else
-#  define attr_maybe_unused
-#endif
-
-/**
- * Warn if a value is unused.
- */
-#if __has_attribute(warn_unused_result)
-#  define attr_nodiscard __attribute__((warn_unused_result))
-#else
-#  define attr_nodiscard
-#endif
-
-/**
- * Hint to avoid inlining a function.
- */
-#if __has_attribute(noinline)
-#  define attr_noinline __attribute__((noinline))
-#else
-#  define attr_noinline
-#endif
-
-/**
- * Hint that a function is unlikely to be called.
- */
-#if __has_attribute(cold)
-#  define attr_cold attr_noinline __attribute__((cold))
-#else
-#  define attr_cold attr_noinline
-#endif
-
-/**
- * Adds compiler warnings for bad printf()-style function calls, if supported.
- */
-#if __has_attribute(format)
-#  define attr_printf(fmt, args) __attribute__((format(printf, fmt, args)))
-#else
-#  define attr_printf(fmt, args)
-#endif
-
-/**
- * Annotates allocator-like functions.
- */
-#if __has_attribute(malloc)
-#  if __GNUC__ >= 11 && !__OPTIMIZE__ // malloc(deallocator) disables inlining on GCC
-#    define attr_malloc(...) attr_nodiscard __attribute__((malloc(__VA_ARGS__)))
-#  else
-#    define attr_malloc(...) attr_nodiscard __attribute__((malloc))
-#  endif
-#else
-#  define attr_malloc(...) attr_nodiscard
-#endif
-
-/**
- * Specifies that a function returns allocations with a given alignment.
- */
-#if __has_attribute(alloc_align)
-#  define attr_alloc_align(param) __attribute__((alloc_align(param)))
-#else
-#  define attr_alloc_align(param)
-#endif
-
-/**
- * Specifies that a function returns allocations with a given size.
- */
-#if __has_attribute(alloc_size)
-#  define attr_alloc_size(...) __attribute__((alloc_size(__VA_ARGS__)))
-#else
-#  define attr_alloc_size(...)
-#endif
-
-/**
- * Shorthand for attr_alloc_align() and attr_alloc_size().
- */
-#define attr_aligned_alloc(align, ...) \
-	attr_alloc_align(align) \
-	attr_alloc_size(__VA_ARGS__)
-
-/**
- * Check if function multiversioning via GNU indirect functions (ifunc) is supported.
- */
-#ifndef BFS_USE_TARGET_CLONES
-#  if __has_attribute(target_clones) && (__GLIBC__ || __FreeBSD__)
-#    define BFS_USE_TARGET_CLONES true
-#  endif
-#endif
-
-/**
- * Apply the target_clones attribute, if available.
- */
-#if BFS_USE_TARGET_CLONES
-#  define attr_target_clones(...) __attribute__((target_clones(__VA_ARGS__)))
-#else
-#  define attr_target_clones(...)
-#endif
-
-/**
- * Shorthand for multiple attributes at once. attr(a, b(c), d) is equivalent to
- *
- *     attr_a
- *     attr_b(c)
- *     attr_d
- */
-#define attr(...) \
-	attr__(attr_##__VA_ARGS__, none, none, none, none, none, none, none, none, none, )
-
-/**
- * attr() helper.  For exposition, pretend we support only 2 args, instead of 9.
- * There are a few cases:
- *
- *     attr()
- *         => attr__(attr_, none, none)
- *         => attr_                =>
- *            attr_none            =>
- *            attr_too_many_none() =>
- *
- *     attr(a)
- *         => attr__(attr_a, none, none)
- *         => attr_a               => __attribute__((a))
- *            attr_none            =>
- *            attr_too_many_none() =>
- *
- *     attr(a, b(c))
- *         => attr__(attr_a, b(c), none, none)
- *         => attr_a                   => __attribute__((a))
- *            attr_b(c)                => __attribute__((b(c)))
- *            attr_too_many_none(none) =>
- *
- *     attr(a, b(c), d)
- *         => attr__(attr_a, b(c), d, none, none)
- *         => attr_a                      => __attribute__((a))
- *            attr_b(c)                   => __attribute__((b(c)))
- *            attr_too_many_d(none, none) => error
- *
- * Some attribute names are the same as standard library functions, e.g. printf.
- * Standard libraries are permitted to define these functions as macros, like
- *
- *     #define printf(...) __builtin_printf(__VA_ARGS__)
- *
- * The token paste in
- *
- *     #define attr(...) attr__(attr_##__VA_ARGS__, none, none)
- *
- * is necessary to prevent macro expansion before evaluating attr__().
- * Otherwise, we could get
- *
- *     attr(printf(1, 2))
- *         => attr__(__builtin_printf(1, 2), none, none)
- *         => attr____builtin_printf(1, 2)
- *         => error
- */
-#define attr__(a1, a2, a3, a4, a5, a6, a7, a8, a9, none, ...) \
-	a1 \
-	attr_##a2 \
-	attr_##a3 \
-	attr_##a4 \
-	attr_##a5 \
-	attr_##a6 \
-	attr_##a7 \
-	attr_##a8 \
-	attr_##a9 \
-	attr_too_many_##none(__VA_ARGS__)
-
-// Ignore `attr_none` from expanding 1-9 argument attr(a1, a2, ...)
-#define attr_none
-// Ignore `attr_` from expanding 0-argument attr()
-#define attr_
-// Only trigger an error on more than 9 arguments
-#define attr_too_many_none(...)
-
-#endif // BFS_CONFIG_H
diff --git a/src/ctx.h b/src/ctx.h
index e14db21..fc3020c 100644
--- a/src/ctx.h
+++ b/src/ctx.h
@@ -8,9 +8,9 @@
 #ifndef BFS_CTX_H
 #define BFS_CTX_H
 
+#include "prelude.h"
 #include "alloc.h"
 #include "bftw.h"
-#include "config.h"
 #include "diag.h"
 #include "expr.h"
 #include "trie.h"
diff --git a/src/diag.c b/src/diag.c
index cb27b92..deb6f26 100644
--- a/src/diag.c
+++ b/src/diag.c
@@ -1,11 +1,11 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "diag.h"
 #include "alloc.h"
 #include "bfstd.h"
 #include "color.h"
-#include "config.h"
 #include "ctx.h"
 #include "dstring.h"
 #include "expr.h"
diff --git a/src/diag.h b/src/diag.h
index 4054c48..2b13609 100644
--- a/src/diag.h
+++ b/src/diag.h
@@ -8,7 +8,7 @@
 #ifndef BFS_DIAG_H
 #define BFS_DIAG_H
 
-#include "config.h"
+#include "prelude.h"
 #include <stdarg.h>
 
 /**
diff --git a/src/dir.c b/src/dir.c
index 98518f2..53c9be3 100644
--- a/src/dir.c
+++ b/src/dir.c
@@ -1,10 +1,10 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "dir.h"
 #include "alloc.h"
 #include "bfstd.h"
-#include "config.h"
 #include "diag.h"
 #include "sanity.h"
 #include "trie.h"
diff --git a/src/dstring.c b/src/dstring.c
index 10b0fad..913dda8 100644
--- a/src/dstring.c
+++ b/src/dstring.c
@@ -1,10 +1,10 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "dstring.h"
 #include "alloc.h"
 #include "bit.h"
-#include "config.h"
 #include "diag.h"
 #include <stdarg.h>
 #include <stddef.h>
diff --git a/src/dstring.h b/src/dstring.h
index 6006199..9ea7eb9 100644
--- a/src/dstring.h
+++ b/src/dstring.h
@@ -8,8 +8,8 @@
 #ifndef BFS_DSTRING_H
 #define BFS_DSTRING_H
 
+#include "prelude.h"
 #include "bfstd.h"
-#include "config.h"
 #include <stdarg.h>
 #include <stddef.h>
 
diff --git a/src/eval.c b/src/eval.c
index d0112c2..b103912 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -5,12 +5,12 @@
  * Implementation of all the primary expressions.
  */
 
+#include "prelude.h"
 #include "eval.h"
 #include "bar.h"
 #include "bfstd.h"
 #include "bftw.h"
 #include "color.h"
-#include "config.h"
 #include "ctx.h"
 #include "diag.h"
 #include "dir.h"
diff --git a/src/eval.h b/src/eval.h
index ae43628..4dd7996 100644
--- a/src/eval.h
+++ b/src/eval.h
@@ -9,7 +9,7 @@
 #ifndef BFS_EVAL_H
 #define BFS_EVAL_H
 
-#include "config.h"
+#include "prelude.h"
 
 struct bfs_ctx;
 struct bfs_expr;
diff --git a/src/exec.c b/src/exec.c
index 60bfd28..e782d49 100644
--- a/src/exec.c
+++ b/src/exec.c
@@ -1,12 +1,12 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "exec.h"
 #include "alloc.h"
 #include "bfstd.h"
 #include "bftw.h"
 #include "color.h"
-#include "config.h"
 #include "ctx.h"
 #include "diag.h"
 #include "dstring.h"
diff --git a/src/expr.h b/src/expr.h
index 75cb5fd..7bcace7 100644
--- a/src/expr.h
+++ b/src/expr.h
@@ -8,8 +8,8 @@
 #ifndef BFS_EXPR_H
 #define BFS_EXPR_H
 
+#include "prelude.h"
 #include "color.h"
-#include "config.h"
 #include "eval.h"
 #include "stat.h"
 #include <sys/types.h>
diff --git a/src/fsade.c b/src/fsade.c
index 0810c7f..34a4d57 100644
--- a/src/fsade.c
+++ b/src/fsade.c
@@ -1,11 +1,11 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "fsade.h"
 #include "atomic.h"
 #include "bfstd.h"
 #include "bftw.h"
-#include "config.h"
 #include "dir.h"
 #include "dstring.h"
 #include "sanity.h"
diff --git a/src/fsade.h b/src/fsade.h
index 1f1dbfc..6300852 100644
--- a/src/fsade.h
+++ b/src/fsade.h
@@ -9,7 +9,7 @@
 #ifndef BFS_FSADE_H
 #define BFS_FSADE_H
 
-#include "config.h"
+#include "prelude.h"
 
 #define BFS_CAN_CHECK_ACL BFS_USE_SYS_ACL_H
 
diff --git a/src/ioq.c b/src/ioq.c
index b936681..189bdac 100644
--- a/src/ioq.c
+++ b/src/ioq.c
@@ -118,12 +118,12 @@
  * [1]: https://arxiv.org/abs/2201.02179
  */
 
+#include "prelude.h"
 #include "ioq.h"
 #include "alloc.h"
 #include "atomic.h"
 #include "bfstd.h"
 #include "bit.h"
-#include "config.h"
 #include "diag.h"
 #include "dir.h"
 #include "stat.h"
diff --git a/src/ioq.h b/src/ioq.h
index 818eea6..d8e1573 100644
--- a/src/ioq.h
+++ b/src/ioq.h
@@ -8,7 +8,7 @@
 #ifndef BFS_IOQ_H
 #define BFS_IOQ_H
 
-#include "config.h"
+#include "prelude.h"
 #include "dir.h"
 #include "stat.h"
 #include <stddef.h>
diff --git a/src/main.c b/src/main.c
index e120f03..9d8b206 100644
--- a/src/main.c
+++ b/src/main.c
@@ -26,7 +26,7 @@
  *     - bit.h         (bit manipulation)
  *     - bfstd.[ch]    (standard library wrappers/polyfills)
  *     - color.[ch]    (for pretty terminal colors)
- *     - config.h      (configuration and feature/platform detection)
+ *     - prelude.h     (configuration and feature/platform detection)
  *     - diag.[ch]     (formats diagnostic messages)
  *     - dir.[ch]      (a directory API facade)
  *     - dstring.[ch]  (a dynamic string library)
@@ -45,8 +45,8 @@
  *     - xtime.[ch]    (date/time handling utilities)
  */
 
+#include "prelude.h"
 #include "bfstd.h"
-#include "config.h"
 #include "ctx.h"
 #include "diag.h"
 #include "eval.h"
diff --git a/src/mtab.c b/src/mtab.c
index 86ae151..7905d14 100644
--- a/src/mtab.c
+++ b/src/mtab.c
@@ -1,10 +1,10 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "mtab.h"
 #include "alloc.h"
 #include "bfstd.h"
-#include "config.h"
 #include "stat.h"
 #include "trie.h"
 #include <errno.h>
diff --git a/src/mtab.h b/src/mtab.h
index d99d78f..67290c2 100644
--- a/src/mtab.h
+++ b/src/mtab.h
@@ -8,7 +8,7 @@
 #ifndef BFS_MTAB_H
 #define BFS_MTAB_H
 
-#include "config.h"
+#include "prelude.h"
 
 struct bfs_stat;
 
diff --git a/src/opt.c b/src/opt.c
index b74b4e1..ffc795b 100644
--- a/src/opt.c
+++ b/src/opt.c
@@ -25,11 +25,11 @@
  * effects are reachable at all, skipping the traversal if not.
  */
 
+#include "prelude.h"
 #include "opt.h"
 #include "bftw.h"
 #include "bit.h"
 #include "color.h"
-#include "config.h"
 #include "ctx.h"
 #include "diag.h"
 #include "dir.h"
diff --git a/src/parse.c b/src/parse.c
index a3e32fe..c2ae58f 100644
--- a/src/parse.c
+++ b/src/parse.c
@@ -8,12 +8,12 @@
  * flags like always-true options, and skipping over paths wherever they appear.
  */
 
+#include "prelude.h"
 #include "parse.h"
 #include "alloc.h"
 #include "bfstd.h"
 #include "bftw.h"
 #include "color.h"
-#include "config.h"
 #include "ctx.h"
 #include "diag.h"
 #include "dir.h"
diff --git a/src/prelude.h b/src/prelude.h
new file mode 100644
index 0000000..c3a0752
--- /dev/null
+++ b/src/prelude.h
@@ -0,0 +1,377 @@
+// Copyright © Tavian Barnes <tavianator@tavianator.com>
+// SPDX-License-Identifier: 0BSD
+
+/**
+ * Configuration and feature/platform detection.
+ */
+
+#ifndef BFS_PRELUDE_H
+#define BFS_PRELUDE_H
+
+// Possible __STDC_VERSION__ values
+
+#define C95 199409L
+#define C99 199901L
+#define C11 201112L
+#define C17 201710L
+#define C23 202311L
+
+#include <stddef.h>
+
+#if __STDC_VERSION__ < C23
+#  include <stdalign.h>
+#  include <stdbool.h>
+#  include <stdnoreturn.h>
+#endif
+
+// bfs packaging configuration
+
+#ifndef BFS_COMMAND
+#  define BFS_COMMAND "bfs"
+#endif
+#ifndef BFS_HOMEPAGE
+#  define BFS_HOMEPAGE "https://tavianator.com/projects/bfs.html"
+#endif
+
+// This is a symbol instead of a literal so we don't have to rebuild everything
+// when the version number changes
+extern const char bfs_version[];
+
+// Check for system headers
+
+#ifdef __has_include
+
+#if __has_include(<mntent.h>)
+#  define BFS_HAS_MNTENT_H true
+#endif
+#if __has_include(<paths.h>)
+#  define BFS_HAS_PATHS_H true
+#endif
+#if __has_include(<sys/acl.h>)
+#  define BFS_HAS_SYS_ACL_H true
+#endif
+#if __has_include(<sys/capability.h>)
+#  define BFS_HAS_SYS_CAPABILITY_H true
+#endif
+#if __has_include(<sys/extattr.h>)
+#  define BFS_HAS_SYS_EXTATTR_H true
+#endif
+#if __has_include(<sys/mkdev.h>)
+#  define BFS_HAS_SYS_MKDEV_H true
+#endif
+#if __has_include(<sys/param.h>)
+#  define BFS_HAS_SYS_PARAM_H true
+#endif
+#if __has_include(<sys/sysmacros.h>)
+#  define BFS_HAS_SYS_SYSMACROS_H true
+#endif
+#if __has_include(<sys/xattr.h>)
+#  define BFS_HAS_SYS_XATTR_H true
+#endif
+#if __has_include(<threads.h>)
+#  define BFS_HAS_THREADS_H true
+#endif
+#if __has_include(<util.h>)
+#  define BFS_HAS_UTIL_H true
+#endif
+
+#else // !__has_include
+
+#define BFS_HAS_MNTENT_H __GLIBC__
+#define BFS_HAS_PATHS_H true
+#define BFS_HAS_SYS_ACL_H true
+#define BFS_HAS_SYS_CAPABILITY_H __linux__
+#define BFS_HAS_SYS_EXTATTR_H __FreeBSD__
+#define BFS_HAS_SYS_MKDEV_H false
+#define BFS_HAS_SYS_PARAM_H true
+#define BFS_HAS_SYS_SYSMACROS_H __GLIBC__
+#define BFS_HAS_SYS_XATTR_H __linux__
+#define BFS_HAS_THREADS_H (!__STDC_NO_THREADS__)
+#define BFS_HAS_UTIL_H __NetBSD__
+
+#endif // !__has_include
+
+#ifndef BFS_USE_MNTENT_H
+#  define BFS_USE_MNTENT_H BFS_HAS_MNTENT_H
+#endif
+#ifndef BFS_USE_PATHS_H
+#  define BFS_USE_PATHS_H BFS_HAS_PATHS_H
+#endif
+#ifndef BFS_USE_SYS_ACL_H
+#  define BFS_USE_SYS_ACL_H (BFS_HAS_SYS_ACL_H && !__illumos__ && (!__linux__ || BFS_USE_LIBACL))
+#endif
+#ifndef BFS_USE_SYS_CAPABILITY_H
+#  define BFS_USE_SYS_CAPABILITY_H (BFS_HAS_SYS_CAPABILITY_H && !__FreeBSD__ && (!__linux__ || BFS_USE_LIBCAP))
+#endif
+#ifndef BFS_USE_SYS_EXTATTR_H
+#  define BFS_USE_SYS_EXTATTR_H (BFS_HAS_SYS_EXTATTR_H && !__DragonFly__)
+#endif
+#ifndef BFS_USE_SYS_MKDEV_H
+#  define BFS_USE_SYS_MKDEV_H BFS_HAS_SYS_MKDEV_H
+#endif
+#ifndef BFS_USE_SYS_PARAM_H
+#  define BFS_USE_SYS_PARAM_H BFS_HAS_SYS_PARAM_H
+#endif
+#ifndef BFS_USE_SYS_SYSMACROS_H
+#  define BFS_USE_SYS_SYSMACROS_H BFS_HAS_SYS_SYSMACROS_H
+#endif
+#ifndef BFS_USE_SYS_XATTR_H
+#  define BFS_USE_SYS_XATTR_H BFS_HAS_SYS_XATTR_H
+#endif
+#ifndef BFS_USE_THREADS_H
+#  define BFS_USE_THREADS_H BFS_HAS_THREADS_H
+#endif
+#ifndef BFS_USE_UTIL_H
+#  define BFS_USE_UTIL_H BFS_HAS_UTIL_H
+#endif
+
+// Stub out feature detection on old/incompatible compilers
+
+#ifndef __has_feature
+#  define __has_feature(feat) false
+#endif
+
+#ifndef __has_c_attribute
+#  define __has_c_attribute(attr) false
+#endif
+
+#ifndef __has_attribute
+#  define __has_attribute(attr) false
+#endif
+
+// Platform detection
+
+// Get the definition of BSD if available
+#if BFS_USE_SYS_PARAM_H
+#  include <sys/param.h>
+#endif
+
+#ifndef __GLIBC_PREREQ
+#  define __GLIBC_PREREQ(maj, min) false
+#endif
+
+#ifndef __NetBSD_Prereq__
+#  define __NetBSD_Prereq__(maj, min, patch) false
+#endif
+
+// Fundamental utilities
+
+/**
+ * Get the length of an array.
+ */
+#define countof(array) (sizeof(array) / sizeof(0[array]))
+
+/**
+ * False sharing/destructive interference/largest cache line size.
+ */
+#ifdef __GCC_DESTRUCTIVE_SIZE
+#  define FALSE_SHARING_SIZE __GCC_DESTRUCTIVE_SIZE
+#else
+#  define FALSE_SHARING_SIZE 64
+#endif
+
+/**
+ * True sharing/constructive interference/smallest cache line size.
+ */
+#ifdef __GCC_CONSTRUCTIVE_SIZE
+#  define TRUE_SHARING_SIZE __GCC_CONSTRUCTIVE_SIZE
+#else
+#  define TRUE_SHARING_SIZE 64
+#endif
+
+/**
+ * Alignment specifier that avoids false sharing.
+ */
+#define cache_align alignas(FALSE_SHARING_SIZE)
+
+#if __COSMOPOLITAN__
+typedef long double max_align_t;
+#endif
+
+// Wrappers for attributes
+
+/**
+ * Silence warnings about switch/case fall-throughs.
+ */
+#if __has_attribute(fallthrough)
+#  define fallthru __attribute__((fallthrough))
+#else
+#  define fallthru ((void)0)
+#endif
+
+/**
+ * Silence warnings about unused declarations.
+ */
+#if __has_attribute(unused)
+#  define attr_maybe_unused __attribute__((unused))
+#else
+#  define attr_maybe_unused
+#endif
+
+/**
+ * Warn if a value is unused.
+ */
+#if __has_attribute(warn_unused_result)
+#  define attr_nodiscard __attribute__((warn_unused_result))
+#else
+#  define attr_nodiscard
+#endif
+
+/**
+ * Hint to avoid inlining a function.
+ */
+#if __has_attribute(noinline)
+#  define attr_noinline __attribute__((noinline))
+#else
+#  define attr_noinline
+#endif
+
+/**
+ * Hint that a function is unlikely to be called.
+ */
+#if __has_attribute(cold)
+#  define attr_cold attr_noinline __attribute__((cold))
+#else
+#  define attr_cold attr_noinline
+#endif
+
+/**
+ * Adds compiler warnings for bad printf()-style function calls, if supported.
+ */
+#if __has_attribute(format)
+#  define attr_printf(fmt, args) __attribute__((format(printf, fmt, args)))
+#else
+#  define attr_printf(fmt, args)
+#endif
+
+/**
+ * Annotates allocator-like functions.
+ */
+#if __has_attribute(malloc)
+#  if __GNUC__ >= 11 && !__OPTIMIZE__ // malloc(deallocator) disables inlining on GCC
+#    define attr_malloc(...) attr_nodiscard __attribute__((malloc(__VA_ARGS__)))
+#  else
+#    define attr_malloc(...) attr_nodiscard __attribute__((malloc))
+#  endif
+#else
+#  define attr_malloc(...) attr_nodiscard
+#endif
+
+/**
+ * Specifies that a function returns allocations with a given alignment.
+ */
+#if __has_attribute(alloc_align)
+#  define attr_alloc_align(param) __attribute__((alloc_align(param)))
+#else
+#  define attr_alloc_align(param)
+#endif
+
+/**
+ * Specifies that a function returns allocations with a given size.
+ */
+#if __has_attribute(alloc_size)
+#  define attr_alloc_size(...) __attribute__((alloc_size(__VA_ARGS__)))
+#else
+#  define attr_alloc_size(...)
+#endif
+
+/**
+ * Shorthand for attr_alloc_align() and attr_alloc_size().
+ */
+#define attr_aligned_alloc(align, ...) \
+	attr_alloc_align(align) \
+	attr_alloc_size(__VA_ARGS__)
+
+/**
+ * Check if function multiversioning via GNU indirect functions (ifunc) is supported.
+ */
+#ifndef BFS_USE_TARGET_CLONES
+#  if __has_attribute(target_clones) && (__GLIBC__ || __FreeBSD__)
+#    define BFS_USE_TARGET_CLONES true
+#  endif
+#endif
+
+/**
+ * Apply the target_clones attribute, if available.
+ */
+#if BFS_USE_TARGET_CLONES
+#  define attr_target_clones(...) __attribute__((target_clones(__VA_ARGS__)))
+#else
+#  define attr_target_clones(...)
+#endif
+
+/**
+ * Shorthand for multiple attributes at once. attr(a, b(c), d) is equivalent to
+ *
+ *     attr_a
+ *     attr_b(c)
+ *     attr_d
+ */
+#define attr(...) \
+	attr__(attr_##__VA_ARGS__, none, none, none, none, none, none, none, none, none, )
+
+/**
+ * attr() helper.  For exposition, pretend we support only 2 args, instead of 9.
+ * There are a few cases:
+ *
+ *     attr()
+ *         => attr__(attr_, none, none)
+ *         => attr_                =>
+ *            attr_none            =>
+ *            attr_too_many_none() =>
+ *
+ *     attr(a)
+ *         => attr__(attr_a, none, none)
+ *         => attr_a               => __attribute__((a))
+ *            attr_none            =>
+ *            attr_too_many_none() =>
+ *
+ *     attr(a, b(c))
+ *         => attr__(attr_a, b(c), none, none)
+ *         => attr_a                   => __attribute__((a))
+ *            attr_b(c)                => __attribute__((b(c)))
+ *            attr_too_many_none(none) =>
+ *
+ *     attr(a, b(c), d)
+ *         => attr__(attr_a, b(c), d, none, none)
+ *         => attr_a                      => __attribute__((a))
+ *            attr_b(c)                   => __attribute__((b(c)))
+ *            attr_too_many_d(none, none) => error
+ *
+ * Some attribute names are the same as standard library functions, e.g. printf.
+ * Standard libraries are permitted to define these functions as macros, like
+ *
+ *     #define printf(...) __builtin_printf(__VA_ARGS__)
+ *
+ * The token paste in
+ *
+ *     #define attr(...) attr__(attr_##__VA_ARGS__, none, none)
+ *
+ * is necessary to prevent macro expansion before evaluating attr__().
+ * Otherwise, we could get
+ *
+ *     attr(printf(1, 2))
+ *         => attr__(__builtin_printf(1, 2), none, none)
+ *         => attr____builtin_printf(1, 2)
+ *         => error
+ */
+#define attr__(a1, a2, a3, a4, a5, a6, a7, a8, a9, none, ...) \
+	a1 \
+	attr_##a2 \
+	attr_##a3 \
+	attr_##a4 \
+	attr_##a5 \
+	attr_##a6 \
+	attr_##a7 \
+	attr_##a8 \
+	attr_##a9 \
+	attr_too_many_##none(__VA_ARGS__)
+
+// Ignore `attr_none` from expanding 1-9 argument attr(a1, a2, ...)
+#define attr_none
+// Ignore `attr_` from expanding 0-argument attr()
+#define attr_
+// Only trigger an error on more than 9 arguments
+#define attr_too_many_none(...)
+
+#endif // BFS_PRELUDE_H
diff --git a/src/printf.c b/src/printf.c
index 3b8269e..4df399b 100644
--- a/src/printf.c
+++ b/src/printf.c
@@ -1,12 +1,12 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "printf.h"
 #include "alloc.h"
 #include "bfstd.h"
 #include "bftw.h"
 #include "color.h"
-#include "config.h"
 #include "ctx.h"
 #include "diag.h"
 #include "dir.h"
diff --git a/src/pwcache.c b/src/pwcache.c
index 79437d8..af8c237 100644
--- a/src/pwcache.c
+++ b/src/pwcache.c
@@ -1,9 +1,9 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "pwcache.h"
 #include "alloc.h"
-#include "config.h"
 #include "trie.h"
 #include <errno.h>
 #include <grp.h>
diff --git a/src/sanity.h b/src/sanity.h
index 423e6ff..e168b8f 100644
--- a/src/sanity.h
+++ b/src/sanity.h
@@ -8,7 +8,7 @@
 #ifndef BFS_SANITY_H
 #define BFS_SANITY_H
 
-#include "config.h"
+#include "prelude.h"
 #include <stddef.h>
 
 #if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
diff --git a/src/stat.c b/src/stat.c
index 2f2743b..eca5bab 100644
--- a/src/stat.c
+++ b/src/stat.c
@@ -1,10 +1,10 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "stat.h"
 #include "atomic.h"
 #include "bfstd.h"
-#include "config.h"
 #include "diag.h"
 #include "sanity.h"
 #include <errno.h>
diff --git a/src/stat.h b/src/stat.h
index 856a2ca..1fdd263 100644
--- a/src/stat.h
+++ b/src/stat.h
@@ -12,7 +12,7 @@
 #ifndef BFS_STAT_H
 #define BFS_STAT_H
 
-#include "config.h"
+#include "prelude.h"
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <time.h>
diff --git a/src/thread.c b/src/thread.c
index 200d8c3..3793896 100644
--- a/src/thread.c
+++ b/src/thread.c
@@ -1,9 +1,9 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "thread.h"
 #include "bfstd.h"
-#include "config.h"
 #include "diag.h"
 #include <errno.h>
 #include <pthread.h>
diff --git a/src/thread.h b/src/thread.h
index 8174fe4..db11bd8 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -8,7 +8,7 @@
 #ifndef BFS_THREAD_H
 #define BFS_THREAD_H
 
-#include "config.h"
+#include "prelude.h"
 #include <pthread.h>
 
 #if __STDC_VERSION__ < C23 && !defined(thread_local)
diff --git a/src/trie.c b/src/trie.c
index f275064..808953e 100644
--- a/src/trie.c
+++ b/src/trie.c
@@ -81,10 +81,10 @@
  * and insert intermediate singleton "jump" nodes when necessary.
  */
 
+#include "prelude.h"
 #include "trie.h"
 #include "alloc.h"
 #include "bit.h"
-#include "config.h"
 #include "diag.h"
 #include "list.h"
 #include <stdint.h>
diff --git a/src/xregex.c b/src/xregex.c
index 3df27f0..c2711bc 100644
--- a/src/xregex.c
+++ b/src/xregex.c
@@ -1,10 +1,10 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "xregex.h"
 #include "alloc.h"
 #include "bfstd.h"
-#include "config.h"
 #include "diag.h"
 #include "sanity.h"
 #include "thread.h"
diff --git a/src/xspawn.c b/src/xspawn.c
index 347625d..113d7ec 100644
--- a/src/xspawn.c
+++ b/src/xspawn.c
@@ -1,10 +1,10 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "xspawn.h"
 #include "alloc.h"
 #include "bfstd.h"
-#include "config.h"
 #include "list.h"
 #include <errno.h>
 #include <fcntl.h>
diff --git a/src/xspawn.h b/src/xspawn.h
index a20cbd0..6a8f54a 100644
--- a/src/xspawn.h
+++ b/src/xspawn.h
@@ -8,7 +8,7 @@
 #ifndef BFS_XSPAWN_H
 #define BFS_XSPAWN_H
 
-#include "config.h"
+#include "prelude.h"
 #include <sys/resource.h>
 #include <sys/types.h>
 #include <unistd.h>
diff --git a/src/xtime.c b/src/xtime.c
index bcf6dd3..91ed915 100644
--- a/src/xtime.c
+++ b/src/xtime.c
@@ -1,9 +1,9 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "xtime.h"
 #include "bfstd.h"
-#include "config.h"
 #include "diag.h"
 #include <errno.h>
 #include <limits.h>
diff --git a/tests/alloc.c b/tests/alloc.c
index 54b84ba..6c0defd 100644
--- a/tests/alloc.c
+++ b/tests/alloc.c
@@ -1,9 +1,9 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "tests.h"
 #include "alloc.h"
-#include "config.h"
 #include "diag.h"
 #include <errno.h>
 #include <stdlib.h>
diff --git a/tests/bfstd.c b/tests/bfstd.c
index 5e408ca..07b68b0 100644
--- a/tests/bfstd.c
+++ b/tests/bfstd.c
@@ -1,9 +1,9 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "tests.h"
 #include "bfstd.h"
-#include "config.h"
 #include "diag.h"
 #include <errno.h>
 #include <langinfo.h>
diff --git a/tests/bit.c b/tests/bit.c
index b444e50..674d1b2 100644
--- a/tests/bit.c
+++ b/tests/bit.c
@@ -1,9 +1,9 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "tests.h"
 #include "bit.h"
-#include "config.h"
 #include "diag.h"
 #include <limits.h>
 #include <stdint.h>
diff --git a/tests/ioq.c b/tests/ioq.c
index a69f2bf..ef5ee3b 100644
--- a/tests/ioq.c
+++ b/tests/ioq.c
@@ -1,10 +1,10 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "tests.h"
 #include "ioq.h"
 #include "bfstd.h"
-#include "config.h"
 #include "diag.h"
 #include "dir.h"
 #include <errno.h>
diff --git a/tests/main.c b/tests/main.c
index 281c417..429772b 100644
--- a/tests/main.c
+++ b/tests/main.c
@@ -5,10 +5,10 @@
  * Entry point for unit tests.
  */
 
+#include "prelude.h"
 #include "tests.h"
 #include "bfstd.h"
 #include "color.h"
-#include "config.h"
 #include <errno.h>
 #include <locale.h>
 #include <stdio.h>
diff --git a/tests/tests.h b/tests/tests.h
index d61ffd7..9078938 100644
--- a/tests/tests.h
+++ b/tests/tests.h
@@ -8,7 +8,7 @@
 #ifndef BFS_TESTS_H
 #define BFS_TESTS_H
 
-#include "config.h"
+#include "prelude.h"
 #include "diag.h"
 
 /** Unit test function type. */
diff --git a/tests/trie.c b/tests/trie.c
index 2a6eb48..4667322 100644
--- a/tests/trie.c
+++ b/tests/trie.c
@@ -1,9 +1,9 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "tests.h"
 #include "trie.h"
-#include "config.h"
 #include "diag.h"
 #include <stdlib.h>
 #include <string.h>
diff --git a/tests/xspawn.c b/tests/xspawn.c
index fd8362e..7362aa5 100644
--- a/tests/xspawn.c
+++ b/tests/xspawn.c
@@ -1,10 +1,10 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "tests.h"
 #include "alloc.h"
 #include "bfstd.h"
-#include "config.h"
 #include "dstring.h"
 #include "xspawn.h"
 #include <stdlib.h>
diff --git a/tests/xtime.c b/tests/xtime.c
index fd7aa0f..a7c63d2 100644
--- a/tests/xtime.c
+++ b/tests/xtime.c
@@ -1,10 +1,10 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "tests.h"
 #include "xtime.h"
 #include "bfstd.h"
-#include "config.h"
 #include "diag.h"
 #include <errno.h>
 #include <limits.h>
diff --git a/tests/xtouch.c b/tests/xtouch.c
index b1daec7..82d749d 100644
--- a/tests/xtouch.c
+++ b/tests/xtouch.c
@@ -1,8 +1,8 @@
 // Copyright © Tavian Barnes <tavianator@tavianator.com>
 // SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "bfstd.h"
-#include "config.h"
 #include "sanity.h"
 #include "xtime.h"
 #include <errno.h>
-- 
cgit v1.2.3