Switch from assert() to bfs_assert()/bfs_verify()

12 files changed, 57 insertions, 66 deletions

diff --git a/src/bfstd.c b/src/bfstd.c
index 91383a2..37f5276 100644
--- a/src/bfstd.c
+++ b/src/bfstd.c
@@ -5,7 +5,6 @@
 #include "config.h"
 #include "diag.h"
 #include "xregex.h"
-#include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <langinfo.h>
@@ -393,7 +392,7 @@ void close_quietly(int fd) {
 int xclose(int fd) {
 	int ret = close(fd);
 	if (ret != 0) {
-		assert(errno != EBADF);
+		bfs_verify(errno != EBADF);
 	}
 	return ret;
 }
diff --git a/src/bftw.c b/src/bftw.c
index 14805de..6ec5cfa 100644
--- a/src/bftw.c
+++ b/src/bftw.c
@@ -19,13 +19,13 @@
 #include "bftw.h"
 #include "bfstd.h"
 #include "config.h"
+#include "diag.h"
 #include "dir.h"
 #include "dstring.h"
 #include "list.h"
 #include "mtab.h"
 #include "stat.h"
 #include "trie.h"
-#include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdlib.h>
@@ -114,7 +114,7 @@ static void bftw_cache_remove(struct bftw_cache *cache, struct bftw_file *file)
 
 /** Close a bftw_file. */
 static void bftw_file_close(struct bftw_cache *cache, struct bftw_file *file) {
-	assert(file->fd >= 0);
+	bfs_assert(file->fd >= 0);
 
 	if (LIST_ATTACHED(cache, file, lru)) {
 		bftw_cache_remove(cache, file);
@@ -137,7 +137,7 @@ static int bftw_cache_pop(struct bftw_cache *cache) {
 
 /** Add a bftw_file to the cache. */
 static int bftw_cache_add(struct bftw_cache *cache, struct bftw_file *file) {
-	assert(file->fd >= 0);
+	bfs_assert(file->fd >= 0);
 
 	if (cache->capacity == 0 && bftw_cache_pop(cache) != 0) {
 		bftw_file_close(cache, file);
@@ -145,7 +145,7 @@ static int bftw_cache_add(struct bftw_cache *cache, struct bftw_file *file) {
 		return -1;
 	}
 
-	assert(cache->capacity > 0);
+	bfs_assert(cache->capacity > 0);
 	--cache->capacity;
 
 	LIST_INSERT(cache, cache->target, file, lru);
@@ -169,9 +169,9 @@ static size_t bftw_child_nameoff(const struct bftw_file *parent) {
 
 /** Destroy a cache. */
 static void bftw_cache_destroy(struct bftw_cache *cache) {
-	assert(!cache->head);
-	assert(!cache->tail);
-	assert(!cache->target);
+	bfs_assert(!cache->head);
+	bfs_assert(!cache->tail);
+	bfs_assert(!cache->target);
 }
 
 /** Create a new bftw_file. */
@@ -230,7 +230,7 @@ static struct bftw_file *bftw_file_new(struct bftw_file *parent, const char *nam
  *         The opened file descriptor, or negative on error.
  */
 static int bftw_file_openat(struct bftw_cache *cache, struct bftw_file *file, struct bftw_file *base, const char *at_path) {
-	assert(file->fd < 0);
+	bfs_assert(file->fd < 0);
 
 	int at_fd = AT_FDCWD;
 	if (base) {
@@ -332,7 +332,7 @@ static struct bfs_dir *bftw_file_opendir(struct bftw_cache *cache, struct bftw_f
 
 /** Free a bftw_file. */
 static void bftw_file_free(struct bftw_cache *cache, struct bftw_file *file) {
-	assert(file->refcount == 0);
+	bfs_assert(file->refcount == 0);
 
 	if (file->fd >= 0) {
 		bftw_file_close(cache, file);
@@ -770,7 +770,7 @@ static enum bftw_action bftw_call_back(struct bftw_state *state, const char *nam
 
 /** Pop a directory to read from the queue. */
 static bool bftw_pop_dir(struct bftw_state *state) {
-	assert(!state->file);
+	bfs_assert(!state->file);
 
 	if (!state->dirs.head) {
 		return false;
@@ -787,7 +787,7 @@ static bool bftw_pop_dir(struct bftw_state *state) {
 
 /** Pop a file to visit from the queue. */
 static bool bftw_pop_file(struct bftw_state *state) {
-	assert(!state->file);
+	bfs_assert(!state->file);
 
 	state->file = state->files.head;
 	if (state->file) {
@@ -802,8 +802,8 @@ static bool bftw_pop_file(struct bftw_state *state) {
  * Open the current directory.
  */
 static int bftw_opendir(struct bftw_state *state) {
-	assert(!state->dir);
-	assert(!state->de);
+	bfs_assert(!state->dir);
+	bfs_assert(!state->de);
 
 	state->direrror = 0;
 
@@ -863,7 +863,7 @@ static int bftw_gc(struct bftw_state *state, enum bftw_gc_flags flags) {
 
 	if (state->dir) {
 		struct bftw_file *file = state->file;
-		assert(file && file->fd >= 0);
+		bfs_assert(file && file->fd >= 0);
 
 		if (file->refcount > 1) {
 			// Keep the fd around if any subdirectories exist
diff --git a/src/color.c b/src/color.c
index 43ea9a4..a723084 100644
--- a/src/color.c
+++ b/src/color.c
@@ -12,7 +12,6 @@
 #include "fsade.h"
 #include "stat.h"
 #include "trie.h"
-#include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdarg.h>
@@ -699,7 +698,7 @@ static int print_colored(CFILE *cfile, const char *esc, const char *str, size_t
 /** Find the offset of the first broken path component. */
 static ssize_t first_broken_offset(const char *path, const struct BFTW *ftwbuf, enum bfs_stat_flags flags, size_t max) {
 	ssize_t ret = max;
-	assert(ret >= 0);
+	bfs_assert(ret >= 0);
 
 	if (bftw_type(ftwbuf, flags) != BFS_ERROR) {
 		goto out;
@@ -1100,7 +1099,7 @@ static int cbuff(CFILE *cfile, const char *format, ...) {
 }
 
 int cvfprintf(CFILE *cfile, const char *format, va_list args) {
-	assert(dstrlen(cfile->buffer) == 0);
+	bfs_assert(dstrlen(cfile->buffer) == 0);
 
 	int ret = -1;
 	if (cvbuff(cfile, format, args) == 0) {
diff --git a/src/diag.c b/src/diag.c
index d7ffaa6..04e3678 100644
--- a/src/diag.c
+++ b/src/diag.c
@@ -6,7 +6,6 @@
 #include "ctx.h"
 #include "color.h"
 #include "expr.h"
-#include <assert.h>
 #include <errno.h>
 #include <stdarg.h>
 #include <stdlib.h>
@@ -117,7 +116,7 @@ static bool highlight_expr_recursive(const struct bfs_ctx *ctx, const struct bfs
 	for (size_t i = 0; i < ctx->argc; ++i) {
 		if (&ctx->argv[i] == expr->argv) {
 			for (size_t j = 0; j < expr->argc; ++j) {
-				assert(i + j < ctx->argc);
+				bfs_assert(i + j < ctx->argc);
 				args[i + j] = true;
 				ret = true;
 			}
diff --git a/src/dir.c b/src/dir.c
index 6739f10..d9ee63b 100644
--- a/src/dir.c
+++ b/src/dir.c
@@ -4,7 +4,7 @@
 #include "dir.h"
 #include "bfstd.h"
 #include "config.h"
-#include <assert.h>
+#include "diag.h"
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
@@ -249,7 +249,7 @@ int bfs_closedir(struct bfs_dir *dir) {
 	int ret = xclose(dir->fd);
 #else
 	int ret = closedir(dir->dir);
-	assert(ret == 0 || errno != EBADF);
+	bfs_verify(ret == 0 || errno != EBADF);
 #endif
 	free(dir);
 	return ret;
diff --git a/src/eval.c b/src/eval.c
index 6cad3a9..342debd 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -26,7 +26,6 @@
 #include "trie.h"
 #include "xregex.h"
 #include "xtime.h"
-#include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <fnmatch.h>
@@ -990,7 +989,7 @@ static bool eval_expr(struct bfs_expr *expr, struct bfs_eval *state) {
 		}
 	}
 
-	assert(!state->quit);
+	bfs_assert(!state->quit);
 
 	bool ret = expr->eval_fn(expr, state);
 
@@ -1006,10 +1005,10 @@ static bool eval_expr(struct bfs_expr *expr, struct bfs_eval *state) {
 	}
 
 	if (bfs_expr_never_returns(expr)) {
-		assert(state->quit);
+		bfs_assert(state->quit);
 	} else if (!state->quit) {
-		assert(!expr->always_true || ret);
-		assert(!expr->always_false || !ret);
+		bfs_assert(!expr->always_true || ret);
+		bfs_assert(!expr->always_false || !ret);
 	}
 
 	return ret;
@@ -1511,7 +1510,7 @@ static void dump_bftw_flags(enum bftw_flags flags) {
 	DEBUG_FLAG(flags, BFTW_SORT);
 	DEBUG_FLAG(flags, BFTW_BUFFER);
 
-	assert(!flags);
+	bfs_assert(flags == 0, "Missing bftw flag 0x%X", flags);
 }
 
 /**
diff --git a/src/exec.c b/src/exec.c
index 7f22d36..5912ad6 100644
--- a/src/exec.c
+++ b/src/exec.c
@@ -10,7 +10,6 @@
 #include "diag.h"
 #include "dstring.h"
 #include "xspawn.h"
-#include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdarg.h>
@@ -276,12 +275,12 @@ static void bfs_exec_free_arg(char *arg, const char *tmpl) {
 
 /** Open a file to use as the working directory. */
 static int bfs_exec_openwd(struct bfs_exec *execbuf, const struct BFTW *ftwbuf) {
-	assert(execbuf->wd_fd < 0);
-	assert(!execbuf->wd_path);
+	bfs_assert(execbuf->wd_fd < 0);
+	bfs_assert(!execbuf->wd_path);
 
 	if (ftwbuf->at_fd != AT_FDCWD) {
 		// Rely on at_fd being the immediate parent
-		assert(xbaseoff(ftwbuf->at_path) == 0);
+		bfs_assert(xbaseoff(ftwbuf->at_path) == 0);
 
 		execbuf->wd_fd = ftwbuf->at_fd;
 		if (!(execbuf->flags & BFS_EXEC_MULTI)) {
diff --git a/src/opt.c b/src/opt.c
index 4ce9425..4699af4 100644
--- a/src/opt.c
+++ b/src/opt.c
@@ -35,7 +35,6 @@
 #include "exec.h"
 #include "expr.h"
 #include "pwcache.h"
-#include <assert.h>
 #include <errno.h>
 #include <limits.h>
 #include <stdarg.h>
@@ -308,7 +307,7 @@ struct opt_state {
 /** Log an optimization. */
 BFS_FORMATTER(3, 4)
 static bool opt_debug(const struct opt_state *state, int level, const char *format, ...) {
-	assert(state->ctx->optlevel >= level);
+	bfs_assert(state->ctx->optlevel >= level);
 
 	if (bfs_debug(state->ctx, DEBUG_OPT, "${cyn}-O%d${rs}: ", level)) {
 		va_list args;
@@ -387,7 +386,7 @@ static struct bfs_expr *de_morgan(const struct opt_state *state, struct bfs_expr
 		has_parent = false;
 	}
 
-	assert(expr->eval_fn == eval_and || expr->eval_fn == eval_or);
+	bfs_assert(expr->eval_fn == eval_and || expr->eval_fn == eval_or);
 	if (expr->eval_fn == eval_and) {
 		expr->eval_fn = eval_or;
 		expr->argv = &fake_or_arg;
@@ -446,7 +445,7 @@ static struct bfs_expr *optimize_expr_recursive(struct opt_state *state, struct
  * Optimize a negation.
  */
 static struct bfs_expr *optimize_not_expr(const struct opt_state *state, struct bfs_expr *expr) {
-	assert(expr->eval_fn == eval_not);
+	bfs_assert(expr->eval_fn == eval_not);
 
 	struct bfs_expr *rhs = expr->rhs;
 
@@ -498,7 +497,7 @@ fail:
 
 /** Optimize a conjunction. */
 static struct bfs_expr *optimize_and_expr(const struct opt_state *state, struct bfs_expr *expr) {
-	assert(expr->eval_fn == eval_and);
+	bfs_assert(expr->eval_fn == eval_and);
 
 	struct bfs_expr *lhs = expr->lhs;
 	struct bfs_expr *rhs = expr->rhs;
@@ -569,7 +568,7 @@ fail:
 
 /** Optimize a disjunction. */
 static struct bfs_expr *optimize_or_expr(const struct opt_state *state, struct bfs_expr *expr) {
-	assert(expr->eval_fn == eval_or);
+	bfs_assert(expr->eval_fn == eval_or);
 
 	struct bfs_expr *lhs = expr->lhs;
 	struct bfs_expr *rhs = expr->rhs;
@@ -673,7 +672,7 @@ static struct bfs_expr *ignore_result(const struct opt_state *state, struct bfs_
 
 /** Optimize a comma expression. */
 static struct bfs_expr *optimize_comma_expr(const struct opt_state *state, struct bfs_expr *expr) {
-	assert(expr->eval_fn == eval_comma);
+	bfs_assert(expr->eval_fn == eval_comma);
 
 	struct bfs_expr *lhs = expr->lhs;
 	struct bfs_expr *rhs = expr->rhs;
diff --git a/src/parse.c b/src/parse.c
index 807892c..1a04e68 100644
--- a/src/parse.c
+++ b/src/parse.c
@@ -29,7 +29,6 @@
 #include "xregex.h"
 #include "xspawn.h"
 #include "xtime.h"
-#include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <fnmatch.h>
@@ -134,7 +133,7 @@ static struct bfs_expr *new_unary_expr(bfs_eval_fn *eval_fn, struct bfs_expr *rh
 
 	expr->lhs = NULL;
 	expr->rhs = rhs;
-	assert(bfs_expr_is_parent(expr));
+	bfs_assert(bfs_expr_is_parent(expr));
 
 	expr->persistent_fds = rhs->persistent_fds;
 	expr->ephemeral_fds = rhs->ephemeral_fds;
@@ -154,7 +153,7 @@ static struct bfs_expr *new_binary_expr(bfs_eval_fn *eval_fn, struct bfs_expr *l
 
 	expr->lhs = lhs;
 	expr->rhs = rhs;
-	assert(bfs_expr_is_parent(expr));
+	bfs_assert(bfs_expr_is_parent(expr));
 
 	expr->persistent_fds = lhs->persistent_fds + rhs->persistent_fds;
 	if (lhs->ephemeral_fds > rhs->ephemeral_fds) {
@@ -263,7 +262,7 @@ static void init_highlight(const struct bfs_ctx *ctx, bool *args) {
 static void highlight_args(const struct bfs_ctx *ctx, char **argv, size_t argc, bool *args) {
 	size_t i = argv - ctx->argv;
 	for (size_t j = 0; j < argc; ++j) {
-		assert(i + j < ctx->argc);
+		bfs_assert(i + j < ctx->argc);
 		args[i + j] = true;
 	}
 }
diff --git a/src/printf.c b/src/printf.c
index 9ccc216..6520d2d 100644
--- a/src/printf.c
+++ b/src/printf.c
@@ -16,7 +16,6 @@
 #include "pwcache.h"
 #include "stat.h"
 #include "xtime.h"
-#include <assert.h>
 #include <errno.h>
 #include <grp.h>
 #include <pwd.h>
@@ -74,7 +73,7 @@ static bool should_color(CFILE *cfile, const struct bfs_printf *directive) {
 #define BFS_PRINTF_BUF(buf, format, ...) \
 	char buf[256]; \
 	int ret = snprintf(buf, sizeof(buf), format, __VA_ARGS__); \
-	assert(ret >= 0 && (size_t)ret < sizeof(buf)); \
+	bfs_assert(ret >= 0 && (size_t)ret < sizeof(buf)); \
 	(void)ret
 
 /**
@@ -190,7 +189,7 @@ static int bfs_printf_strftime(CFILE *cfile, const struct bfs_printf *directive,
 		break;
 	}
 
-	assert(ret >= 0 && (size_t)ret < sizeof(buf));
+	bfs_assert(ret >= 0 && (size_t)ret < sizeof(buf));
 	(void)ret;
 
 	return dyn_fprintf(cfile->file, directive, buf);
diff --git a/src/trie.c b/src/trie.c
index a2921de..8543eb1 100644
--- a/src/trie.c
+++ b/src/trie.c
@@ -86,7 +86,6 @@
 #include "config.h"
 #include "diag.h"
 #include "list.h"
-#include <assert.h>
 #include <limits.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ -139,27 +138,27 @@ static bool trie_is_leaf(uintptr_t ptr) {
 
 /** Decode a pointer to a leaf. */
 static struct trie_leaf *trie_decode_leaf(uintptr_t ptr) {
-	assert(trie_is_leaf(ptr));
+	bfs_assert(trie_is_leaf(ptr));
 	return (struct trie_leaf *)(ptr ^ 1);
 }
 
 /** Encode a pointer to a leaf. */
 static uintptr_t trie_encode_leaf(const struct trie_leaf *leaf) {
 	uintptr_t ptr = (uintptr_t)leaf ^ 1;
-	assert(trie_is_leaf(ptr));
+	bfs_assert(trie_is_leaf(ptr));
 	return ptr;
 }
 
 /** Decode a pointer to an internal node. */
 static struct trie_node *trie_decode_node(uintptr_t ptr) {
-	assert(!trie_is_leaf(ptr));
+	bfs_assert(!trie_is_leaf(ptr));
 	return (struct trie_node *)ptr;
 }
 
 /** Encode a pointer to an internal node. */
 static uintptr_t trie_encode_node(const struct trie_node *node) {
 	uintptr_t ptr = (uintptr_t)node;
-	assert(!trie_is_leaf(ptr));
+	bfs_assert(!trie_is_leaf(ptr));
 	return ptr;
 }
 
@@ -341,9 +340,9 @@ static void trie_leaf_free(struct trie *trie, struct trie_leaf *leaf) {
 /** Compute the size of a trie node with a certain number of children. */
 static size_t trie_node_size(unsigned int size) {
 	// Empty nodes aren't supported
-	assert(size > 0);
+	bfs_assert(size > 0);
 	// Node size must be a power of two
-	assert(has_single_bit(size));
+	bfs_assert(has_single_bit(size));
 
 	return flex_sizeof(struct trie_node, children, size);
 }
@@ -435,7 +434,7 @@ static struct trie_leaf *trie_node_insert(struct trie *trie, uintptr_t *ptr, str
 	unsigned int bit = 1U << nibble;
 
 	// The child must not already be present
-	assert(!(node->bitmap & bit));
+	bfs_assert(!(node->bitmap & bit));
 	node->bitmap |= bit;
 
 	unsigned int target = count_ones(node->bitmap & (bit - 1));
@@ -474,7 +473,7 @@ static struct trie_leaf *trie_node_insert(struct trie *trie, uintptr_t *ptr, str
 static uintptr_t *trie_jump(uintptr_t *ptr, const char *key, size_t *offset) {
 	// We only ever need to jump to leaf nodes, since internal nodes are
 	// guaranteed to be within OFFSET_MAX anyway
-	assert(trie_is_leaf(*ptr));
+	bfs_assert(trie_is_leaf(*ptr));
 
 	struct trie_node *node = malloc(trie_node_size(1));
 	if (!node) {
@@ -512,7 +511,7 @@ static uintptr_t *trie_jump(uintptr_t *ptr, const char *key, size_t *offset) {
 static struct trie_leaf *trie_split(struct trie *trie, uintptr_t *ptr, struct trie_leaf *leaf, struct trie_leaf *rep, size_t offset, size_t mismatch) {
 	unsigned char key_nibble = trie_key_nibble(leaf->key, mismatch);
 	unsigned char rep_nibble = trie_key_nibble(rep->key, mismatch);
-	assert(key_nibble != rep_nibble);
+	bfs_assert(key_nibble != rep_nibble);
 
 	struct trie_node *node = malloc(trie_node_size(2));
 	if (!node) {
@@ -570,11 +569,11 @@ static struct trie_leaf *trie_insert_mem_impl(struct trie *trie, const void *key
 		unsigned char nibble = trie_key_nibble(key, offset);
 		unsigned int bit = 1U << nibble;
 		if (node->bitmap & bit) {
-			assert(offset < mismatch);
+			bfs_assert(offset < mismatch);
 			unsigned int index = count_ones(node->bitmap & (bit - 1));
 			ptr = &node->children[index];
 		} else {
-			assert(offset == mismatch);
+			bfs_assert(offset == mismatch);
 			return trie_node_insert(trie, ptr, leaf, nibble);
 		}
 	}
@@ -600,7 +599,7 @@ static void trie_free_singletons(struct trie *trie, uintptr_t ptr) {
 		struct trie_node *node = trie_decode_node(ptr);
 
 		// Make sure the bitmap is a power of two, i.e. it has just one child
-		assert(has_single_bit(node->bitmap));
+		bfs_assert(has_single_bit(node->bitmap));
 
 		ptr = node->children[0];
 		free(node);
@@ -651,12 +650,12 @@ static void trie_remove_impl(struct trie *trie, struct trie_leaf *leaf) {
 	while (!trie_is_leaf(*child)) {
 		struct trie_node *node = trie_decode_node(*child);
 		offset += node->offset;
-		assert((offset >> 1) < leaf->length);
+		bfs_assert((offset >> 1) < leaf->length);
 
 		unsigned char nibble = trie_key_nibble(leaf->key, offset);
 		unsigned int bit = 1U << nibble;
 		unsigned int bitmap = node->bitmap;
-		assert(bitmap & bit);
+		bfs_assert(bitmap & bit);
 		unsigned int index = count_ones(bitmap & (bit - 1));
 
 		// Advance the parent pointer, unless this node had only one child
@@ -669,7 +668,7 @@ static void trie_remove_impl(struct trie *trie, struct trie_leaf *leaf) {
 		child = &node->children[index];
 	}
 
-	assert(trie_decode_leaf(*child) == leaf);
+	bfs_assert(trie_decode_leaf(*child) == leaf);
 
 	if (!parent) {
 		trie_free_singletons(trie, trie->root);
@@ -683,7 +682,7 @@ static void trie_remove_impl(struct trie *trie, struct trie_leaf *leaf) {
 
 	node->bitmap ^= child_bit;
 	unsigned int parent_size = count_ones(node->bitmap);
-	assert(parent_size > 0);
+	bfs_assert(parent_size > 0);
 	if (parent_size == 1 && trie_collapse_node(parent, node, child_index) == 0) {
 		return;
 	}
diff --git a/src/xregex.c b/src/xregex.c
index a7153b7..1143f23 100644
--- a/src/xregex.c
+++ b/src/xregex.c
@@ -3,7 +3,7 @@
 
 #include "xregex.h"
 #include "config.h"
-#include <assert.h>
+#include "diag.h"
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
@@ -140,7 +140,7 @@ int bfs_regcomp(struct bfs_regex **preg, const char *pattern, enum bfs_regex_typ
 		syntax = ONIG_SYNTAX_GREP;
 		break;
 	}
-	assert(syntax);
+	bfs_assert(syntax);
 
 	OnigOptionType options = syntax->options;
 	if (flags & BFS_REGEX_ICASE) {