Completely revamp the grab source code

Some of the (many) few changes are:
- Multithreading for significantly faster performance
- The -p/--predicate flag
- Byte offsets as the default
- No customizable colors (maybe this will come back later)
- Newer edition of mlib (formerly librune)

9 files changed, 1019 insertions, 980 deletions

diff --git a/src/da.h b/src/da.h
deleted file mode 100644
index 8891971..0000000
--- a/src/da.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Simple & stupid dynamic array single-header implementation.  You can use the
- * macros defined in this file with any structure that has the following fields:
- *
- *  struct dyn_array {
- *      T *buf  // Array of items
- *      N  len  // Length of array
- *      N  cap  // Capacity of array
- *  }
- *
- * The type ‘T’ is whatever type you want to store.  The type ‘N’ is any numeric
- * type — most likely ‘size_t’ — but it could be sized as well.
- *
- * The daremove() macro also doesn’t bother with shrinking your array when the
- * length is far lower than the capacity.  If you care about that, do it
- * yourself.
- *
- * Remember to call free() on your dynamic arrays ‘buf’ field after use.
- *
- *
- * Macro Overview
- * ――――――――――――――
- * The argument ‘a’ to all of the below macros is a pointer to the dynamic array
- * structure.
- *
- * dainit(a, n)              Initialize the array with a capacity of ‘n’ items.
- * dapush(a, x)              Append the item ‘x’ to the array
- * daremove(a, x)            Remove the item at index ‘x’ from the array
- * da_remove_range(a, x, y)  Remove the items between the range [x, y)
- * da_foreach(a, p)          Iterate the pointer ‘p’ over each element of the
- *                           array.  The type of ‘p’ is inferred.
- *
- * The ‘dapush()’ macro will double the arrays capacity when it gets full.  If
- * you would like your arrays to grow with a different scale, edit this file.
- *
- *
- * Example
- * ―――――――
- *
- * struct {
- *     int *buf;
- *     size_t len, cap;
- * } nums;
- *
- * // Initialize nums with capacity == 4
- * dainit(&nums, 4);
- *
- * // Append 69, 1337, and 420 to nums
- * dapush(&nums, 69);
- * dapush(&nums, 1337);
- * dapush(&nums, 420);
- *
- * da_foreach (&nums, n) {
- *     int x = *n << 1;
- *     printf("n = %d; n² = %d\n", *n, x);
- * }
- *
- * // Remove 1337 and 420 from nums
- * da_remove_range(&nums, 1, 3);
- *
- * // Remove 69 from nums
- * daremove(&nums, 0);
- */
-
-#ifndef MANGO_DA_H
-#define MANGO_DA_H
-
-#include <err.h>
-#include <errno.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-#if __STDC_VERSION__ >= 202311L
-#	define DA_NULL nullptr
-#else
-#	define DA_NULL NULL
-#endif
-
-#define DA_ALLOC(p, n) \
-	do { \
-		if ((n) && SIZE_MAX / (n) < sizeof(*(p))) { \
-			errno = EOVERFLOW; \
-			err(EXIT_FAILURE, "realloc"); \
-		} \
-		if (!((p) = realloc((p), (n) * sizeof(*(p))))) \
-			err(EXIT_FAILURE, "realloc"); \
-	} while (0)
-
-#define dainit(a, n) \
-	do { \
-		(a)->buf = DA_NULL; \
-		(a)->cap = (n); \
-		(a)->len = 0; \
-		if (n) \
-			DA_ALLOC((a)->buf, (a)->cap); \
-	} while (0)
-
-#define dapush(a, x) \
-	do { \
-		if ((a)->len >= (a)->cap) { \
-			(a)->cap = (a)->cap ? (a)->cap * 2 : 1; \
-			DA_ALLOC((a)->buf, (a)->cap); \
-		} \
-		(a)->buf[(a)->len++] = (x); \
-	} while (0)
-
-#define daremove(a, i) da_remove_range((a), (i), (i) + 1)
-
-#define da_remove_range(a, i, j) \
-	do { \
-		memmove((a)->buf + (i), (a)->buf + (j), \
-		        ((a)->len - (j)) * sizeof(*(a)->buf)); \
-		(a)->len -= j - i; \
-	} while (0)
-
-#define da_foreach(a, p) \
-	for (typeof((a)->buf) p = (a)->buf; (size_t)(p - (a)->buf) < (a)->len; p++)
-
-#endif /* !MANGO_DA_H */
diff --git a/src/exitcodes.h b/src/exitcodes.h
new file mode 100644
index 0000000..00b455c
--- /dev/null
+++ b/src/exitcodes.h
@@ -0,0 +1,9 @@
+#ifndef GRAB_EXITCODES_H
+#define GRAB_EXITCODES_H
+
+/* These values should never be changed!  Scripts may depend on them. */
+constexpr int EXIT_NOMATCH = 1;
+constexpr int EXIT_WARNING = 2;
+constexpr int EXIT_FATAL = 3;
+
+#endif /* !GRAB_EXITCODES_H */
diff --git a/src/flags.h b/src/flags.h
new file mode 100644
index 0000000..a4a4709
--- /dev/null
+++ b/src/flags.h
@@ -0,0 +1,23 @@
+#ifndef GRAB2_FLAGS_H
+#define GRAB2_FLAGS_H
+
+typedef struct {
+	bool c : 1;
+	bool i : 1;
+	bool l : 1;
+	bool p : 1;
+	bool s : 1;
+	bool U : 1;
+	bool z : 1;
+
+#if !GIT_GRAB
+	bool do_header : 1;
+#endif
+} flags_t;
+
+#if !MAIN_C
+extern
+#endif
+flags_t flags;
+
+#endif /* !GRAB2_FLAGS_H */
diff --git a/src/grab.c b/src/grab.c
deleted file mode 100644
index bf26a79..0000000
--- a/src/grab.c
+++ /dev/null
@@ -1,859 +0,0 @@
-#include <err.h>
-#include <getopt.h>
-#include <libgen.h>
-#include <limits.h>
-#include <locale.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#if GRAB_DO_PCRE
-#	include <pcre2posix.h>
-#else
-#	include <regex.h>
-#	ifndef REG_DOTALL
-#		define REG_DOTALL 0
-#	endif
-#	define REG_UCP 0
-#	define REG_UTF 0
-#	ifndef REG_STARTEND
-#		error "REG_STARTEND not defined"
-#	endif
-#endif
-
-#include <gbrk.h>
-#include <rune.h>
-#include <utf8.h>
-
-#include "da.h"
-
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
-#define MAX(a, b) ((a) > (b) ? (a) : (b))
-
-#define FLAGMSK(f) ((uint64_t)1 << ((f) - ((f) < 'a' ? 'A' : 'G')))
-#define FLAGSET(f) (flags & FLAGMSK(f))
-
-#define lengthof(a) (sizeof(a) / sizeof(*(a)))
-
-#define die(...)  err(3, __VA_ARGS__)
-#define diex(...) errx(3, __VA_ARGS__)
-#define warn(...) \
-	do { \
-		warn(__VA_ARGS__); \
-		rv = 3; \
-	} while (0)
-#define warnx(...) \
-	do { \
-		warnx(__VA_ARGS__); \
-		rv = 3; \
-	} while (0)
-
-#define streq(a, b)    (!strcmp(a, b))
-#define memeq(a, b, n) (!memcmp(a, b, n))
-
-#define DEFCOL_FN "35"
-#define DEFCOL_HL "01;31"
-#define DEFCOL_LN "32"
-#define DEFCOL_SE "36"
-
-struct matches {
-	struct sv *buf;
-	size_t len, cap;
-};
-
-struct op {
-	char c;
-	regex_t pat;
-#ifdef GRAB_DEBUG
-	bool alloced;
-#endif
-};
-
-struct ops {
-	struct op *buf;
-	size_t len, cap;
-};
-
-struct sv {
-	char8_t *p;
-	size_t len;
-};
-
-typedef unsigned char uchar;
-typedef void cmd_func(struct sv, struct matches *, struct ops, size_t,
-                      const char *);
-typedef void put_func(struct sv, struct matches *, const char *);
-
-static cmd_func cmdg, cmdh, cmdH, cmdx, cmdX;
-static put_func putm, putm_nc;
-
-#if GIT_GRAB
-static FILE *getfstream(int n, char *v[n]);
-#endif
-static void grab(struct ops, FILE *, const char *);
-static struct ops comppat(char8_t *);
-static regex_t mkregex(char8_t *, size_t);
-static bool islbrk(struct u8view);
-static bool sgrvalid(const char *);
-static bool xisspace(char);
-static int svposcmp(const void *, const void *);
-static char *env_or_default(const char *, const char *);
-
-static int filecnt, rv;
-static bool got_match;
-static uint64_t flags = FLAGMSK('f') * GIT_GRAB;
-static put_func *putf;
-
-static struct {
-	const char8_t *p, *bp;
-	size_t col, row;
-} pos;
-
-static cmd_func *op_table[UCHAR_MAX] = {
-	['g'] = cmdg, ['G'] = cmdg, ['h'] = cmdh,
-	['H'] = cmdH, ['x'] = cmdx, ['X'] = cmdX,
-};
-
-[[noreturn]] static void
-usage(const char *s)
-{
-	fprintf(stderr,
-#if GIT_GRAB
-	        "Usage: %s [-s | -z] [-bcinU] pattern [glob ...]\n"
-#else
-	        "Usage: %s [-s | -z] [-bcfinU] pattern [file ...]\n"
-#endif
-	        "       %s -h\n",
-	        s, s);
-	exit(EXIT_FAILURE);
-}
-
-int
-main(int argc, char **argv)
-{
-	int opt;
-	struct ops ops;
-	struct option longopts[] = {
-		{"byte-offset",   no_argument, nullptr, 'b'},
-		{"color",         no_argument, nullptr, 'c'},
-#if GIT_GRAB
-		{"filenames",     no_argument, nullptr, 'f'},
-#endif
-		{"help",          no_argument, nullptr, 'h'},
-		{"ignore-case",   no_argument, nullptr, 'i'},
-		{"newline",       no_argument, nullptr, 'n'},
-		{"strip-newline", no_argument, nullptr, 's'},
-		{"no-unicode",    no_argument, nullptr, 'U'},
-		{"zero",          no_argument, nullptr, 'z'},
-		{nullptr,         0,           nullptr, 0  },
-	};
-
-#if GIT_GRAB
-	char *entry = nullptr;
-	size_t len;
-	ssize_t nr;
-	FILE *flist;
-	const char *opts = "bchinsUz";
-#else
-	const char *opts = "bcfhinsUz";
-#endif
-
-	argv[0] = basename(argv[0]);
-	if (argc < 2)
-		usage(argv[0]);
-
-	setlocale(LC_ALL, "");
-
-	while ((opt = getopt_long(argc, argv, opts, longopts, nullptr)) != -1) {
-		switch (opt) {
-		case '?':
-			usage(argv[0]);
-		case 'h':
-			execlp("man", "man", "1", argv[0], nullptr);
-			die("execlp: man 1 %s", argv[0]);
-#if !GRAB_DO_PCRE
-		case 'U':
-			errx(2, "program not built with PCRE support");
-#endif
-		default:
-			flags |= FLAGMSK(opt);
-		}
-	}
-
-	if (FLAGSET('s') && FLAGSET('z'))
-		usage(argv[0]);
-
-	argc -= optind;
-	argv += optind;
-	filecnt = argc - 1;
-
-	if (!FLAGSET('c') && isatty(STDOUT_FILENO) == 1
-	    && !env_or_default("NO_COLOR", nullptr))
-	{
-		flags |= FLAGMSK('c') * !streq(env_or_default("TERM", ""), "dumb");
-	}
-
-	putf = FLAGSET('c') ? putm : putm_nc;
-	ops = comppat(argv[0]);
-
-#if GIT_GRAB
-	if (!(flist = getfstream(argc - 1, argv + 1)))
-		die("getfstream");
-	while ((nr = getdelim(&entry, &len, '\0', flist)) > 0) {
-		FILE *fp;
-
-		if (!(fp = fopen(entry, "r")))
-			warn("fopen: %s", entry);
-		else {
-			grab(ops, fp, entry);
-			fclose(fp);
-		}
-	}
-	if (ferror(flist))
-		warn("getdelim");
-	fclose(flist);
-#else
-	if (argc == 1)
-		grab(ops, stdin, "-");
-	else {
-		for (int i = 1; i < argc; i++) {
-			FILE *fp;
-
-			if (streq(argv[i], "-")) {
-				grab(ops, stdin, "-");
-			} else if (!(fp = fopen(argv[i], "r"))) {
-				warn("fopen: %s", argv[i]);
-			} else {
-				grab(ops, fp, argv[i]);
-				fclose(fp);
-			}
-		}
-	}
-#endif
-
-#ifdef GRAB_DEBUG
-#	if GIT_GRAB
-	free(entry);
-#	endif
-	da_foreach (&ops, op) {
-		if (op->alloced)
-			regfree(&op->pat);
-	}
-	free(ops.buf);
-#endif
-
-	return got_match ? rv : EXIT_FAILURE;
-}
-
-struct ops
-comppat(char8_t *s)
-{
-	struct ops ops;
-
-	dainit(&ops, 8);
-	while (*s && xisspace(*s))
-		s++;
-	if (!*s)
-		diex("input string terminated prematurely");
-
-	do {
-		int w;
-		rune ch;
-		size_t len;
-		char8_t *p;
-		struct op op;
-
-		/* Grab the operator and delimiter.  All operators are ASCII, but
-		   u8tor() is used to parse it so that we get properly formed error
-		   messages when someone uses a non-ASCII operator. */
-		w = u8tor(&ch, s);
-		if (ch == RUNE_ERROR)
-			diex("invalid UTF-8 sequence near ‘%02hhX’", s[-1]);
-		if (w > 1 || !op_table[ch])
-			diex("invalid operator ‘%.*s’", w, s);
-		op.c = *s++;
-
-		s += u8tor(&ch, s);
-		if (ch == RUNE_ERROR)
-			diex("invalid UTF-8 sequence near ‘%02hhX’", s[-1]);
-		if (ch == '\0')
-			diex("input string terminated prematurely");
-
-		/* Find the closing delimiter.  The user is allowed to omit the closing
-		   delimiter if this is the last operation in the query pattern. */
-		p = s;
-		len = strlen(s);
-		if (!(s = u8chr(s, ch, len)))
-			s = p + len;
-
-		if (s - p == 0) {
-			if (op.c != 'h')
-				diex("empty regex given to ‘%c’", op.c);
-			if (ops.len == 0)
-				diex("empty ‘h’ is not allowed as the first operator");
-			op.pat = ops.buf[ops.len - 1].pat;
-		} else
-			op.pat = mkregex(p, s - p);
-
-#if GRAB_DEBUG
-		op.alloced = s - p == 0;
-#endif
-
-		dapush(&ops, op);
-
-		if (*s) {
-			s += u8tor(&ch, s);
-			if (ch == RUNE_ERROR)
-				diex("invalid UTF-8 sequence near ‘%02hhX’", s[-1]);
-		}
-		while (*s && xisspace(*s))
-			s++;
-	} while (*s);
-
-	return ops;
-}
-
-void
-grab(struct ops ops, FILE *stream, const char *filename)
-{
-	size_t n;
-	struct {
-		char *buf;
-		size_t len, cap;
-	} chars = {0};
-
-	do {
-		static_assert(sizeof(char) == 1, "sizeof(char) != 1; wtf?");
-		chars.cap += BUFSIZ;
-		if (!(chars.buf = realloc(chars.buf, chars.cap)))
-			die("realloc");
-		chars.len += n = fread(chars.buf + chars.len, 1, BUFSIZ, stream);
-	} while (n == BUFSIZ);
-
-	if (ferror(stream)) {
-		warn("fread: %s", filename);
-		goto out;
-	}
-
-	const char8_t *p;
-	struct sv sv = {
-		.p = chars.buf,
-		.len = chars.len,
-	};
-	struct matches ms;
-
-	if (p = u8chk(chars.buf, chars.len)) {
-		warnx("%s: invalid UTF-8 near ‘%02X’", filename, *p);
-		goto out;
-	}
-
-	dainit(&ms, 4);
-	pos.col = pos.row = 1;
-	pos.bp = pos.p = chars.buf;
-	op_table[(uchar)ops.buf[0].c](sv, &ms, ops, 0, filename);
-	free(ms.buf);
-
-out:
-	free(chars.buf);
-}
-
-void
-cmdg(struct sv sv, struct matches *ms, struct ops ops, size_t i,
-     const char *filename)
-{
-	int r;
-	regmatch_t rm = {
-		.rm_so = 0,
-		.rm_eo = sv.len,
-	};
-	struct op op = ops.buf[i];
-
-	r = regexec(&op.pat, sv.p, 1, &rm, REG_STARTEND);
-	if ((r == REG_NOMATCH && op.c == 'g') || (r != REG_NOMATCH && op.c == 'G'))
-		return;
-
-	if (i + 1 == ops.len)
-		putf(sv, ms, filename);
-	else
-		op_table[(uchar)ops.buf[i + 1].c](sv, ms, ops, i + 1, filename);
-}
-
-void
-cmdh(struct sv sv, struct matches *ms, struct ops ops, size_t i,
-     const char *filename)
-{
-	regmatch_t rm = {
-		.rm_so = 0,
-		.rm_eo = sv.len,
-	};
-	struct op op = ops.buf[i];
-
-	do {
-		if (regexec(&op.pat, sv.p, 1, &rm, REG_STARTEND) == REG_NOMATCH)
-			break;
-
-		if (rm.rm_so < rm.rm_eo)
-			dapush(ms, ((struct sv){sv.p + rm.rm_so, rm.rm_eo - rm.rm_so}));
-		else {
-			rune unused;
-			rm.rm_eo += u8tor_uc(&unused, sv.p + rm.rm_eo);
-		}
-
-		rm = (regmatch_t){
-			.rm_so = rm.rm_eo,
-			.rm_eo = sv.len,
-		};
-	} while (rm.rm_so < rm.rm_eo);
-
-	if (i + 1 == ops.len)
-		putf(sv, ms, filename);
-	else {
-		size_t save = ms->len;
-		op_table[(uchar)ops.buf[i + 1].c](sv, ms, ops, i + 1, filename);
-		ms->len = save;
-	}
-}
-
-void
-cmdH(struct sv sv, struct matches *ms, struct ops ops, size_t i,
-     const char *filename)
-{
-	regmatch_t rm = {
-		.rm_so = 0,
-		.rm_eo = sv.len,
-	};
-	regmatch_t prev = {
-		.rm_so = 0,
-		.rm_eo = 0,
-	};
-	struct op op = ops.buf[i];
-
-	do {
-		struct sv nsv;
-
-		if (regexec(&op.pat, sv.p, 1, &rm, REG_STARTEND) == REG_NOMATCH)
-			break;
-
-		if (prev.rm_so || prev.rm_eo || rm.rm_so) {
-			nsv = (struct sv){
-				.p = sv.p + prev.rm_eo,
-				.len = rm.rm_so - prev.rm_eo,
-			};
-			if (nsv.len)
-				dapush(ms, nsv);
-		}
-
-		prev = rm;
-		if (rm.rm_so == rm.rm_eo) {
-			rune unused;
-			rm.rm_eo += u8tor_uc(&unused, sv.p + rm.rm_eo);
-		}
-		rm = (regmatch_t){
-			.rm_so = rm.rm_eo,
-			.rm_eo = sv.len,
-		};
-	} while (rm.rm_so < rm.rm_eo);
-
-	if (prev.rm_eo < rm.rm_eo)
-		dapush(ms, ((struct sv){sv.p + rm.rm_so, rm.rm_eo - rm.rm_so}));
-
-	if (i + 1 == ops.len)
-		putf(sv, ms, filename);
-	else
-		op_table[(uchar)ops.buf[i + 1].c](sv, ms, ops, i + 1, filename);
-}
-
-void
-cmdx(struct sv sv, struct matches *ms, struct ops ops, size_t i,
-     const char *filename)
-{
-	regmatch_t rm = {
-		.rm_so = 0,
-		.rm_eo = sv.len,
-	};
-	struct op op = ops.buf[i];
-
-	do {
-		struct sv nsv;
-
-		if (regexec(&op.pat, sv.p, 1, &rm, REG_STARTEND) == REG_NOMATCH)
-			break;
-		if (rm.rm_so < rm.rm_eo) {
-			nsv = (struct sv){
-				.p = sv.p + rm.rm_so,
-				.len = rm.rm_eo - rm.rm_so,
-			};
-			if (i + 1 == ops.len)
-				putf(nsv, ms, filename);
-			else {
-				size_t save = ms->len;
-				op_table[(uchar)ops.buf[i + 1].c](nsv, ms, ops, i + 1,
-				                                  filename);
-				ms->len = save;
-			}
-		} else {
-			rune unused;
-			rm.rm_eo += u8tor_uc(&unused, sv.p + rm.rm_eo);
-		}
-		rm = (regmatch_t){
-			.rm_so = rm.rm_eo,
-			.rm_eo = sv.len,
-		};
-	} while (rm.rm_so < rm.rm_eo);
-}
-
-void
-cmdX(struct sv sv, struct matches *ms, struct ops ops, size_t i,
-     const char *filename)
-{
-	regmatch_t rm = {
-		.rm_so = 0,
-		.rm_eo = sv.len,
-	};
-	regmatch_t prev = {
-		.rm_so = 0,
-		.rm_eo = 0,
-	};
-	struct op op = ops.buf[i];
-
-	do {
-		struct sv nsv;
-
-		if (regexec(&op.pat, sv.p, 1, &rm, REG_STARTEND) == REG_NOMATCH)
-			break;
-
-		if (prev.rm_so || prev.rm_eo || rm.rm_so) {
-			nsv = (struct sv){
-				.p = sv.p + prev.rm_eo,
-				.len = rm.rm_so - prev.rm_eo,
-			};
-			if (nsv.len) {
-				if (i + 1 == ops.len)
-					putf(nsv, ms, filename);
-				else
-					op_table[(uchar)ops.buf[i + 1].c](nsv, ms, ops, i + 1,
-					                                  filename);
-			}
-		}
-
-		prev = rm;
-		if (rm.rm_so == rm.rm_eo) {
-			rune unused;
-			rm.rm_eo += u8tor_uc(&unused, sv.p + rm.rm_eo);
-		}
-		rm = (regmatch_t){
-			.rm_so = rm.rm_eo,
-			.rm_eo = sv.len,
-		};
-	} while (rm.rm_so < rm.rm_eo);
-
-	if (prev.rm_eo < rm.rm_eo) {
-		struct sv nsv = {
-			.p = sv.p + rm.rm_so,
-			.len = rm.rm_eo - rm.rm_so,
-		};
-		if (i + 1 == ops.len)
-			putf(nsv, ms, filename);
-		else
-			op_table[(uchar)ops.buf[i + 1].c](nsv, ms, ops, i + 1, filename);
-	}
-}
-
-int
-svposcmp(const void *a, const void *b)
-{
-	struct sv *A, *B;
-	A = (struct sv *)a;
-	B = (struct sv *)b;
-	return A->p != B->p ? A->p - B->p : A->len < B->len ? -1 : A->len != B->len;
-}
-
-void
-putm(struct sv sv, struct matches *ms, const char *filename)
-{
-	const char8_t *p;
-	struct matches valid;
-	static const char *fn, *hl, *ln, *se;
-
-	got_match = true;
-
-	if (FLAGSET('c') && !fn) {
-		char *optstr;
-		if ((optstr = env_or_default("GRAB_COLORS", nullptr))) {
-			enum {
-				OPT_FN,
-				OPT_HL,
-				OPT_LN,
-				OPT_SE,
-			};
-			/* clang-format off */
-			static char *const tokens[] = {
-				[OPT_FN] = "fn",
-				[OPT_HL] = "hl",
-				[OPT_LN] = "ln",
-				[OPT_SE] = "se",
-				nullptr
-			};
-			/* clang-format on */
-
-			while (*optstr) {
-				char *val;
-				switch (getsubopt(&optstr, tokens, &val)) {
-				case OPT_FN:
-					if (sgrvalid(val))
-						fn = val;
-					break;
-				case OPT_HL:
-					if (sgrvalid(val))
-						hl = val;
-					break;
-				case OPT_LN:
-					if (sgrvalid(val))
-						fn = val;
-					break;
-				case OPT_SE:
-					if (sgrvalid(val))
-						se = val;
-					break;
-				default:
-					warnx("invalid color value -- '%s'", val);
-				}
-			}
-		}
-
-		if (!fn)
-			fn = DEFCOL_FN;
-		if (!hl)
-			hl = DEFCOL_HL;
-		if (!ln)
-			ln = DEFCOL_LN;
-		if (!se)
-			se = DEFCOL_SE;
-	}
-
-	if (FLAGSET('f') || filecnt > 1) {
-		char sep = FLAGSET('z') ? '\0' : ':';
-		printf("\33[%sm%s\33[0m"  /* filename */
-		       "\33[%sm%c\33[0m", /* separator */
-		       fn, filename, se, sep);
-
-		if (FLAGSET('b')) {
-			printf("\33[%sm%td\33[0m" /* byte offset */
-			       "\33[%sm%c\33[0m", /* separator */
-			       ln, sv.p - pos.bp, se, sep);
-		} else {
-			struct u8view v;
-			size_t len = sv.p - pos.p;
-
-			while (u8gnext(&v, &pos.p, &len)) {
-				if (islbrk(v)) {
-					pos.col = 1;
-					pos.row++;
-				} else
-					pos.col++;
-			}
-
-			printf("\33[%sm%zu\33[0m" /* row */
-			       "\33[%sm%c\33[0m"  /* separator */
-			       "\33[%sm%zu\33[0m" /* column */
-			       "\33[%sm%c\33[0m", /* separator */
-			       ln, pos.row, se, sep, ln, pos.col, se, sep);
-		}
-	}
-
-	/* Here we need to take all the views of regions to highlight, and try
-	   to merge them into a simpler form.  This happens in two steps:
-
-	   1. Sort the views by their starting position in the matched text.
-	   2. Merge overlapping views.
-
-	   After this process we should have the most reduced possible set of
-	   views.  The next part is to actually print the highlighted regions
-	   possible which requires bounds-checking as highlighted regions may
-	   begin before or end after the matched text when using patterns such
-	   as ‘h/.+/ x/.$/’. */
-
-	dainit(&valid, ms->len);
-	qsort(ms->buf, ms->len, sizeof(*ms->buf), svposcmp);
-	memcpy(valid.buf, ms->buf, ms->len * sizeof(*ms->buf));
-	valid.len = ms->len;
-
-	for (size_t i = 0; i + 1 < valid.len;) {
-		ptrdiff_t d;
-		struct sv *a, *b;
-
-		a = valid.buf + i;
-		b = valid.buf + i + 1;
-		d = a->p + a->len - b->p;
-
-		if (d >= 0) {
-			a->len += MAX(b->len - d, 0);
-			daremove(&valid, i + 1);
-		} else
-			i++;
-	}
-
-	for (size_t i = 0; i < valid.len; i++) {
-		struct sv *m = valid.buf + i;
-		if (m->p + m->len < sv.p || m->p >= sv.p + sv.len) {
-			daremove(&valid, i);
-			i--;
-			continue;
-		}
-
-		if (m->p < sv.p) {
-			m->len -= sv.p - m->p;
-			m->p = sv.p;
-		}
-		m->len = MIN(m->len, (size_t)(sv.p + sv.len - m->p));
-	}
-
-	p = sv.p;
-	da_foreach (&valid, m) {
-		printf("%.*s\33[%sm%.*s\33[0m", (int)(m->p - p), p, hl, (int)m->len,
-		       m->p);
-		p = m->p + m->len;
-	}
-	fwrite(p, 1, sv.p + sv.len - p, stdout);
-
-	if (!(FLAGSET('s') && sv.p[sv.len - 1] == '\n'))
-		putchar(FLAGSET('z') ? '\0' : '\n');
-	free(valid.buf);
-}
-
-void
-putm_nc(struct sv sv, struct matches *ms, const char *filename)
-{
-	(void)ms;
-
-	got_match = true;
-
-	if (FLAGSET('f') || filecnt > 1) {
-		char sep = FLAGSET('z') ? '\0' : ':';
-		printf("%s%c", filename, sep);
-
-		if (FLAGSET('b'))
-			printf("%td%c", sv.p - pos.bp, sep);
-		else {
-			struct u8view v;
-			size_t len = sv.p - pos.p;
-
-			while (u8gnext(&v, &pos.p, &len)) {
-				if (islbrk(v)) {
-					pos.col = 1;
-					pos.row++;
-				} else
-					pos.col++;
-			}
-
-			printf("%zu%c%zu%c", pos.row, sep, pos.col, sep);
-		}
-	}
-	fwrite(sv.p, 1, sv.len, stdout);
-	if (!(FLAGSET('s') && sv.p[sv.len - 1] == '\n'))
-		putchar(FLAGSET('z') ? '\0' : '\n');
-}
-
-bool
-islbrk(struct u8view v)
-{
-	return *v.p == '\n' || (v.len == 2 && memeq(v.p, "\r\n", 2));
-}
-
-bool
-sgrvalid(const char *s)
-{
-	if (!s || !*s)
-		return false;
-	do {
-		if ((*s < '0' || *s > '9') && *s != ';')
-			return false;
-	} while (*++s);
-
-	return true;
-}
-
-regex_t
-mkregex(char8_t *s, size_t n)
-{
-	int ret, cflags;
-	regex_t r;
-	char8_t c = s[n];
-
-	s[n] = 0;
-	cflags = REG_EXTENDED | REG_UTF | (FLAGSET('n') ? REG_NEWLINE : REG_DOTALL);
-	if (FLAGSET('i'))
-		cflags |= REG_ICASE;
-	if (!FLAGSET('U'))
-		cflags |= REG_UCP;
-	if (ret = regcomp(&r, s, cflags)) {
-		char emsg[256];
-		regerror(ret, &r, emsg, sizeof(emsg));
-		diex("failed to compile regex ‘%s’: %s", s, emsg);
-	}
-	s[n] = c;
-
-	return r;
-}
-
-#if GIT_GRAB
-FILE *
-getfstream(int argc, char *argv[argc])
-{
-	pid_t pid;
-	int fds[2];
-	enum {
-		FD_R,
-		FD_W,
-	};
-
-	if (pipe(fds) == -1)
-		die("pipe");
-
-	switch (pid = fork()) {
-	case -1:
-		die("fork");
-	case 0:;
-		size_t len;
-		char **args;
-		static const char *git_grep_args[] = {
-			"git", "grep", "--cached", "-Ilz", "",
-		};
-
-		len = argc + lengthof(git_grep_args) + 1;
-
-		close(fds[FD_R]);
-		if (dup2(fds[FD_W], STDOUT_FILENO) == -1)
-			die("dup2");
-		close(fds[FD_W]);
-
-		if (!(args = malloc(len * sizeof(char *))))
-			die("malloc");
-		memcpy(args, git_grep_args, sizeof(git_grep_args));
-		memcpy(args + 5, argv, argc * sizeof(char *));
-		args[len - 1] = nullptr;
-
-		execvp("git", args);
-		die("execvp: git grep --cached -Ilz ''");
-	}
-
-	close(fds[FD_W]);
-	return fdopen(fds[FD_R], "r");
-}
-#endif
-
-char *
-env_or_default(const char *e, const char *d)
-{
-	const char *s = getenv(e);
-	return (char *)(s && *s ? s : d);
-}
-
-bool
-xisspace(char c)
-{
-	return c == ' ' || c == '\t' || c == '\n';
-}
diff --git a/src/main.c b/src/main.c
new file mode 100644
index 0000000..5b2efff
--- /dev/null
+++ b/src/main.c
@@ -0,0 +1,372 @@
+#include <langinfo.h>
+#include <locale.h>
+#include <stdatomic.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <alloc.h>
+#include <array.h>
+#include <cli.h>
+#include <errors.h>
+#include <macros.h>
+#include <mbstring.h>
+#include <pcre2.h>
+#include <unicode/prop.h>
+#include <unicode/string.h>
+
+#include "exitcodes.h"
+#include "tpool.h"
+#include "work.h"
+
+#define MAIN_C 1
+#include "flags.h"
+
+static bool use_color_p(void);
+static op_t *pattern_comp(u8view_t pat);
+#if GIT_GRAB
+static FILE *getfstream(int globc, char **globv);
+#endif
+
+atomic_int rv = EXIT_NOMATCH;
+op_t *ops;
+/* For use in diagnostic messages */
+const char *lquot = "`", *rquot = "'";
+
+/* We need to use different matching functions depending on if we’re using JIT
+   matching or not */
+typeof(pcre2_match) *pcre2_match_fn;
+
+static char emsg[256]; /* Buffer for PCRE2 error messages */
+/* TODO: Use the LUT in work.c */
+static const bool opchars[] = {
+	['g'] = true,
+	['G'] = true,
+	['h'] = true,
+	['H'] = true,
+	['x'] = true,
+	['X'] = true,
+};
+
+int
+main(int argc, char **argv)
+{
+	mlib_setprogname(argv[0]);
+	setlocale(LC_ALL, "");
+
+	if (streq(nl_langinfo(CODESET), "UTF-8")) {
+		lquot = u8"‘";
+		rquot = u8"’";
+	}
+
+	optparser_t parser = mkoptparser(argv);
+	static const cli_opt_t opts[] = {
+		{'c', U8C("color"),         CLI_NONE},
+		{'h', U8C("help"),          CLI_NONE},
+		{'i', U8C("ignore-case"),   CLI_NONE},
+		{'l', U8C("line"),          CLI_OPT},
+		{'p', U8C("predicate"),     CLI_NONE},
+		{'s', U8C("strip-newline"), CLI_NONE},
+		{'U', U8C("no-unicode"),    CLI_NONE},
+		{'z', U8C("zero"),          CLI_NONE},
+	};
+
+	for (;;) {
+		rune opt = optparse(&parser, opts, lengthof(opts));
+		if (opt == 0)
+			break;
+		switch (opt) {
+		case 'c':
+			flags.c = true;
+			break;
+		case 'h':
+			execlp("man", "man", "1", mlib_progname(), nullptr);
+			err("execlp: man 1 %s:", mlib_progname());
+		case 'i':
+			flags.i = true;
+			break;
+		case 'l':
+			flags.l = true;
+			break;
+		case 'p':
+			flags.p = true;
+			break;
+		case 's':
+			flags.s = true;
+			break;
+		case 'U':
+			flags.U = true;
+			break;
+		case 'z':
+			flags.z = true;
+			break;
+		case -1:
+			warn(parser.errmsg);
+			goto usage;
+		}
+	}
+
+	if (flags.p && flags.s) {
+		warn("-p and -s are mutually exclusive");
+		goto usage;
+	}
+	if (flags.p && flags.z) {
+		warn("-p and -z are mutually exclusive");
+		goto usage;
+	}
+	if (flags.s && flags.z) {
+		warn("-s and -z are mutually exclusive");
+		goto usage;
+	}
+
+	argc -= parser.optind;
+	argv += parser.optind;
+
+	if (argc == 0) {
+	usage:
+		usage("[-p | -s | -z] [-cilU] pattern [file ...]", "-h");
+		exit(EXIT_FATAL);
+	}
+
+	flags.c = flags.c || use_color_p();
+	ops = pattern_comp((u8view_t){*argv, strlen(*argv)});
+
+	allocator_t mem = init_heap_allocator(nullptr);
+
+#if GIT_GRAB
+	argc--;
+	argv++;
+
+	FILE *fstream = getfstream(argc, argv);
+	if (fstream == nullptr)
+		cerr(EXIT_FATAL, "getfstream:");
+
+	const char **filenames = array_new(mem, typeof(*filenames), 1024);
+
+	size_t len;
+	ssize_t nr;
+	char *file = nullptr;
+	while ((nr = getdelim(&file, &len, 0, fstream)) > 0) {
+		/* TODO: Would an arena improve performance? */
+		const char *s = strdup(file);
+		if (s == nullptr)
+			cerr(EXIT_FATAL, "strdup:");
+		array_push(&filenames, s);
+	}
+#else
+	if (argc == 1)
+		argv = (static char *[]){"-"};
+	else {
+		argc--;
+		argv++;
+		flags.do_header = true;
+	}
+#endif
+
+	tpool_t tp;
+	int thrds = tpinit(&tp,
+#if GIT_GRAB
+		filenames, array_len(filenames)
+#else
+		(const char **)argv, argc
+#endif
+	);
+
+    /* Failed to spawn threads */
+	if (thrds == 0) {
+		unsigned char *buf = array_new(mem, typeof(*buf), 4096);
+		for (int i = 0; i < argc; i++) {
+			process_file(argv[i], &buf);
+			fwrite(buf, 1, array_len(buf), stdout);
+			array_hdr(buf)->len = 0;
+		}
+#if DEBUG
+		array_free(buf);
+#endif
+	}
+
+	if (thrds != 0)
+		tpfree(&tp);
+#if DEBUG
+	pcre2_jit_free_unused_memory(nullptr);
+	array_foreach (ops, op) {
+		if (op->free_me)
+			pcre2_code_free(op->re);
+	}
+	array_free(ops);
+#if GIT_GRAB
+	array_foreach (filenames, f)
+		free(f);
+	array_free(filenames);
+#endif
+#endif
+	return rv;
+}
+
+op_t *
+pattern_comp(u8view_t pat)
+{
+	allocator_t mem = init_heap_allocator(nullptr);
+	op_t *ops = array_new(mem, op_t, 16);
+
+	for (;;) {
+		int w;
+		rune ch;
+
+		while ((w = ucsnext(&ch, &pat)) != 0) {
+			if (!uprop_is_pat_ws(ch)) {
+				VSHFT(&pat, -w);
+				break;
+			}
+		}
+		if (pat.len == 0)
+			break;
+
+		/* Grab the operator.  We grab the entire next grapheme for
+		   better error messages in the case that someone tries to use a
+		   non-ASCII grapheme as an operator for whatever reason. */
+
+		op_t op;
+		u8view_t g;
+
+		(void)ucsgnext(&g, &pat);
+		if (g.len != 1 || *g.p >= lengthof(opchars) || !opchars[*g.p]) {
+			cerr(EXIT_FATAL, "Invalid operator %s%.*s%s",
+				lquot, SV_PRI_ARGS(g), rquot);
+		}
+		op.c = (char)*g.p;
+
+		/* Unlike with the operator, we parse the delimeter as a rune
+		   instead of a grapheme.  This makes it easier for users to
+		   write patterns that match combining characters.  This _may_ be
+		   subject to change in the future but for now this is the
+		   rationale.  Alongside standard delimeters, if the opening
+		   delimeter is a bracket or some other form of paired-bracket
+		   (as determined by Unicode) then the closing delimeter is set
+		   to the right-hand form of the bracket.  This means that the
+		   following are both valid delimeted patterns:
+
+		       /regex/
+		       ｢regex｣ */
+
+		rune ldelim, rdelim;
+		if ((w = ucsnext(&ldelim, &pat)) == 0)
+			cerr(EXIT_FATAL, "Premature end of pattern");
+		rdelim = uprop_get_bpb(ldelim);
+
+		/* Find the right delimeter, which is optional for the last
+		   operator */
+		/* TODO: Change u8view_t.len to ptrdiff_t and use -1 here */
+		u8view_t re = {pat.p, (size_t)-1};
+		while ((w = ucsnext(&ch, &pat)) != 0) {
+			if (ch == rdelim) {
+				re.len = pat.p - re.p - w;
+				break;
+			}
+		}
+		if (re.len == (size_t)-1)
+			re.len = pat.p - re.p;
+		if (re.len == 0) {
+			if (op.c != 'h') {
+				cerr(EXIT_FATAL, "%s%c%s operator given empty regex",
+					lquot, op.c, rquot);
+			}
+			if (array_len(ops) == 0) {
+				cerr(EXIT_FATAL,
+					"%sh%s operator given empty regex as the first operator",
+					lquot, rquot);
+			}
+			op.re = ops[array_len(ops) - 1].re;
+#if DEBUG
+			op.free_me = false;
+#endif
+		} else {
+			int ec;
+			size_t eoff;
+			uint32_t reopts = PCRE2_DOTALL | PCRE2_MATCH_INVALID_UTF | PCRE2_UTF;
+			if (flags.i)
+				reopts |= PCRE2_CASELESS;
+			if (!flags.U)
+				reopts |= PCRE2_UCP;
+			op.re = pcre2_compile(re.p, re.len, reopts, &ec, &eoff, nullptr);
+			if (op.re == nullptr) {
+				/* TODO: Ensure the buffer is large enough for the error message */
+				(void)pcre2_get_error_message(ec, emsg, sizeof(emsg));
+				cerr(EXIT_FATAL, "Failed to compile regex: %s", emsg);
+			}
+			if ((ec = pcre2_jit_compile(op.re, PCRE2_JIT_COMPLETE)) != 0) {
+				/* TODO: Ensure the buffer is large enough for the error message */
+				(void)pcre2_get_error_message(ec, emsg, sizeof(emsg));
+				warn("Failed to JIT compile regex: %s", emsg);
+				rv = EXIT_WARNING;
+				pcre2_match_fn = pcre2_match;
+			} else
+				pcre2_match_fn = pcre2_jit_match;
+#if DEBUG
+			op.free_me = true;
+#endif
+		}
+		array_push(&ops, op);
+	}
+
+	if (array_len(ops) == 0)
+		err("Empty pattern");
+
+	return ops;
+}
+
+bool
+use_color_p(void)
+{
+	const char *ev = getenv("TERM");
+	if (ev != nullptr && streq(ev, "dumb"))
+		return false;
+	if ((ev = getenv("NO_COLOR")) != nullptr && *ev != 0)
+		return false;
+	if ((ev = getenv("CLICOLOR_FORCE")) != nullptr && *ev != 0)
+		return true;
+	return isatty(STDOUT_FILENO);
+}
+
+#if GIT_GRAB
+FILE *
+getfstream(int globc, char **globv)
+{
+	pid_t pid;
+	int fds[2];
+	enum { R, W };
+
+	if (pipe(fds) == 1)
+		cerr(EXIT_FATAL, "pipe:");
+
+	switch (pid = fork()) {
+	case -1:
+		cerr(EXIT_FATAL, "fork:");
+	case 0:
+		static const char *git_grep_argv[] = {
+			"git", "grep", "-Ilz", "",
+		};
+
+		close(fds[R]);
+		if (dup2(fds[W], STDOUT_FILENO) == -1)
+			cerr(EXIT_FATAL, "dup2:");
+		close(fds[W]);
+
+		size_t argc = globc + lengthof(git_grep_argv) + 1;
+		char **argv = malloc(argc * sizeof(char *));
+		if (argv == nullptr)
+			cerr(EXIT_FATAL, "malloc:");
+		memcpy(argv, git_grep_argv, sizeof(git_grep_argv));
+		memcpy(argv + lengthof(git_grep_argv), globv, globc * sizeof(char *));
+		argv[argc - 1] = nullptr;
+
+		execvp("git", argv);
+		cerr(EXIT_FATAL, "execvp: git grep -Ilz '':");
+	}
+
+	close(fds[W]);
+	return fdopen(fds[R], "r");
+}
+#endif
diff --git a/src/tpool.c b/src/tpool.c
new file mode 100644
index 0000000..f30bccc
--- /dev/null
+++ b/src/tpool.c
@@ -0,0 +1,127 @@
+/* Thread pool implementation mostly copied from cbs.h */
+
+#include <errno.h>
+#include <pthread.h>
+#include <stdatomic.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <alloc.h>
+#include <array.h>
+#include <errors.h>
+#include <macros.h>
+
+#include "tpool.h"
+#include "work.h"
+
+#include <stdio.h>
+
+static int nproc(void);
+static void *tpwork(void *);
+
+static pthread_t thread_buffer[32];
+
+extern const char *lquot, *rquot;
+
+int
+nproc(void)
+{
+	errno = 0;
+
+	/* Grab the number of processors available on the users system.  If we can
+	   we query sysconf() but fallback to 1 for systems that don’t support the
+	   sysconf() method.  The user can also override this via the GRAB_NPROCS
+	   environment variable, and if that’s invalid then we just issue a
+	   diagnostic and default to 1.
+
+	   We don’t want to error on an invalid value for GRAB_NPROCS because we
+       might be running this tool as part of an editor plugin for example where
+       finding the root cause of your regexp-search failing may not be so
+       trivial. */
+
+	const char *ev = getenv("GRAB_NPROCS");
+	if (ev != nullptr && *ev != 0) {
+		const char *endptr;
+		long n = strtol(ev, (char **)&endptr, 10);
+		if (errno == 0 && *endptr == 0)
+			return (int)n;
+		if (errno != 0)
+			warn("strtol: %s:", ev);
+		if (*endptr != 0)
+			warn("Invalid value for %s%s%s for GRAB_NPROCS", lquot, ev, rquot);
+		return 1;
+	}
+
+#ifdef _SC_NPROCESSORS_ONLN
+	return (int)sysconf(_SC_NPROCESSORS_ONLN);
+#else
+	return 1;
+#endif
+}
+
+int
+tpinit(tpool_t *tp, const char **files, ptrdiff_t filecnt)
+{
+	tp->files = files;
+	tp->filecnt = filecnt;
+	tp->tcnt = nproc();
+	tp->tcnt = MIN(tp->tcnt, filecnt);
+	tp->wi = 0;
+
+	if (tp->tcnt <= 32)
+		tp->thrds = thread_buffer;
+	else if ((tp->thrds = malloc(sizeof(*tp->thrds) * tp->tcnt)) == nullptr)
+		err("malloc:");
+
+	/* If for whatever reason some threads fail to be created, we don’t
+       panic but instead just continue using the threads that were able
+       to spawn.  If all threads fail to spawn we return 0 and the caller
+       will resort to single-threaded behaviour. */
+
+	int n = 0;
+	for (int i = 0; i < tp->tcnt; i++) {
+		if ((errno = pthread_create(tp->thrds + n, nullptr, tpwork, tp)) != 0)
+			warn("failed to create thread:");
+		else
+			n++;
+	}
+	return n;
+}
+
+void
+tpfree(tpool_t *tp)
+{
+	for (int i = 0; i < tp->tcnt; i++)
+		pthread_join(tp->thrds[i], nullptr);
+
+#if DEBUG
+	if (tp->thrds != thread_buffer)
+		free(tp->thrds);
+#endif
+}
+
+void *
+tpwork(void *arg)
+{
+	tpool_t *tp = arg;
+
+	allocator_t mem = init_heap_allocator(nullptr);
+	unsigned char *buf = array_new(mem, typeof(*buf), 4096);
+
+	for (;;) {
+		ptrdiff_t i = atomic_fetch_add(&tp->wi, 1);
+		if (i >= tp->filecnt)
+			break;
+		process_file(tp->files[i], &buf);
+	}
+
+	flockfile(stdout);
+	fwrite(buf, 1, array_len(buf), stdout);
+	funlockfile(stdout);
+
+#if DEBUG
+	array_free(buf);
+#endif
+	return nullptr;
+}
diff --git a/src/tpool.h b/src/tpool.h
new file mode 100644
index 0000000..04f0486
--- /dev/null
+++ b/src/tpool.h
@@ -0,0 +1,19 @@
+#ifndef GRAB_TPOOL_H
+#define GRAB_TPOOL_H
+
+#include <pthread.h>
+#include <stdatomic.h>
+#include <stddef.h>
+
+typedef struct {
+	int tcnt;
+	pthread_t *thrds;
+	atomic_ptrdiff_t wi;
+	const char **files;
+	ptrdiff_t filecnt;
+} tpool_t;
+
+int tpinit(tpool_t *tp, const char **files, ptrdiff_t filecnt);
+void tpfree(tpool_t *tp);
+
+#endif /* !GRAB_TPOOL_H */
diff --git a/src/work.c b/src/work.c
new file mode 100644
index 0000000..37fd8b8
--- /dev/null
+++ b/src/work.c
@@ -0,0 +1,453 @@
+#include <sys/mman.h>
+#include <sys/stat.h>
+
+#include <stdatomic.h>
+#include <stdckdint.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <alloc.h>
+#include <array.h>
+#include <errors.h>
+#include <macros.h>
+#include <mbstring.h>
+#include <pcre2.h>
+#include <unicode/string.h>
+
+#include "exitcodes.h"
+#include "flags.h"
+#include "work.h"
+
+#define DEFINE_OPERATOR(fn) \
+	void operator_##fn(ptrdiff_t opi, u8view_t sv, u8view_t **hl)
+#define array_extend_sv(xs, sv) \
+	array_extend((xs), (sv).p, (ptrdiff_t)(sv).len)
+
+typedef struct {
+	ptrdiff_t row, col;
+} pos_t;
+
+static pos_t compute_pos(const char8_t *p);
+static bool islbrk(u8view_t g);
+static int svposcmp(const void *a, const void *b);
+static void write_match_to_buffer(u8view_t sv, u8view_t *hl);
+
+static DEFINE_OPERATOR(dispatch);
+static DEFINE_OPERATOR(g);
+static DEFINE_OPERATOR(G);
+static DEFINE_OPERATOR(h);
+static DEFINE_OPERATOR(H);
+static DEFINE_OPERATOR(x);
+static DEFINE_OPERATOR(X);
+
+static thread_local const char *filename;
+static thread_local char8_t *baseptr;
+static thread_local const char8_t *last_match;
+static thread_local unsigned char **buf;
+
+static typeof(operator_dispatch) *operators[] = {
+	['g'] = operator_g,
+	['G'] = operator_G,
+	['h'] = operator_h,
+	['H'] = operator_H,
+	['x'] = operator_x,
+	['X'] = operator_X,
+};
+
+extern atomic_int rv;
+extern op_t *ops;
+extern bool cflag;
+extern typeof(pcre2_match) *pcre2_match_fn;
+
+
+
+void
+process_file(const char *locl_filename, unsigned char **locl_buf)
+{
+	filename = locl_filename;
+	buf = locl_buf;
+
+	FILE *fp = streq(filename, "-") ? stdin : fopen(filename, "r");
+	if (fp == nullptr) {
+		warn("fopen: %s:", filename);
+		atomic_store(&rv, EXIT_WARNING);
+		goto out;
+	}
+
+	allocator_t mem = init_heap_allocator(nullptr);
+	if (baseptr == nullptr)
+		baseptr = array_new(mem, char8_t, 0x1000);
+	size_t bufsz = array_cap(baseptr);
+	last_match = baseptr;
+
+	do {
+		static_assert(sizeof(char8_t) == 1, "sizeof(char8_t) != 1; wtf?");
+		baseptr = array_resz(baseptr, bufsz += BUFSIZ); /* TODO: Bounds checking */
+		size_t n = fread(baseptr + array_len(baseptr), 1, BUFSIZ, fp);
+		array_hdr(baseptr)->len += n;
+	} while (!feof(fp));
+
+	if (ferror(fp)) {
+		warn("fread: %s:", filename);
+		atomic_store(&rv, EXIT_WARNING);
+		goto out;
+	}
+
+	/* Shouldn’t need more than 32 ever… */
+	static thread_local u8view_t *hl = nullptr;
+	if (hl == nullptr)
+		hl = array_new(mem, typeof(*hl), 32);
+
+	operator_dispatch(0, (u8view_t){baseptr, array_len(baseptr)}, &hl);
+#if DEBUG
+	array_free(baseptr);
+	baseptr = nullptr;
+	array_free(hl);
+	hl = nullptr;
+#else
+	array_hdr(baseptr)->len = 0;
+	array_hdr(hl)->len = 0;
+#endif
+
+out:
+	if (fp != stdin)
+		(void)fclose(fp);
+}
+
+
+
+DEFINE_OPERATOR(dispatch)
+{
+	if (array_len(ops) == opi) {
+		if (flags.p)
+			exit(EXIT_SUCCESS);
+		atomic_compare_exchange_strong(&rv, &(int){EXIT_NOMATCH}, EXIT_SUCCESS);
+		write_match_to_buffer(sv, *hl);
+	} else /* Cast to silence GCC warning */
+		operators[(unsigned char)ops[opi].c](opi, sv, hl);
+}
+
+DEFINE_OPERATOR(g)
+{
+	pcre2_match_data *md =
+		pcre2_match_data_create_from_pattern(ops[opi].re, nullptr);
+	int n = pcre2_match_fn(ops[opi].re, sv.p, sv.len, 0, PCRE2_NOTEMPTY,
+	                       md, nullptr);
+	pcre2_match_data_free(md);
+
+	/* This should never happen */
+	if (n == 0)
+		cerr(EXIT_FATAL, "PCRE2 match data too small");
+	if (n == PCRE2_ERROR_NOMATCH)
+		return;
+	if (n < 0)
+		; /* TODO: Handle error */
+
+	operator_dispatch(opi + 1, sv, hl);
+}
+
+DEFINE_OPERATOR(G)
+{
+	/* TODO: Can we reuse match data? */
+	pcre2_match_data *md =
+		pcre2_match_data_create_from_pattern(ops[opi].re, nullptr);
+	int n = pcre2_match_fn(ops[opi].re, sv.p, sv.len, 0, PCRE2_NOTEMPTY,
+	                       md, nullptr);
+	pcre2_match_data_free(md);
+
+	/* This should never happen */
+	if (n == 0)
+		cerr(EXIT_FATAL, "PCRE2 match data too small");
+	if (n == PCRE2_ERROR_NOMATCH)
+		operator_dispatch(opi + 1, sv, hl);
+	if (n < 0)
+		; /* TODO: Handle error */
+}
+
+DEFINE_OPERATOR(h)
+{
+	if (flags.p) {
+		operator_dispatch(opi + 1, sv, hl);
+		return;
+	}
+
+	pcre2_match_data *md =
+		pcre2_match_data_create_from_pattern(ops[opi].re, nullptr);
+	u8view_t sv_save = sv;
+	ptrdiff_t origlen = array_len(*hl);
+	for (;;) {
+		int n = pcre2_match_fn(ops[opi].re, sv.p, sv.len, 0,
+		                       PCRE2_NOTEMPTY, md, nullptr);
+		/* This should never happen */
+		if (n == 0)
+			cerr(EXIT_FATAL, "PCRE2 match data too small");
+		if (n == PCRE2_ERROR_NOMATCH)
+			break;
+		if (n < 0)
+			; /* TODO: Handle error */
+
+		size_t *ov = pcre2_get_ovector_pointer(md);
+		array_push(hl, ((u8view_t){sv.p + ov[0], ov[1] - ov[0]}));
+		VSHFT(&sv, ov[1]);
+	}
+	pcre2_match_data_free(md);
+	operator_dispatch(opi + 1, sv_save, hl);
+	array_hdr(*hl)->len = origlen;
+}
+
+DEFINE_OPERATOR(H)
+{
+	if (flags.p) {
+		operator_dispatch(opi + 1, sv, hl);
+		return;
+	}
+
+	pcre2_match_data *md =
+		pcre2_match_data_create_from_pattern(ops[opi].re, nullptr);
+	u8view_t sv_save = sv;
+	ptrdiff_t origlen = array_len(*hl);
+	for (;;) {
+		int n = pcre2_match_fn(ops[opi].re, sv.p, sv.len, 0, PCRE2_NOTEMPTY,
+		                       md, nullptr);
+		/* This should never happen */
+		if (n == 0)
+			cerr(EXIT_FATAL, "PCRE2 match data too small");
+		if (n == PCRE2_ERROR_NOMATCH)
+			break;
+		if (n < 0)
+			; /* TODO: Handle error */
+
+		size_t *ov = pcre2_get_ovector_pointer(md);
+		array_push(hl, ((u8view_t){sv.p, ov[0]}));
+		VSHFT(&sv, ov[1]);
+	}
+	pcre2_match_data_free(md);
+	operator_dispatch(opi + 1, sv_save, hl);
+	array_hdr(*hl)->len = origlen;
+}
+
+DEFINE_OPERATOR(x)
+{
+	pcre2_match_data *md =
+		pcre2_match_data_create_from_pattern(ops[opi].re, nullptr);
+	for (;;) {
+		int n = pcre2_match_fn(ops[opi].re, sv.p, sv.len, 0, PCRE2_NOTEMPTY,
+		                       md, nullptr);
+		/* This should never happen */
+		if (n == 0)
+			cerr(EXIT_FATAL, "PCRE2 match data too small");
+		if (n == PCRE2_ERROR_NOMATCH)
+			break;
+		if (n < 0)
+			; /* TODO: Handle error */
+
+		size_t *ov = pcre2_get_ovector_pointer(md);
+		operator_dispatch(opi + 1, (u8view_t){sv.p + ov[0], ov[1] - ov[0]}, hl);
+		VSHFT(&sv, ov[1]);
+	}
+	pcre2_match_data_free(md);
+}
+
+DEFINE_OPERATOR(X)
+{
+	pcre2_match_data *md =
+		pcre2_match_data_create_from_pattern(ops[opi].re, nullptr);
+	for (;;) {
+		int n = pcre2_match_fn(ops[opi].re, sv.p, sv.len, 0, PCRE2_NOTEMPTY,
+		                       md, nullptr);
+		/* This should never happen */
+		if (n == 0)
+			cerr(EXIT_FATAL, "PCRE2 match data too small");
+		if (n == PCRE2_ERROR_NOMATCH)
+			break;
+		if (n < 0)
+			; /* TODO: Handle error */
+
+		size_t *ov = pcre2_get_ovector_pointer(md);
+		if (ov[0] != 0)
+			operator_dispatch(opi + 1, (u8view_t){sv.p, ov[0]}, hl);
+		VSHFT(&sv, ov[1]);
+	}
+	if (sv.len != 0)
+		operator_dispatch(opi + 1, sv, hl);
+	pcre2_match_data_free(md);
+}
+
+
+
+static inline bool
+views_overlap(const u8view_t a, const u8view_t b)
+{
+	const char8_t *p = a.p + a.len;
+	return p >= b.p && p <= b.p + b.len;
+}
+
+void
+write_match_to_buffer(u8view_t sv, u8view_t *hl)
+{
+	const u8view_t COL_FN = !flags.c ? U8("") : U8("\33[35m");
+	const u8view_t COL_HL = !flags.c ? U8("") : U8("\33[01;31m");
+	const u8view_t COL_LN = !flags.c ? U8("") : U8("\33[32m");
+	const u8view_t COL_SE = !flags.c ? U8("") : U8("\33[36m");
+	const u8view_t COL_RS = !flags.c ? U8("") : U8("\33[0m");
+
+	if (
+#if GIT_GRAB
+		true
+#else
+		flags.do_header
+#endif
+	) {
+		char sep = flags.z ? 0 : ':';
+
+		size_t filenamesz = strlen(filename);
+
+		array_extend_sv(buf, COL_FN);
+		array_extend(buf, filename, (ptrdiff_t)filenamesz);
+		array_extend_sv(buf, COL_RS);
+
+		array_extend_sv(buf, COL_SE);
+		array_push(buf, sep);
+		array_extend_sv(buf, COL_RS);
+
+		/* GCC things ‘offset’ can overflow because our offsets have type
+		   ptrdiff_t which if negative would have a ‘-’ in the front, but
+		   we know that the match positions can’t be negative so it’s
+		   safe to ignore. */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat-overflow"
+
+		int offsetsz;
+		char offset[/* len(INT64_MAX - 1) */ 19];
+		if (flags.l) {
+			pos_t p = compute_pos(sv.p);
+
+			offsetsz = sprintf(offset, "%td", p.row + 1);
+			array_extend_sv(buf, COL_LN);
+			array_extend(buf, offset, offsetsz);
+			array_extend_sv(buf, COL_RS);
+
+			array_extend_sv(buf, COL_SE);
+			array_push(buf, sep);
+			array_extend_sv(buf, COL_RS);
+
+			offsetsz = sprintf(offset, "%td", p.col + 1);
+			array_extend_sv(buf, COL_LN);
+			array_extend(buf, offset, offsetsz);
+			array_extend_sv(buf, COL_RS);
+		} else {
+			offsetsz = sprintf(offset, "%td", sv.p - baseptr);
+			array_extend_sv(buf, COL_LN);
+			array_extend(buf, offset, offsetsz);
+			array_extend_sv(buf, COL_RS);
+		}
+
+		array_extend_sv(buf, COL_SE);
+		array_push(buf, sep);
+		array_extend_sv(buf, COL_RS);
+	}
+
+#pragma GCC diagnostic pop
+
+	/* Here we need to take all the views of regions to highlight, and try
+	   to merge them into a simpler form.  This happens in two steps:
+
+	   1. Sort the views by their starting position in the matched text.
+	   2. Merge overlapping views.
+
+	   After this process we should have the most reduced possible set of
+	   views.  The next part is to actually print the highlighted regions
+	   possible which requires bounds-checking as highlighted regions may
+	   begin before or end after the matched text when using patterns such
+	   as ‘h/.+/ x/.$/’. */
+
+	static thread_local u8view_t *sorted = nullptr;
+	if (sorted == nullptr) {
+		allocator_t mem = init_heap_allocator(nullptr);
+		ptrdiff_t buflen = array_len(hl);
+		buflen = MAX(buflen, 16);
+		sorted = array_new(mem, typeof(*sorted), buflen);
+	} else
+		array_hdr(sorted)->len = 0;
+
+	array_extend(&sorted, hl, array_len(hl));
+	qsort(sorted, array_len(sorted), sizeof(*sorted), svposcmp);
+
+	for (ptrdiff_t i = 0, len = array_len(sorted); i < len - 1;) {
+		if (views_overlap(sorted[i], sorted[i + 1])) {
+			sorted[i].len = sorted[i + 1].p + sorted[i + 1].len - sorted[i].p;
+			memmove(hl + i + 1, hl + i + 2, sizeof(*hl) * (len - i - 1));
+			array_hdr(sorted)->len = --len;
+		} else
+			i++;
+	}
+
+	for (ptrdiff_t i = 0, len = array_len(sorted); i < len; i++) {
+		if (i < len - 1 && sorted[i].p == sorted[i + 1].p)
+			continue;
+		array_extend(buf, sv.p, sorted[i].p - sv.p);
+		array_extend_sv(buf, COL_HL);
+		array_extend_sv(buf, sorted[i]);
+		array_extend_sv(buf, COL_RS);
+		ptrdiff_t Δ = sorted[i].p - sv.p + sorted[i].len;
+		VSHFT(&sv, Δ);
+	}
+	array_extend_sv(buf, sv);
+
+#if DEBUG
+	array_free(sorted);
+	sorted = nullptr;
+#endif
+
+	if (flags.z)
+		array_push(buf, 0);
+	else {
+		ptrdiff_t bufsz = array_len(*buf);
+		if (!flags.s || bufsz == 0 || (*buf)[bufsz - 1] != '\n')
+			array_push(buf, '\n');
+	}
+}
+
+pos_t
+compute_pos(const char8_t *ptr)
+{
+	static thread_local pos_t p;
+	if (last_match == baseptr)
+		p.row = p.col = 0;
+	u8view_t g, sv = {last_match, PTRDIFF_MAX};
+	while (sv.p < ptr) {
+		ucsgnext(&g, &sv);
+		if (islbrk(g)) {
+			p.row++;
+			p.col = 0;
+		} else
+			p.col = ucswdth(g, p.col, 8);  /* TODO: Configurable tabsize? */
+	}
+	last_match = sv.p;
+	return p;
+}
+
+bool
+islbrk(u8view_t g)
+{
+	return ucseq(g, U8("\n"))
+	    || ucseq(g, U8("\v"))
+	    || ucseq(g, U8("\f"))
+	    || ucseq(g, U8("\r\n"))
+	    || ucseq(g, U8("\x85"))
+	    || ucseq(g, U8("\u2028"))
+	    || ucseq(g, U8("\u2029"));
+}
+
+int
+svposcmp(const void *a_, const void *b_)
+{
+	const u8view_t *a = a_,
+	               *b = b_;
+	ptrdiff_t Δ = a->p - b->p;
+	return Δ == 0 ? (ptrdiff_t)a->len - (ptrdiff_t)b->len : Δ;
+}
diff --git a/src/work.h b/src/work.h
new file mode 100644
index 0000000..644a244
--- /dev/null
+++ b/src/work.h
@@ -0,0 +1,16 @@
+#ifndef GRAB_WORK_H
+#define GRAB_WORK_H
+
+#include <pcre2.h>
+
+typedef struct {
+	char c;
+	pcre2_code *re;
+#if DEBUG
+	bool free_me;
+#endif
+} op_t;
+
+void process_file(const char *filename, unsigned char **buf);
+
+#endif /* !GRAB_WORK_H */