Massive overhaul to cbs.h

1 files changed, 380 insertions, 720 deletions

diff --git a/cbs.h b/cbs.h
index 72ccef5..64d6372 100644
--- a/cbs.h
+++ b/cbs.h
@@ -1,758 +1,458 @@
-/* Single-header library to help write build scripts in C.  This library is
-   POSIX compliant, so it should work on all respectible UNIX-like systems.
-
-   You can find the CBS git repository at https://git.sr.ht/~mango/cbs and you
-   can include this in your project with the following command:
-
-       $ wget 'https://git.sr.ht/~mango/cbs/blob/master/cbs.h'
-
-   This library is licensed under the 0-Clause BSD license, and as such you may
-   do whatever you want to it, however you want to it, whenever you want.  You
-   are encouraged in fact to modify this library to suit your specific usecase.
-
-   All functions and macros are documented.  You can figure out the API pretty
-   easily by just reading the comments in this file.
-
-   In many cases you may want to be able to execute commands on multiple threads
-   to speed up compilation, such as the -j option when using Make.  Functions
-   for creating and using thread pools will be made available if the CBS_PTHREAD
-   macro is defined before including this file.  Do note that on POSIX platforms
-   it will require linking to the pthreads library when bootstrapping the build
-   script.
-
-   This file does not support C89.  Fuck C89, that shit is ancient.  Move on.
-
-   IMPORTANT NOTE: Any identifiers prefixed with an underscore (e.g. ‘_rebuild’)
-   are meant for internal use only and you should not touch them unless you know
-   what you’re doing.
-
-   IMPORTANT NOTE: All the functions and macros in this library will terminate
-   the program on error.  If this is undesired behavior, feel free to edit the
-   functions to return errors.
-
-   IMPORTANT NOTE: This library is built with the assumption that the source
-   file for your build script and your build script are in the SAME DIRECTORY.
-
-   There are a few exceptions to the above rule, and they are documented.
-
-   This library does not aim to ever support Windows */
+/*
+ * BSD Zero Clause License
+ *
+ * Copyright © 2023–2024 Thomas Voss
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
 
 #ifndef C_BUILD_SYSTEM_H
 #define C_BUILD_SYSTEM_H
 
-#ifdef __GNUC__
-#	pragma GCC diagnostic push
-#	pragma GCC diagnostic ignored "-Wunused-function"
-#	pragma GCC diagnostic ignored "-Wparentheses"
-#endif
-
-/* Assert that the user is building for a supported platform.  The only portable
-   way to check for POSIX is to validate that unistd.h exists.  This is only
-   possible without compiler extensions in C23 (although some compilers support
-   it as an extension in earlier editions), so people compiling for pre-C23
-   might not get this error if on a bad platform, and may end up being a bit
-   confused.
-
-   It’s just a maybe though, this is nothing more than a sanity check for the
-   users sake. */
-#if defined(__has_include) && !__has_include(<unistd.h>)
-#	error "Non-POSIX platform detected"
-#endif
-
-#ifdef __APPLE__
-#	define st_mtim st_mtimespec
-#endif
-
+#define _GNU_SOURCE
 #include <sys/stat.h>
 #include <sys/wait.h>
 
+#include <assert.h>
 #include <errno.h>
-#include <libgen.h>
 #include <limits.h>
-#ifdef CBS_PTHREAD
+#ifndef CBS_NO_THREADS
 #	include <pthread.h>
 #endif
-#include <stdarg.h>
-#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <wordexp.h>
 
-/* C23 changed a lot so we want to check for it */
-#if __STDC_VERSION__ >= 202000
-#	define CBS_IS_C23 1
-#endif
+#define _vtoxs(...) ((char *[]){__VA_ARGS__})
 
-/* Some C23 compat.  In C23 booleans are actual keywords, and the noreturn
-   attribute is different. */
-#if CBS_IS_C23
-#	define noreturn [[noreturn]]
-#else
-#	include <stdbool.h>
-#	include <stddef.h>
-#	include <stdnoreturn.h>
-#	define nullptr NULL
-#endif
+#define lengthof(xs) (sizeof(xs) / sizeof(*(xs)))
 
-/* Give helpful diagnostics when people use die() incorrectly on GCC.  C23
-   introduced C++ attribute syntax, so we need a check for that too. */
-#ifdef __GNUC__
-#	if CBS_IS_C23
-#		define ATTR_FMT [[gnu::format(printf, 1, 2)]]
-#	else
-#		define ATTR_FMT __attribute__((format(printf, 1, 2)))
-#	endif
-#else
-#	define ATTR_FMT
-#endif
-
-/* Clang defines this attribute, and while it does nothing it does serve as
-   good documentation. */
-#ifndef _Nullable
-#	define _Nullable
-#endif
-
-/* Convert the given variadic arguments to a string array */
-#define _vtoa(...) ((char *[]){__VA_ARGS__})
-
-/* Internal global versions of argc and argv, so our functions and macros can
-   access them from anywhere. */
-static int _cbs_argc;
-static char **_cbs_argv;
-
-/* A vector of strings used to accumulate output of functions such as pcquery().
-   The array of strings buf has length len, and is not null-terminated.  You
-   should always zero-initialize variables of this type. */
-struct strv {
+struct strs {
 	char **buf;
-	size_t len;
+	size_t len, cap;
 };
 
-/* Free and zero a string vector.  Because this function zeros the structure, it
-   is safe to reuse the vector after this function is called. */
-static void strvfree(struct strv *);
-
-/* A wrapper function around realloc().  It behaves exactly the same except
-   instead of taking a buffer size as an argument, it takes a count n of
-   elements, and a size m of each element.  This allows it to properly check for
-   overflow, and errors if overflow would occur. */
-static void *bufalloc(void *_Nullable, size_t n, size_t m);
-
-/* Error reporting functions.  The die() function takes the same arguments as
-   printf() and prints the corresponding string to stderr.  It also prefixes the
-   string with the command name followed by a colon, and suffixes the string
-   with a colon and the error string returned from strerror().
-
-   If you want to print just the error message and no custom text, NULL may be
-   passed to die().  NULL should not be passed to diex().
-
-   diex() is the same as die() but does not print a strerror() error string. */
-ATTR_FMT noreturn static void die(const char *_Nullable, ...);
-ATTR_FMT noreturn static void diex(const char *, ...);
-
-/* Initializes some data required for this header to work properly.  This should
-   be the first thing called in main() with argc and argv passed.  It also
-   chdir()s into the directory where the build script is located. */
-static void cbsinit(int, char **);
-
-/* Get the number of items in the array a */
-#define lengthof(a) (sizeof(a) / sizeof(*(a)))
-
-/* Struct representing a CLI command that various functions act on.  You should
-   always zero-initialize variables of this type before use.
-
-   After executing a command, you can reuse the already allocated buffer this
-   command holds by calling cmdclr().  When you’re really done with an object of
-   this type, remember to call free() on ._argv.
-
-   The ._argv field is a NULL-terminated list of command arguments of length
-   ._len.  You may safely read from both of these fields but they should NOT be
-   modified without use of cmdadd() and cmdaddv(). */
-typedef struct {
-	char **_argv;
-	size_t _len, _cap;
-} cmd_t;
+enum pkg_config_flags {
+	PC_CFLAGS = 1 << 0,
+	PC_LIBS = 1 << 1,
+	PC_SHARED = 1 << 2,
+	PC_STATIC = 1 << 3,
+};
 
-/* Returns whether or not a binary of the given name exists in the users
-   environment as defined by $PATH. */
-static bool binexists(const char *);
+void cbsinit(int, char **);
+static void rebuild(const char *); /* Always call via macro wrapper */
+#define rebuild() rebuild(__FILE__)
 
-/* cmdadd() adds the variadic string arguments to the given command.
-   Alternatively, the cmdaddv() function adds the n strings pointed to by p to
-   the given command. */
-static void cmdaddv(cmd_t *, char **p, size_t n);
-#define cmdadd(cmd, ...) \
-	cmdaddv(cmd, _vtoa(__VA_ARGS__), lengthof(_vtoa(__VA_ARGS__)))
-
-/* Clear (but not free) the command c.  Useful for reusing the same command
-   struct to minimize allocations. */
-static void cmdclr(cmd_t *c);
-
-/* The cmdexec() function executes the given command and waits for it to
-   terminate, returning its exit code.  The cmdexeca() function executes the
-   given command and returns immediately, returning its process ID.
-
-   The cmdexecb() function is like cmdexec() except it writes the given commands
-   standard output to the character buffer pointed to by p.  It also stores the
-   size of the output in *n.  The character buffer p is null-terminated.  If the
-   given command produces no output to the standard output, p will be set to
-   NULL.
-
-   cmdexec() and cmdexecb() have the same return values as cmdwait(). */
-static int cmdexec(cmd_t);
-static pid_t cmdexeca(cmd_t);
-static int cmdexecb(cmd_t, char **p, size_t *n);
-
-/* Wait for the process with the given PID to terminate, and return its exit
-   status.  If the process was terminated by a signal 256 is returned. */
-static int cmdwait(pid_t);
+static void strsfree(struct strs *);
+static void strszero(struct strs *);
+static void strspush(struct strs *, char **, size_t);
+static void strspushenv(struct strs *, const char *, char **, size_t);
+#define strspushl(xs, ...)                                                     \
+	strspush((xs), _vtoxs(__VA_ARGS__), lengthof(_vtoxs(__VA_ARGS__)))
+#define strspushenvl(xs, ev, ...)                                              \
+	strspushenv((xs), (ev), _vtoxs(__VA_ARGS__), lengthof(_vtoxs(__VA_ARGS__)))
 
-/* Write a representation of the given command to the given file stream.  This
-   can be used to mimick the echoing behavior of make(1).  The cmdput() function
-   is a nice convenience function so you can avoid writing ‘stdout’ all the
-   time. */
-static void cmdput(cmd_t);
-static void cmdputf(FILE *, cmd_t);
-
-/* Expand the environment variable s using /bin/sh expansion rules and append
-   the results in the given string vector.  If the environment variable is NULL
-   or empty, then store the strings specified by the array p of length n.
-
-   env_or_default() is the same as env_or_defaultv() but you provide p as
-   variadic arguments.
-
-   If the pointer p is null, then no default value is appended to the given
-   string vector when the environment variable is not present. */
-static void env_or_defaultv(struct strv *, const char *s, char *_Nullable *p,
-                            size_t n);
-#define env_or_default(sv, s, ...) \
-	env_or_defaultv((sv), (s), _vtoa(__VA_ARGS__), lengthof(_vtoa(__VA_ARGS__)))
-
-/* Returns if a file exists at the given path.  A return value of false may also
-   mean you don’t have the proper file access permissions, which will also set
-   errno. */
 static bool fexists(const char *);
-
-/* Compare the modification dates of the two named files.
-
-   A return value >0 means the LHS is newer than the RHS.
-   A return value <0 means the LHS is older than the RHS.
-   A return value of 0 means the LHS and RHS have the same modification date.
-
-   The fmdnewer() and fmdolder() functions are wrappers around fmdcmp() that
-   return true when the LHS is newer or older than the RHS respectively. */
 static int fmdcmp(const char *, const char *);
 static bool fmdolder(const char *, const char *);
 static bool fmdnewer(const char *, const char *);
+static bool foutdated(const char *, char **, size_t);
+#define foutdatedl(s, ...)                                                     \
+	foutdated(s, _vtoxs(__VA_ARGS__), lengthof(_vtoxs(__VA_ARGS__)))
 
-/* Report if any of n files specified by p render the file base outdated.  If
-   the file base does not exist, this function returns true.  You will typically
-   call this with a compiled program as base, and C source files as p.  The
-   macro foutdated() is a wrapper around foutdatedv() that allows you to specify
-   the sources to base as variadic arguments instead of as an array. */
-static bool foutdatedv(const char *base, const char **p, size_t n);
-#define foutdated(s, ...) \
-	foutdatedv(s, (const char **)_vtoa(__VA_ARGS__), \
-	           lengthof(_vtoa(__VA_ARGS__)))
-
-/* Rebuild the build script if it has been modified, and execute the newly built
-   script.  You should call the rebuild() macro at the very beginning of main(),
-   but right after cbsinit().  You probably don’t want to call _rebuild()
-   directly.
-
-   NOTE: This function/macro REQUIRES that the source for the build script and
-   the compiled build script are in the SAME DIRECTORY. */
-static void _rebuild(char *);
-#define rebuild() _rebuild(__FILE__)
-
-/* Get the number of available CPUs, or -1 on error.  This function also returns
-   -1 if the _SC_NPROCESSORS_ONLN flag to sysconf(3) is not available.  In that
-   case, errno will not be set. */
-static int nproc(void);
+static int cmdexec(struct strs);
+static pid_t cmdexec_async(struct strs);
+static int cmdexec_read(struct strs, char **, size_t *);
+static int cmdwait(pid_t);
+static void cmdput(struct strs);
+static void cmdfput(FILE *, struct strs);
 
-/* Append the arguments returned by an invokation of pkg-config for the library
-   lib to the given string vector.  The flags argument is one-or-more of the
-   flags in the pkg_config_flags enum bitwise-ORed together.
+static char *swpext(const char *, const char *);
+static bool pcquery(struct strs *, const char *, int);
+static bool binexists(const char *);
+static int nproc(void);
 
-   If PKGC_CFLAGS is specified, call pkg-config with ‘--cflags’.
-   If PKGC_LIBS is specified, call pkg-config with ‘--libs’.
+#ifndef CBS_NO_THREADS
+typedef void tjob(void *);
+typedef void tjob_free(void *);
 
-   This function returns true on success and false if pkg-config is not found on
-   the system.  To check for pkg-configs existance, you can use the binexists()
-   function. */
-static bool pcquery(struct strv *, char *lib, int flags);
-enum pkg_config_flags {
-	PKGC_LIBS = 1 << 0,
-	PKGC_CFLAGS = 1 << 1,
+struct _tqueue {
+	void *arg;
+	tjob *fn;
+	tjob_free *free;
+	struct _tqueue *next;
 };
 
-#ifdef CBS_PTHREAD
+typedef struct {
+	bool stop;
+	size_t tcnt, left;
+	pthread_t *thrds;
+	pthread_cond_t cnd;
+	pthread_mutex_t mtx;
+	struct _tqueue *head, *tail;
+} tpool;
+
+static void tpinit(tpool *, size_t);
+static void tpfree(tpool *);
+static void tpwait(tpool *);
+static void tpenq(tpool *, tjob *, void *, tjob_free *);
+#endif /* !CBS_NO_THREADS */
 
-/* A tfunc_t represents a function to be executed by a threads in a thread pool.
-   It takes an argument in the form of a void * and returns nothing. */
-typedef void (*tfunc_t)(void *);
+static int _cbs_argc;
+static char **_cbs_argv;
 
-/* A tfunc_free_t represents a function which frees the argument passed to a
-   tfunc_t function. */
-typedef void (*tfree_func_t)(void *);
+/* Implementation */
 
-/* A thread pool job queue.  Meant for internal-use only. */
-struct _tjob {
-	void *arg;
-	tfunc_t fn;
-	tfree_func_t free;
-	struct _tjob *next;
-};
+#ifdef __GNUC__
+#	pragma GCC diagnostic push
+#	pragma GCC diagnostic ignored "-Wunused-function"
+#endif
 
-/* A basic thread pool.  None of its fields should really be touched. */
-typedef struct {
-	bool _stop;
-	size_t _tcnt, _left;
-	pthread_t *_thrds;
-	pthread_cond_t _cnd;
-	pthread_mutex_t _mtx;
-	struct _tjob *_head, *_tail;
-} tpool_t;
-
-/* Initialize and destroy a thread pool.  The tpinit() function initializes the
-   given thread pool and creates n threads ready to execute work.  The tpfree()
-   function should be called after a thread pool has been used to release all
-   resources used by the thread pool. */
-static void tpinit(tpool_t *, size_t n);
-static void tpfree(tpool_t *);
-
-/* Wait for all jobs on the given thread pool to be executed.  Note that this
-   function does not destroy the threads or free any resources — those are tasks
-   for the tpfree() function. */
-static void tpwait(tpool_t *);
-
-/* Enqueue and dequeue jobs to the thread pools job queue.  The tpenq() function
-   is threadsafe while the _tpdeq() function is not (so don’t use it).  When
-   calling the tpenq() function, the function fn will be queued to be executed
-   by a thread in the thread pool with the argument arg.  If the given argument
-   needs to be deallocated after the job completes, you can pass the free
-   argument which will be called with the given argument after use.  If free is
-   NULL, it will be ignored.
-
-   The free() function is a valid argument to the free parameter. */
-static void tpenq(tpool_t *, tfunc_t fn, void *arg,
-                  tfree_func_t _Nullable free);
-static struct _tjob *_tpdeq(tpool_t *);
-
-#endif /* CBS_PTHREAD */
-
-/* BEGIN DEFINITIONS */
+#ifdef __APPLE__
+#	define st_mtim st_mtimespec
+#endif
 
 void
-strvfree(struct strv *v)
+cbsinit(int argc, char **argv)
 {
-	free(v->buf);
-	memset(v, 0, sizeof(*v));
+	_cbs_argc = argc;
+	_cbs_argv = malloc(sizeof(char *) * (argc + 1));
+	assert(_cbs_argv != NULL);
+	for (int i = 0; i < argc; i++) {
+		_cbs_argv[i] = strdup(argv[i]);
+		assert(_cbs_argv[i] != NULL);
+	}
+	_cbs_argv[argc] = NULL;
+
+	char *s = strrchr(_cbs_argv[0], '/');
+	if (s != NULL) {
+		s[0] = 0;
+		assert(chdir(_cbs_argv[0]) != -1);
+		s[0] = '/';
+	}
 }
 
-void *
-bufalloc(void *p, size_t n, size_t m)
+void
+(rebuild)(const char *path)
 {
-	if (n && SIZE_MAX / n < m) {
-		errno = EOVERFLOW;
-		die(__func__);
-	}
+	char *src, *dst;
+
+	if ((src = strrchr(path, '/')) != NULL)
+		src++;
+	else
+		src = (char *)path;
 
-	if (!(p = realloc(p, n * m)))
-		die(__func__);
-	return p;
+	if ((dst = strrchr(*_cbs_argv, '/')) != NULL)
+		dst++;
+	else
+		dst = *_cbs_argv;
+
+	if (!foutdatedl(dst, src))
+		return;
+
+	struct strs xs = {0};
+	strspushenvl(&xs, "CC", "cc");
+#ifndef CBS_NO_THREADS
+	strspushl(&xs, "-lpthread");
+#endif
+	strspushl(&xs, "-o", dst, src);
+	cmdput(xs);
+	assert(cmdexec(xs) == EXIT_SUCCESS);
+
+	execvp(*_cbs_argv, _cbs_argv);
+	assert(!"failed to execute process");
 }
 
 void
-die(const char *fmt, ...)
+strsfree(struct strs *xs)
 {
-	int e = errno;
-	va_list ap;
-
-	va_start(ap, fmt);
-	flockfile(stderr);
-	fprintf(stderr, "%s: ", *_cbs_argv);
-	if (fmt) {
-		vfprintf(stderr, fmt, ap);
-		fprintf(stderr, ": ");
-	}
-	fprintf(stderr, "%s\n", strerror(e));
-	exit(EXIT_FAILURE);
+	free(xs->buf);
+	xs->buf = NULL;
+	xs->len = xs->cap = 0;
 }
 
 void
-diex(const char *fmt, ...)
+strszero(struct strs *xs)
 {
-	va_list ap;
-
-	va_start(ap, fmt);
-	flockfile(stderr);
-	fprintf(stderr, "%s: ", *_cbs_argv);
-	vfprintf(stderr, fmt, ap);
-	fputc('\n', stderr);
-	exit(EXIT_FAILURE);
+	xs->len = 0;
 }
 
 void
-cbsinit(int argc, char **argv)
+strspush(struct strs *xs, char **ys, size_t n)
 {
-	char *s;
+	if (n == 0)
+		return;
 
-	_cbs_argc = argc;
-	_cbs_argv = bufalloc(nullptr, argc, sizeof(char *));
-	for (int i = 0; i < argc; i++) {
-		if (!(_cbs_argv[i] = strdup(argv[i]))) {
-			/* We might not have set _cbs_argv[0] yet, so we can’t use die() */
-			fprintf(stderr, "%s: strdup: %s\n", *argv, strerror(errno));
-			exit(EXIT_FAILURE);
-		}
+	if (xs->len + n >= xs->cap) {
+		xs->cap = (xs->len + n) * 2;
+		xs->buf = realloc(xs->buf, sizeof(char *) * (xs->cap + 1));
+		assert(xs->buf != NULL);
 	}
+	memcpy(xs->buf + xs->len, ys, n * sizeof(char *));
+	xs->len += n;
 
-	/* Cd to dirname(argv[0]).  We can’t use dirname(3) because it may modify
-	   the source string. */
-	if (s = strrchr(_cbs_argv[0], '/')) {
-		s[0] = '\0';
-		if (chdir(_cbs_argv[0]) == -1)
-			die("chdir: %s", s);
-		s[0] = '/';
-	}
+	assert(xs->len <= xs->cap);
+	xs->buf[xs->len] = NULL;
 }
 
-static size_t
-_next_powerof2(size_t x)
+void
+strspushenv(struct strs *xs, const char *ev, char **ys, size_t n)
 {
-#if defined(__has_builtin) && __has_builtin(__builtin_clzl)
-	x = x <= 1 ? 1 : 1 << (64 - __builtin_clzl(x - 1));
-#else
-	if (x) {
-		x--;
-		x |= x >> 1;
-		x |= x >> 2;
-		x |= x >> 4;
-		x |= x >> 8;
-		if (sizeof(size_t) >= 4)
-			x |= x >> 16;
-		if (sizeof(size_t) >= 8)
-			x |= x >> 32;
-	}
-	x++;
-#endif
-
-	return x;
+	/* NOTE: Do your best to NOT modify any pushed envvar! */
+	char *p = getenv(ev);
+	if (p == NULL || *p == 0)
+		strspush(xs, ys, n);
+	else
+		strspush(xs, &p, 1);
 }
 
 bool
-binexists(const char *name)
+fexists(const char *f)
 {
-	char *p, *path;
-
-	if (!(path = getenv("PATH")))
-		diex("PATH environment variable not found");
+	return !access(f, F_OK);
+}
 
-	if (!(path = strdup(path)))
-		die("strdup");
-	p = strtok(path, ":");
-	while (p) {
-		char buf[PATH_MAX];
-		snprintf(buf, sizeof(buf), "%s/%s", p, name);
-		if (fexists(buf)) {
-			free(path);
-			return true;
-		}
+int
+fmdcmp(const char *lhs, const char *rhs)
+{
+	struct stat sbl, sbr;
 
-		p = strtok(nullptr, ":");
-	}
+	assert(stat(lhs, &sbl) != -1);
+	assert(stat(rhs, &sbr) != -1);
 
-	free(path);
-	return false;
+	return sbl.st_mtim.tv_sec == sbr.st_mtim.tv_sec
+	         ? sbl.st_mtim.tv_nsec - sbr.st_mtim.tv_nsec
+	         : sbl.st_mtim.tv_sec - sbr.st_mtim.tv_sec;
 }
 
-void
-cmdaddv(cmd_t *cmd, char **xs, size_t n)
+bool
+fmdnewer(const char *lhs, const char *rhs)
 {
-	if (cmd->_len + n >= cmd->_cap) {
-		cmd->_cap = _next_powerof2(cmd->_len + n) + 2;
-		cmd->_argv = bufalloc(cmd->_argv, cmd->_cap, sizeof(char *));
-	}
+	return fmdcmp(lhs, rhs) > 0;
+}
 
-	memcpy(cmd->_argv + cmd->_len, xs, n * sizeof(*xs));
-	cmd->_len += n;
-	cmd->_argv[cmd->_len] = nullptr;
+bool
+fmdolder(const char *lhs, const char *rhs)
+{
+	return fmdcmp(lhs, rhs) < 0;
 }
 
-void
-cmdclr(cmd_t *c)
+bool
+foutdated(const char *src, char **deps, size_t n)
 {
-	c->_len = 0;
-	*c->_argv = nullptr;
+	if (!fexists(src))
+		return true;
+	for (size_t i = 0; i < n; i++) {
+		if (fmdolder(src, deps[i]))
+			return true;
+	}
+	return false;
 }
 
 int
-cmdexec(cmd_t c)
+cmdexec(struct strs xs)
 {
-	return cmdwait(cmdexeca(c));
+	return cmdwait(cmdexec_async(xs));
 }
 
 pid_t
-cmdexeca(cmd_t c)
+cmdexec_async(struct strs xs)
 {
-	pid_t pid;
-
-	switch (pid = fork()) {
-	case -1:
-		die("fork");
-	case 0:
-		execvp(*c._argv, c._argv);
-		die("execvp: %s", *c._argv);
+	pid_t pid = fork();
+	assert(pid != -1);
+	if (pid == 0) {
+		execvp(xs.buf[0], xs.buf);
+		assert(!"failed to execute process");
 	}
-
 	return pid;
 }
 
 int
-cmdexecb(cmd_t c, char **p, size_t *n)
+cmdexec_read(struct strs xs, char **p, size_t *n)
 {
 	enum {
-		FD_R,
-		FD_W,
+		R,
+		W,
 	};
-	pid_t pid;
 	int fds[2];
-	char *buf;
-	size_t len, blksize;
-	struct stat sb;
 
-	if (pipe(fds) == -1)
-		die("pipe");
-
-	switch (pid = fork()) {
-	case -1:
-		die("fork");
-	case 0:
-		close(fds[FD_R]);
-		if (dup2(fds[FD_W], STDOUT_FILENO) == -1)
-			die("dup2");
-		execvp(*c._argv, c._argv);
-		die("execvp: %s", *c._argv);
+	assert(pipe(fds) != -1);
+
+	pid_t pid = fork();
+	assert(pid != -1);
+
+	if (pid == 0) {
+		close(fds[R]);
+		close(STDOUT_FILENO);
+		assert(dup2(fds[W], STDOUT_FILENO) != -1);
+		execvp(xs.buf[0], xs.buf);
+		assert(!"failed to execute process");
 	}
 
-	close(fds[FD_W]);
+	close(fds[W]);
+
+	struct stat sb;
+	assert(fstat(fds[R], &sb) != -1);
 
-	buf = nullptr;
-	len = 0;
+	*p = NULL, *n = 0;
+	char *buf = malloc(sb.st_blksize);
+	assert(buf != NULL);
 
-	blksize = fstat(fds[FD_R], &sb) == -1 ? BUFSIZ : sb.st_blksize;
 	for (;;) {
-		/* This can maybe somewhere somehow break some system.  I do not care */
-		char tmp[blksize];
 		ssize_t nr;
-
-		if ((nr = read(fds[FD_R], tmp, blksize)) == -1)
-			die("read");
-		if (!nr)
+		if ((nr = read(fds[R], buf, sb.st_blksize)) == 0)
 			break;
-		buf = bufalloc(buf, len + nr + 1, sizeof(char));
-		memcpy(buf + len, tmp, nr);
-		len += nr;
+		assert(nr != -1);
+
+		*p = realloc(*p, *n + nr + 1);
+		assert(*p != NULL);
+
+		memcpy(*p + *n, buf, nr);
+		*n += nr;
 	}
 
-	close(fds[FD_R]);
-	if (buf)
-		buf[len] = 0;
-	*p = buf;
-	*n = len;
+	close(fds[R]);
+	if (buf != NULL)
+		buf[*n] = 0;
+	free(buf);
+
 	return cmdwait(pid);
 }
 
 int
 cmdwait(pid_t pid)
 {
-	for (;;) {
-		int ws;
-		if (waitpid(pid, &ws, 0) == -1)
-			die("waitpid");
-
-		if (WIFEXITED(ws))
-			return WEXITSTATUS(ws);
-
-		if (WIFSIGNALED(ws))
-			return 256;
-	}
+	int ws;
+	assert(waitpid(pid, &ws, 0) != -1);
+	if (WIFEXITED(ws))
+		return WEXITSTATUS(ws);
+	return WIFEXITED(ws) ? WEXITSTATUS(ws) : 256;
 }
 
 /* import shlex
 
-   s = '#define SHELL_SAFE "'
+   s = '#define _SHELL_SAFE "'
    for c in map(chr, range(128)):
        if not shlex._find_unsafe(c):
            s += c
    print(s + '"') */
-#define SHELL_SAFE \
+#define _SHELL_SAFE                                                            \
 	"%+,-./0123456789:=@ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"
 
 void
-cmdput(cmd_t c)
+cmdput(struct strs xs)
 {
-	cmdputf(stdout, c);
+	cmdfput(stdout, xs);
 }
 
 void
-cmdputf(FILE *stream, cmd_t cmd)
+cmdfput(FILE *fp, struct strs xs)
 {
-	flockfile(stream);
-	for (size_t i = 0; i < cmd._len; i++) {
+	flockfile(fp);
+	for (size_t i = 0; i < xs.len; i++) {
 		bool safe = true;
 		char *p, *q;
 
-		p = q = cmd._argv[i];
+		p = q = xs.buf[i];
 		for (; *q; q++) {
-			if (!strchr(SHELL_SAFE, *q)) {
+			if (!strchr(_SHELL_SAFE, *q)) {
 				safe = false;
 				break;
 			}
 		}
 
 		if (safe)
-			fputs(p, stream);
+			fputs(p, fp);
 		else {
-			putc('\'', stream);
+			putc('\'', fp);
 			for (q = p; *q; q++) {
 				if (*q == '\'')
-					fputs("'\"'\"'", stream);
+					fputs("'\"'\"'", fp);
 				else
-					putc(*q, stream);
+					putc(*q, fp);
 			}
-			putc('\'', stream);
+			putc('\'', fp);
 		}
 
-		putc(i == cmd._len - 1 ? '\n' : ' ', stream);
+		putc(i == xs.len - 1 ? '\n' : ' ', fp);
 	}
-	funlockfile(stream);
+	funlockfile(fp);
 }
 
-void
-env_or_defaultv(struct strv *sv, const char *s, char **p, size_t n)
+bool
+pcquery(struct strs *xs, const char *lib, int flags)
 {
-	wordexp_t we;
-	const char *ev;
-
-	if ((ev = getenv(s)) && *ev) {
-		switch (wordexp(ev, &we, WRDE_NOCMD)) {
-		case WRDE_BADCHAR:
-		case WRDE_BADVAL:
-		case WRDE_SYNTAX:
-			errno = EINVAL;
-			die("wordexp");
-		case WRDE_NOSPACE:
-			errno = ENOMEM;
-			die("wordexp");
-		}
+	struct strs ys = {0};
+
+	strspushl(&ys, "pkg-config", "--silence-errors");
+	if (flags & PC_CFLAGS)
+		strspushl(&ys, "--cflags");
+	if (flags & PC_LIBS)
+		strspushl(&ys, "--libs");
+	if (flags & PC_SHARED)
+		strspushl(&ys, "--shared");
+	if (flags & PC_STATIC)
+		strspushl(&ys, "--static");
+	strspushl(&ys, (char *)lib);
 
-		p = we.we_wordv;
-		n = we.we_wordc;
-	} else if (!n || !*p)
-		return;
-
-	sv->buf = bufalloc(sv->buf, sv->len + n, sizeof(*sv->buf));
-	for (size_t i = 0; i < n; i++) {
-		if (!(sv->buf[sv->len + i] = strdup(p[i])))
-			die("strdup");
-	}
-	sv->len += n;
-
-	if (ev && *ev)
-		wordfree(&we);
-}
+	char *buf;
+	size_t bufsz;
+	int ec = cmdexec_read(ys, &buf, &bufsz);
+	strsfree(&ys);
+	if (ec != EXIT_SUCCESS)
+		return false;
 
-bool
-fexists(const char *f)
-{
-	return !access(f, F_OK);
-}
+	/* Remove trailing newline */
+	buf[bufsz - 1] = 0;
 
-int
-fmdcmp(const char *lhs, const char *rhs)
-{
-	struct stat sbl, sbr;
+	wordexp_t we;
+	assert(wordexp(buf, &we, WRDE_NOCMD) == 0);
 
-	if (stat(lhs, &sbl) == -1)
-		die("%s", lhs);
-	if (stat(rhs, &sbr) == -1)
-		die("%s", rhs);
+	char **words = malloc(sizeof(char *) * we.we_wordc);
+	assert(words != NULL);
+	for (size_t i = 0; i < we.we_wordc; i++)
+		assert((words[i] = strdup(we.we_wordv[i])) != NULL);
 
-	return sbl.st_mtim.tv_sec == sbr.st_mtim.tv_sec
-	         ? sbl.st_mtim.tv_nsec - sbr.st_mtim.tv_nsec
-	         : sbl.st_mtim.tv_sec - sbr.st_mtim.tv_sec;
+	strspush(xs, words, we.we_wordc);
+	wordfree(&we);
+	free(buf);
+	return true;
 }
 
 bool
-fmdnewer(const char *lhs, const char *rhs)
+binexists(const char *s)
 {
-	return fmdcmp(lhs, rhs) > 0;
-}
+	const char *path = getenv("PATH");
+	assert(path != NULL);
 
-bool
-fmdolder(const char *lhs, const char *rhs)
-{
-	return fmdcmp(lhs, rhs) < 0;
-}
+	char *p = strdup(path), *it;
+	assert(p != NULL);
 
-bool
-foutdatedv(const char *src, const char **deps, size_t n)
-{
-	if (!fexists(src))
-		return true;
-	for (size_t i = 0; i < n; i++) {
-		if (fmdolder(src, deps[i]))
+	for (it = strtok(p, ":"); it != NULL; it = strtok(NULL, ":")) {
+		static char buf[PATH_MAX];
+		memset(buf, 0, sizeof(buf));
+		snprintf(buf, sizeof(buf), "%s/%s", it, s);
+		if (fexists(buf)) {
+			free(p);
 			return true;
+		}
 	}
-	return false;
-}
-
-void
-_rebuild(char *src)
-{
-	char *bbn, *sbn, *argv0;
-	cmd_t cmd = {0};
-	size_t bufsiz;
-
-	/* We assume that the compiled binary and the source file are in the same
-	   directory. */
-	if (sbn = strrchr(src, '/'))
-		sbn++;
-	else
-		sbn = src;
-	if (bbn = strrchr(*_cbs_argv, '/'))
-		bbn++;
-	else
-		bbn = src;
-
-	if (!foutdated(bbn, sbn))
-		return;
-
-	cmdadd(&cmd, "cc");
-#ifdef CBS_PTHREAD
-	cmdadd(&cmd, "-lpthread");
-#endif
-	cmdadd(&cmd, "-o", bbn, sbn);
-	cmdput(cmd);
-	if (cmdexec(cmd))
-		diex("Compilation of build script failed");
-
-	cmdclr(&cmd);
 
-	argv0 = bufalloc(nullptr, strlen(bbn) + 3, 1);
-	*_cbs_argv = argv0;
-
-	*argv0++ = '.';
-	*argv0++ = '/';
-	strcpy(argv0, bbn);
-
-	cmdaddv(&cmd, _cbs_argv, _cbs_argc);
-	execvp(*cmd._argv, cmd._argv);
-	die("execvp: %s", *cmd._argv);
+	free(p);
+	return false;
 }
 
 int
@@ -766,181 +466,141 @@ nproc(void)
 #endif
 }
 
-bool
-pcquery(struct strv *vec, char *lib, int flags)
+char *
+swpext(const char *file, const char *ext)
 {
-	int ec;
-	char *p;
-	size_t n;
-	cmd_t c = {0};
-	wordexp_t we;
-
-	p = nullptr;
-
-	cmdadd(&c, "pkg-config");
-	if (flags & PKGC_LIBS)
-		cmdadd(&c, "--libs");
-	if (flags & PKGC_CFLAGS)
-		cmdadd(&c, "--cflags");
-	cmdadd(&c, lib);
-
-	if ((ec = cmdexecb(c, &p, &n))) {
-		if (errno == ENOENT) {
-			free(c._argv);
-			return false;
-		}
-		diex("pkg-config terminated with exit-code %d", ec);
+	const char *p = strrchr(file, '.');
+	if (p == NULL) {
+		p = strdup(file);
+		assert(p != NULL);
+		return (char *)p;
 	}
 
-	if (!p)
-		return true;
+	size_t noextlen = p - file;
+	char *s = malloc(noextlen + strlen(ext) + 2);
+	assert(s != NULL);
+	sprintf(s, "%.*s.%s", (int)noextlen, file, ext);
+	return s;
+}
 
-	/* Remove trailing newline */
-	p[n - 1] = 0;
-
-	switch (wordexp(p, &we, WRDE_NOCMD)) {
-	case WRDE_BADCHAR:
-	case WRDE_BADVAL:
-	case WRDE_SYNTAX:
-		errno = EINVAL;
-		die("wordexp");
-	case WRDE_NOSPACE:
-		errno = ENOMEM;
-		die("wordexp");
-	}
+#ifndef CBS_NO_THREADS
+static struct _tqueue *
+_tpdeq(tpool *tp)
+{
+	struct _tqueue *q = tp->head;
 
-	vec->buf = bufalloc(vec->buf, vec->len + we.we_wordc, sizeof(char *));
-	for (size_t i = 0; i < we.we_wordc; i++) {
-		char *p = strdup(we.we_wordv[i]);
-		if (!p)
-			die(__func__);
-		vec->buf[vec->len++] = p;
+	if (q != NULL) {
+		tp->head = tp->head->next;
+		if (!tp->head)
+			tp->tail = NULL;
 	}
 
-	wordfree(&we);
-	free(p);
-	return true;
+	return q;
 }
 
-#ifdef CBS_PTHREAD
-
 static void *
 _tpwork(void *arg)
 {
-	tpool_t *tp = arg;
+	tpool *tp = arg;
 
-	while (!tp->_stop) {
-		struct _tjob *j;
+	while (!tp->stop) {
+		struct _tqueue *q;
 
-		pthread_mutex_lock(&tp->_mtx);
-		while (!tp->_stop && !tp->_head)
-			pthread_cond_wait(&tp->_cnd, &tp->_mtx);
-		if (tp->_stop) {
-			pthread_mutex_unlock(&tp->_mtx);
+		pthread_mutex_lock(&tp->mtx);
+		while (!tp->stop && !tp->head)
+			pthread_cond_wait(&tp->cnd, &tp->mtx);
+		if (tp->stop) {
+			pthread_mutex_unlock(&tp->mtx);
 			break;
 		}
 
-		j = _tpdeq(tp);
-		pthread_mutex_unlock(&tp->_mtx);
+		q = _tpdeq(tp);
+		pthread_mutex_unlock(&tp->mtx);
 
-		j->fn(j->arg);
-		if (j->free)
-			j->free(j->arg);
-		free(j);
+		q->fn(q->arg);
+		if (q->free)
+			q->free(q->arg);
+		free(q);
 
-		pthread_mutex_lock(&tp->_mtx);
-		tp->_left--;
-		pthread_cond_broadcast(&tp->_cnd);
-		pthread_mutex_unlock(&tp->_mtx);
+		pthread_mutex_lock(&tp->mtx);
+		tp->left--;
+		pthread_cond_broadcast(&tp->cnd);
+		pthread_mutex_unlock(&tp->mtx);
 	}
 
-	return nullptr;
+	return NULL;
 }
 
 void
-tpinit(tpool_t *tp, size_t n)
+tpinit(tpool *tp, size_t n)
 {
-	tp->_tcnt = n;
-	tp->_stop = false;
-	tp->_left = 0;
-	tp->_head = tp->_tail = nullptr;
-	tp->_thrds = bufalloc(nullptr, n, sizeof(pthread_t));
-	pthread_cond_init(&tp->_cnd, nullptr);
-	pthread_mutex_init(&tp->_mtx, nullptr);
-
+	tp->tcnt = n;
+	tp->stop = false;
+	tp->left = 0;
+	tp->head = tp->tail = NULL;
+	tp->thrds = malloc(sizeof(pthread_t) * n);
+	assert(tp->thrds != NULL);
+	pthread_cond_init(&tp->cnd, NULL);
+	pthread_mutex_init(&tp->mtx, NULL);
 	for (size_t i = 0; i < n; i++)
-		pthread_create(tp->_thrds + i, nullptr, _tpwork, tp);
+		assert(pthread_create(tp->thrds + i, NULL, _tpwork, tp) == 0);
 }
 
 void
-tpfree(tpool_t *tp)
+tpfree(tpool *tp)
 {
-	tp->_stop = true;
+	tp->stop = true;
 
-	pthread_mutex_lock(&tp->_mtx);
-	pthread_cond_broadcast(&tp->_cnd);
-	pthread_mutex_unlock(&tp->_mtx);
+	pthread_mutex_lock(&tp->mtx);
+	pthread_cond_broadcast(&tp->cnd);
+	pthread_mutex_unlock(&tp->mtx);
 
-	for (size_t i = 0; i < tp->_tcnt; i++)
-		pthread_join(tp->_thrds[i], nullptr);
+	for (size_t i = 0; i < tp->tcnt; i++)
+		pthread_join(tp->thrds[i], NULL);
 
-	free(tp->_thrds);
-	while (tp->_head) {
-		struct _tjob *j = _tpdeq(tp);
-		if (j->free)
-			j->free(j->arg);
-		free(j);
+	free(tp->thrds);
+	while (tp->head != NULL) {
+		struct _tqueue *q = _tpdeq(tp);
+		if (q->free)
+			q->free(q->arg);
+		free(q);
 	}
 
-	pthread_cond_destroy(&tp->_cnd);
-	pthread_mutex_destroy(&tp->_mtx);
+	pthread_cond_destroy(&tp->cnd);
+	pthread_mutex_destroy(&tp->mtx);
 }
 
-struct _tjob *
-_tpdeq(tpool_t *tp)
+void
+tpwait(tpool *tp)
 {
-	struct _tjob *j = tp->_head;
-
-	if (j) {
-		tp->_head = tp->_head->next;
-		if (!tp->_head)
-			tp->_tail = nullptr;
-	}
-
-	return j;
+	pthread_mutex_lock(&tp->mtx);
+	while (!tp->stop && tp->left)
+		pthread_cond_wait(&tp->cnd, &tp->mtx);
+	pthread_mutex_unlock(&tp->mtx);
 }
 
 void
-tpenq(tpool_t *tp, tfunc_t fn, void *arg, tfree_func_t free)
+tpenq(tpool *tp, tjob *fn, void *arg, tjob_free *free)
 {
-	struct _tjob *j = bufalloc(nullptr, 1, sizeof(struct _tjob));
-	*j = (struct _tjob){
+	struct _tqueue *q = malloc(sizeof(*q));
+	assert(q != NULL);
+	*q = (struct _tqueue){
 		.fn = fn,
 		.arg = arg,
 		.free = free,
 	};
 
-	pthread_mutex_lock(&tp->_mtx);
-	if (tp->_tail)
-		tp->_tail->next = j;
-	if (!tp->_head)
-		tp->_head = j;
-	tp->_tail = j;
-	tp->_left++;
-	pthread_cond_signal(&tp->_cnd);
-	pthread_mutex_unlock(&tp->_mtx);
+	pthread_mutex_lock(&tp->mtx);
+	if (tp->tail)
+		tp->tail->next = q;
+	if (!tp->head)
+		tp->head = q;
+	tp->tail = q;
+	tp->left++;
+	pthread_cond_signal(&tp->cnd);
+	pthread_mutex_unlock(&tp->mtx);
 }
-
-void
-tpwait(tpool_t *tp)
-{
-	pthread_mutex_lock(&tp->_mtx);
-	while (!tp->_stop && tp->_left)
-		pthread_cond_wait(&tp->_cnd, &tp->_mtx);
-	pthread_mutex_unlock(&tp->_mtx);
-}
-
-#endif /* CBS_PTHREAD */
+#endif /* !CBS_NO_THREADS */
 
 #ifdef __GNUC__
 #	pragma GCC diagnostic pop