aboutsummaryrefslogtreecommitdiff
path: root/vendor/librune/cbs.h
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/librune/cbs.h')
-rw-r--r--vendor/librune/cbs.h939
1 files changed, 939 insertions, 0 deletions
diff --git a/vendor/librune/cbs.h b/vendor/librune/cbs.h
new file mode 100644
index 0000000..bcf82df
--- /dev/null
+++ b/vendor/librune/cbs.h
@@ -0,0 +1,939 @@
+/* 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.
+
+ There are a few exceptions to the above rule, and they are documented.
+
+ This library does not aim to ever support Windows */
+
+#ifndef C_BUILD_SYSTEM_H
+#define C_BUILD_SYSTEM_H
+
+#ifdef __GNUC__
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wunused-function"
+#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
+
+#include <sys/stat.h>
+#include <sys/wait.h>
+
+#include <errno.h>
+#include <libgen.h>
+#include <limits.h>
+#ifdef CBS_PTHREAD
+# include <pthread.h>
+#endif
+#include <stdarg.h>
+#include <stdint.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
+
+/* 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 <stdnoreturn.h>
+#endif
+
+/* 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 {
+ char **buf;
+ size_t len;
+};
+
+/* 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. */
+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;
+
+/* Returns whether or not a binary of the given name exists in the users
+ environment as defined by $PATH. */
+static bool binexists(const char *);
+
+/* 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);
+
+/* 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 *);
+
+/* 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. */
+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);
+
+/* 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.
+
+ If PKGC_CFLAGS is specified, call pkg-config with ‘--cflags’.
+ If PKGC_LIBS is specified, call pkg-config with ‘--libs’.
+
+ 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,
+};
+
+#ifdef CBS_PTHREAD
+
+/* 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 *);
+
+/* A tfunc_free_t represents a function which frees the argument passed to a
+ tfunc_t function. */
+typedef void (*tfree_func_t)(void *);
+
+/* A thread pool job queue. Meant for internal-use only. */
+struct _tjob {
+ void *arg;
+ tfunc_t fn;
+ tfree_func_t free;
+ struct _tjob *next;
+};
+
+/* 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 */
+
+void
+strvfree(struct strv *v)
+{
+ free(v->buf);
+ *v = (struct strv){0};
+}
+
+void *
+bufalloc(void *p, size_t n, size_t m)
+{
+ if (n && SIZE_MAX / n < m) {
+ errno = EOVERFLOW;
+ die(__func__);
+ }
+
+ if (!(p = realloc(p, n * m)))
+ die(__func__);
+ return p;
+}
+
+void
+die(const char *fmt, ...)
+{
+ 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);
+}
+
+void
+diex(const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ flockfile(stderr);
+ fprintf(stderr, "%s: ", *_cbs_argv);
+ vfprintf(stderr, fmt, ap);
+ fputc('\n', stderr);
+ exit(EXIT_FAILURE);
+}
+
+void
+cbsinit(int argc, char **argv)
+{
+ _cbs_argc = argc;
+ _cbs_argv = bufalloc(NULL, 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);
+ }
+ }
+}
+
+static size_t
+_next_powerof2(size_t n)
+{
+ if (n && !(n & (n - 1)))
+ return n;
+
+ n--;
+ for (size_t i = 1; i < sizeof(size_t); i <<= 1)
+ n |= n >> i;
+ return n + 1;
+}
+
+bool
+binexists(const char *name)
+{
+ char *p, *path;
+
+ if (!(path = getenv("PATH")))
+ diex("PATH environment variable not found");
+
+ 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;
+ }
+
+ p = strtok(NULL, ":");
+ }
+
+ free(path);
+ return false;
+}
+
+void
+cmdaddv(cmd_t *cmd, char **xs, size_t n)
+{
+ if (cmd->_len + n >= cmd->_cap) {
+ cmd->_cap = _next_powerof2(cmd->_len + n) + 2;
+ cmd->_argv = bufalloc(cmd->_argv, cmd->_cap, sizeof(char *));
+ }
+
+ memcpy(cmd->_argv + cmd->_len, xs, n * sizeof(*xs));
+ cmd->_len += n;
+ cmd->_argv[cmd->_len] = NULL;
+}
+
+void
+cmdclr(cmd_t *c)
+{
+ c->_len = 0;
+ *c->_argv = NULL;
+}
+
+int
+cmdexec(cmd_t c)
+{
+ return cmdwait(cmdexeca(c));
+}
+
+pid_t
+cmdexeca(cmd_t c)
+{
+ pid_t pid;
+
+ switch (pid = fork()) {
+ case -1:
+ die("fork");
+ case 0:
+ execvp(*c._argv, c._argv);
+ die("execvp: %s", *c._argv);
+ }
+
+ return pid;
+}
+
+int
+cmdexecb(cmd_t c, char **p, size_t *n)
+{
+ enum {
+ FD_R,
+ FD_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);
+ }
+
+ close(fds[FD_W]);
+
+ buf = NULL;
+ len = 0;
+
+ 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)
+ break;
+ buf = bufalloc(buf, len + nr + 1, sizeof(char));
+ memcpy(buf + len, tmp, nr);
+ len += nr;
+ }
+
+ close(fds[FD_R]);
+ if (buf)
+ buf[len] = 0;
+ *p = buf;
+ *n = len;
+ 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;
+ }
+}
+
+/* import shlex
+
+ s = '#define SHELL_SAFE "'
+ for c in map(chr, range(128)):
+ if not shlex._find_unsafe(c):
+ s += c
+ print(s + '"') */
+#define SHELL_SAFE \
+ "%+,-./0123456789:=@ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"
+
+void
+cmdput(cmd_t c)
+{
+ cmdputf(stdout, c);
+}
+
+void
+cmdputf(FILE *stream, cmd_t cmd)
+{
+ flockfile(stream);
+ for (size_t i = 0; i < cmd._len; i++) {
+ bool safe = true;
+ char *p, *q;
+
+ p = q = cmd._argv[i];
+ for (; *q; q++) {
+ if (!strchr(SHELL_SAFE, *q)) {
+ safe = false;
+ break;
+ }
+ }
+
+ if (safe)
+ fputs(p, stream);
+ else {
+ putc('\'', stream);
+ for (q = p; *q; q++) {
+ if (*q == '\'')
+ fputs("'\"'\"'", stream);
+ else
+ putc(*q, stream);
+ }
+ putc('\'', stream);
+ }
+
+ putc(i == cmd._len - 1 ? '\n' : ' ', stream);
+ }
+ funlockfile(stream);
+}
+
+void
+env_or_defaultv(struct strv *sv, const char *s, char **p, size_t n)
+{
+ 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");
+ }
+
+ p = we.we_wordv;
+ n = we.we_wordc;
+ } else if (!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);
+}
+
+bool
+fexists(const char *f)
+{
+ return !access(f, F_OK);
+}
+
+int
+fmdcmp(const char *lhs, const char *rhs)
+{
+ struct stat sbl, sbr;
+
+ if (stat(lhs, &sbl) == -1)
+ die("%s", lhs);
+ if (stat(rhs, &sbr) == -1)
+ die("%s", rhs);
+
+ 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;
+}
+
+bool
+fmdnewer(const char *lhs, const char *rhs)
+{
+ return fmdcmp(lhs, rhs) > 0;
+}
+
+bool
+fmdolder(const char *lhs, const char *rhs)
+{
+ return fmdcmp(lhs, rhs) < 0;
+}
+
+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]))
+ return true;
+ }
+ return false;
+}
+
+static char *
+_getcwd(void)
+{
+ char *buf = NULL;
+ size_t n = 0;
+
+ for (;;) {
+ n += PATH_MAX;
+ buf = bufalloc(buf, n, sizeof(char));
+ if (getcwd(buf, n))
+ break;
+ if (errno != ERANGE)
+ die("getcwd");
+ }
+
+ return buf;
+}
+
+void
+_rebuild(char *src)
+{
+ char *cwd, *cpy1, *cpy2, *dn, *bn;
+ cmd_t cmd = {0};
+
+ cwd = _getcwd();
+ if (!(cpy1 = strdup(*_cbs_argv)))
+ die("strdup");
+ if (!(cpy2 = strdup(*_cbs_argv)))
+ die("strdup");
+ dn = dirname(cpy1);
+ bn = basename(cpy2);
+
+ if (chdir(dn) == -1)
+ die("chdir: %s", dn);
+ if (!foutdated(bn, src)) {
+ if (chdir(cwd) == -1)
+ die("chdir: %s", cwd);
+ free(cpy1);
+ free(cpy2);
+ free(cwd);
+ return;
+ }
+
+ cmdadd(&cmd, "cc");
+#ifdef CBS_PTHREAD
+ cmdadd(&cmd, "-lpthread");
+#endif
+ cmdadd(&cmd, "-o", bn, src);
+ cmdput(cmd);
+ if (cmdexec(cmd))
+ diex("Compilation of build script failed");
+
+ cmdclr(&cmd);
+
+ if (chdir(cwd) == -1)
+ die("chdir: %s", cwd);
+
+ cmdaddv(&cmd, _cbs_argv, _cbs_argc);
+ execvp(*cmd._argv, cmd._argv);
+ die("execvp: %s", *cmd._argv);
+}
+
+int
+nproc(void)
+{
+#ifdef _SC_NPROCESSORS_ONLN
+ return (int)sysconf(_SC_NPROCESSORS_ONLN);
+#else
+ errno = 0;
+ return -1;
+#endif
+}
+
+bool
+pcquery(struct strv *vec, char *lib, int flags)
+{
+ int ec;
+ char *p;
+ size_t n;
+ cmd_t c = {0};
+ wordexp_t we;
+
+ p = NULL;
+
+ 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);
+ }
+
+ if (!p)
+ return true;
+
+ /* 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");
+ }
+
+ 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;
+ }
+
+ wordfree(&we);
+ free(p);
+ return true;
+}
+
+#ifdef CBS_PTHREAD
+
+static void *
+_tpwork(void *arg)
+{
+ tpool_t *tp = arg;
+
+ while (!tp->_stop) {
+ struct _tjob *j;
+
+ 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);
+
+ j->fn(j->arg);
+ if (j->free)
+ j->free(j->arg);
+ free(j);
+
+ pthread_mutex_lock(&tp->_mtx);
+ tp->_left--;
+ pthread_cond_broadcast(&tp->_cnd);
+ pthread_mutex_unlock(&tp->_mtx);
+ }
+
+ return NULL;
+}
+
+void
+tpinit(tpool_t *tp, size_t n)
+{
+ tp->_tcnt = n;
+ tp->_stop = false;
+ tp->_left = 0;
+ tp->_head = tp->_tail = NULL;
+ tp->_thrds = bufalloc(NULL, n, sizeof(pthread_t));
+ 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, NULL, _tpwork, tp);
+}
+
+void
+tpfree(tpool_t *tp)
+{
+ tp->_stop = true;
+
+ 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], NULL);
+
+ free(tp->_thrds);
+ while (tp->_head) {
+ struct _tjob *j = _tpdeq(tp);
+ if (j->free)
+ j->free(j->arg);
+ free(j);
+ }
+
+ pthread_cond_destroy(&tp->_cnd);
+ pthread_mutex_destroy(&tp->_mtx);
+}
+
+struct _tjob *
+_tpdeq(tpool_t *tp)
+{
+ struct _tjob *j = tp->_head;
+
+ if (j) {
+ tp->_head = tp->_head->next;
+ if (!tp->_head)
+ tp->_tail = NULL;
+ }
+
+ return j;
+}
+
+void
+tpenq(tpool_t *tp, tfunc_t fn, void *arg, tfree_func_t free)
+{
+ struct _tjob *j = bufalloc(NULL, 1, sizeof(struct _tjob));
+ *j = (struct _tjob){
+ .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);
+}
+
+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 */
+
+#ifdef __GNUC__
+# pragma GCC diagnostic pop
+#endif
+
+#ifdef __APPLE__
+# undef st_mtim
+#endif
+
+#endif /* !C_BUILD_SYSTEM_H */