chore(3p/git): Unvendor git and track patches instead r/2903

This was vendored a long time ago under the expectation that keeping
it in sync with cgit would be easier this way, but it has proven not
to be a big issue.

On the other hand, a vendored copy of git is an annoying maintenance
burden. It is much easier to rebase the single (dottime) patch that we
have.

This removes the vendored copy of git and instead passes the git
source code to cgit via `pkgs.srcOnly`, which includes the applied
patch so that cgit can continue rendering dottime.

Change-Id: If31f62dea7ce688fd1b9050204e9378019775f2b

1 files changed, 0 insertions, 2209 deletions

diff --git a/third_party/git/grep.c b/third_party/git/grep.c
deleted file mode 100644
index 54af9f813e99..000000000000
--- a/third_party/git/grep.c
+++ /dev/null
@@ -1,2209 +0,0 @@
-#include "cache.h"
-#include "config.h"
-#include "grep.h"
-#include "object-store.h"
-#include "userdiff.h"
-#include "xdiff-interface.h"
-#include "diff.h"
-#include "diffcore.h"
-#include "commit.h"
-#include "quote.h"
-#include "help.h"
-
-static int grep_source_load(struct grep_source *gs);
-static int grep_source_is_binary(struct grep_source *gs,
-				 struct index_state *istate);
-
-static struct grep_opt grep_defaults;
-
-#ifdef USE_LIBPCRE2
-static pcre2_general_context *pcre2_global_context;
-
-static void *pcre2_malloc(PCRE2_SIZE size, MAYBE_UNUSED void *memory_data)
-{
-	return malloc(size);
-}
-
-static void pcre2_free(void *pointer, MAYBE_UNUSED void *memory_data)
-{
-	free(pointer);
-}
-#endif
-
-static const char *color_grep_slots[] = {
-	[GREP_COLOR_CONTEXT]	    = "context",
-	[GREP_COLOR_FILENAME]	    = "filename",
-	[GREP_COLOR_FUNCTION]	    = "function",
-	[GREP_COLOR_LINENO]	    = "lineNumber",
-	[GREP_COLOR_COLUMNNO]	    = "column",
-	[GREP_COLOR_MATCH_CONTEXT]  = "matchContext",
-	[GREP_COLOR_MATCH_SELECTED] = "matchSelected",
-	[GREP_COLOR_SELECTED]	    = "selected",
-	[GREP_COLOR_SEP]	    = "separator",
-};
-
-static void std_output(struct grep_opt *opt, const void *buf, size_t size)
-{
-	fwrite(buf, size, 1, stdout);
-}
-
-static void color_set(char *dst, const char *color_bytes)
-{
-	xsnprintf(dst, COLOR_MAXLEN, "%s", color_bytes);
-}
-
-/*
- * Initialize the grep_defaults template with hardcoded defaults.
- * We could let the compiler do this, but without C99 initializers
- * the code gets unwieldy and unreadable, so...
- */
-void init_grep_defaults(struct repository *repo)
-{
-	struct grep_opt *opt = &grep_defaults;
-	static int run_once;
-
-	if (run_once)
-		return;
-	run_once++;
-
-	memset(opt, 0, sizeof(*opt));
-	opt->repo = repo;
-	opt->relative = 1;
-	opt->pathname = 1;
-	opt->max_depth = -1;
-	opt->pattern_type_option = GREP_PATTERN_TYPE_UNSPECIFIED;
-	color_set(opt->colors[GREP_COLOR_CONTEXT], "");
-	color_set(opt->colors[GREP_COLOR_FILENAME], "");
-	color_set(opt->colors[GREP_COLOR_FUNCTION], "");
-	color_set(opt->colors[GREP_COLOR_LINENO], "");
-	color_set(opt->colors[GREP_COLOR_COLUMNNO], "");
-	color_set(opt->colors[GREP_COLOR_MATCH_CONTEXT], GIT_COLOR_BOLD_RED);
-	color_set(opt->colors[GREP_COLOR_MATCH_SELECTED], GIT_COLOR_BOLD_RED);
-	color_set(opt->colors[GREP_COLOR_SELECTED], "");
-	color_set(opt->colors[GREP_COLOR_SEP], GIT_COLOR_CYAN);
-	opt->only_matching = 0;
-	opt->color = -1;
-	opt->output = std_output;
-}
-
-static int parse_pattern_type_arg(const char *opt, const char *arg)
-{
-	if (!strcmp(arg, "default"))
-		return GREP_PATTERN_TYPE_UNSPECIFIED;
-	else if (!strcmp(arg, "basic"))
-		return GREP_PATTERN_TYPE_BRE;
-	else if (!strcmp(arg, "extended"))
-		return GREP_PATTERN_TYPE_ERE;
-	else if (!strcmp(arg, "fixed"))
-		return GREP_PATTERN_TYPE_FIXED;
-	else if (!strcmp(arg, "perl"))
-		return GREP_PATTERN_TYPE_PCRE;
-	die("bad %s argument: %s", opt, arg);
-}
-
-define_list_config_array_extra(color_grep_slots, {"match"});
-
-/*
- * Read the configuration file once and store it in
- * the grep_defaults template.
- */
-int grep_config(const char *var, const char *value, void *cb)
-{
-	struct grep_opt *opt = &grep_defaults;
-	const char *slot;
-
-	if (userdiff_config(var, value) < 0)
-		return -1;
-
-	if (!strcmp(var, "grep.extendedregexp")) {
-		opt->extended_regexp_option = git_config_bool(var, value);
-		return 0;
-	}
-
-	if (!strcmp(var, "grep.patterntype")) {
-		opt->pattern_type_option = parse_pattern_type_arg(var, value);
-		return 0;
-	}
-
-	if (!strcmp(var, "grep.linenumber")) {
-		opt->linenum = git_config_bool(var, value);
-		return 0;
-	}
-	if (!strcmp(var, "grep.column")) {
-		opt->columnnum = git_config_bool(var, value);
-		return 0;
-	}
-
-	if (!strcmp(var, "grep.fullname")) {
-		opt->relative = !git_config_bool(var, value);
-		return 0;
-	}
-
-	if (!strcmp(var, "color.grep"))
-		opt->color = git_config_colorbool(var, value);
-	if (!strcmp(var, "color.grep.match")) {
-		if (grep_config("color.grep.matchcontext", value, cb) < 0)
-			return -1;
-		if (grep_config("color.grep.matchselected", value, cb) < 0)
-			return -1;
-	} else if (skip_prefix(var, "color.grep.", &slot)) {
-		int i = LOOKUP_CONFIG(color_grep_slots, slot);
-		char *color;
-
-		if (i < 0)
-			return -1;
-		color = opt->colors[i];
-		if (!value)
-			return config_error_nonbool(var);
-		return color_parse(value, color);
-	}
-	return 0;
-}
-
-/*
- * Initialize one instance of grep_opt and copy the
- * default values from the template we read the configuration
- * information in an earlier call to git_config(grep_config).
- *
- * If using PCRE, make sure that the library is configured
- * to use the same allocator as Git (e.g. nedmalloc on Windows).
- *
- * Any allocated memory needs to be released in grep_destroy().
- */
-void grep_init(struct grep_opt *opt, struct repository *repo, const char *prefix)
-{
-	struct grep_opt *def = &grep_defaults;
-	int i;
-
-#if defined(USE_LIBPCRE2)
-	if (!pcre2_global_context)
-		pcre2_global_context = pcre2_general_context_create(
-					pcre2_malloc, pcre2_free, NULL);
-#endif
-
-#ifdef USE_LIBPCRE1
-	pcre_malloc = malloc;
-	pcre_free = free;
-#endif
-
-	memset(opt, 0, sizeof(*opt));
-	opt->repo = repo;
-	opt->prefix = prefix;
-	opt->prefix_length = (prefix && *prefix) ? strlen(prefix) : 0;
-	opt->pattern_tail = &opt->pattern_list;
-	opt->header_tail = &opt->header_list;
-
-	opt->only_matching = def->only_matching;
-	opt->color = def->color;
-	opt->extended_regexp_option = def->extended_regexp_option;
-	opt->pattern_type_option = def->pattern_type_option;
-	opt->linenum = def->linenum;
-	opt->columnnum = def->columnnum;
-	opt->max_depth = def->max_depth;
-	opt->pathname = def->pathname;
-	opt->relative = def->relative;
-	opt->output = def->output;
-
-	for (i = 0; i < NR_GREP_COLORS; i++)
-		color_set(opt->colors[i], def->colors[i]);
-}
-
-void grep_destroy(void)
-{
-#ifdef USE_LIBPCRE2
-	pcre2_general_context_free(pcre2_global_context);
-#endif
-}
-
-static void grep_set_pattern_type_option(enum grep_pattern_type pattern_type, struct grep_opt *opt)
-{
-	/*
-	 * When committing to the pattern type by setting the relevant
-	 * fields in grep_opt it's generally not necessary to zero out
-	 * the fields we're not choosing, since they won't have been
-	 * set by anything. The extended_regexp_option field is the
-	 * only exception to this.
-	 *
-	 * This is because in the process of parsing grep.patternType
-	 * & grep.extendedRegexp we set opt->pattern_type_option and
-	 * opt->extended_regexp_option, respectively. We then
-	 * internally use opt->extended_regexp_option to see if we're
-	 * compiling an ERE. It must be unset if that's not actually
-	 * the case.
-	 */
-	if (pattern_type != GREP_PATTERN_TYPE_ERE &&
-	    opt->extended_regexp_option)
-		opt->extended_regexp_option = 0;
-
-	switch (pattern_type) {
-	case GREP_PATTERN_TYPE_UNSPECIFIED:
-		/* fall through */
-
-	case GREP_PATTERN_TYPE_BRE:
-		break;
-
-	case GREP_PATTERN_TYPE_ERE:
-		opt->extended_regexp_option = 1;
-		break;
-
-	case GREP_PATTERN_TYPE_FIXED:
-		opt->fixed = 1;
-		break;
-
-	case GREP_PATTERN_TYPE_PCRE:
-#ifdef USE_LIBPCRE2
-		opt->pcre2 = 1;
-#else
-		/*
-		 * It's important that pcre1 always be assigned to
-		 * even when there's no USE_LIBPCRE* defined. We still
-		 * call the PCRE stub function, it just dies with
-		 * "cannot use Perl-compatible regexes[...]".
-		 */
-		opt->pcre1 = 1;
-#endif
-		break;
-	}
-}
-
-void grep_commit_pattern_type(enum grep_pattern_type pattern_type, struct grep_opt *opt)
-{
-	if (pattern_type != GREP_PATTERN_TYPE_UNSPECIFIED)
-		grep_set_pattern_type_option(pattern_type, opt);
-	else if (opt->pattern_type_option != GREP_PATTERN_TYPE_UNSPECIFIED)
-		grep_set_pattern_type_option(opt->pattern_type_option, opt);
-	else if (opt->extended_regexp_option)
-		/*
-		 * This branch *must* happen after setting from the
-		 * opt->pattern_type_option above, we don't want
-		 * grep.extendedRegexp to override grep.patternType!
-		 */
-		grep_set_pattern_type_option(GREP_PATTERN_TYPE_ERE, opt);
-}
-
-static struct grep_pat *create_grep_pat(const char *pat, size_t patlen,
-					const char *origin, int no,
-					enum grep_pat_token t,
-					enum grep_header_field field)
-{
-	struct grep_pat *p = xcalloc(1, sizeof(*p));
-	p->pattern = xmemdupz(pat, patlen);
-	p->patternlen = patlen;
-	p->origin = origin;
-	p->no = no;
-	p->token = t;
-	p->field = field;
-	return p;
-}
-
-static void do_append_grep_pat(struct grep_pat ***tail, struct grep_pat *p)
-{
-	**tail = p;
-	*tail = &p->next;
-	p->next = NULL;
-
-	switch (p->token) {
-	case GREP_PATTERN: /* atom */
-	case GREP_PATTERN_HEAD:
-	case GREP_PATTERN_BODY:
-		for (;;) {
-			struct grep_pat *new_pat;
-			size_t len = 0;
-			char *cp = p->pattern + p->patternlen, *nl = NULL;
-			while (++len <= p->patternlen) {
-				if (*(--cp) == '\n') {
-					nl = cp;
-					break;
-				}
-			}
-			if (!nl)
-				break;
-			new_pat = create_grep_pat(nl + 1, len - 1, p->origin,
-						  p->no, p->token, p->field);
-			new_pat->next = p->next;
-			if (!p->next)
-				*tail = &new_pat->next;
-			p->next = new_pat;
-			*nl = '\0';
-			p->patternlen -= len;
-		}
-		break;
-	default:
-		break;
-	}
-}
-
-void append_header_grep_pattern(struct grep_opt *opt,
-				enum grep_header_field field, const char *pat)
-{
-	struct grep_pat *p = create_grep_pat(pat, strlen(pat), "header", 0,
-					     GREP_PATTERN_HEAD, field);
-	if (field == GREP_HEADER_REFLOG)
-		opt->use_reflog_filter = 1;
-	do_append_grep_pat(&opt->header_tail, p);
-}
-
-void append_grep_pattern(struct grep_opt *opt, const char *pat,
-			 const char *origin, int no, enum grep_pat_token t)
-{
-	append_grep_pat(opt, pat, strlen(pat), origin, no, t);
-}
-
-void append_grep_pat(struct grep_opt *opt, const char *pat, size_t patlen,
-		     const char *origin, int no, enum grep_pat_token t)
-{
-	struct grep_pat *p = create_grep_pat(pat, patlen, origin, no, t, 0);
-	do_append_grep_pat(&opt->pattern_tail, p);
-}
-
-struct grep_opt *grep_opt_dup(const struct grep_opt *opt)
-{
-	struct grep_pat *pat;
-	struct grep_opt *ret = xmalloc(sizeof(struct grep_opt));
-	*ret = *opt;
-
-	ret->pattern_list = NULL;
-	ret->pattern_tail = &ret->pattern_list;
-
-	for(pat = opt->pattern_list; pat != NULL; pat = pat->next)
-	{
-		if(pat->token == GREP_PATTERN_HEAD)
-			append_header_grep_pattern(ret, pat->field,
-						   pat->pattern);
-		else
-			append_grep_pat(ret, pat->pattern, pat->patternlen,
-					pat->origin, pat->no, pat->token);
-	}
-
-	return ret;
-}
-
-static NORETURN void compile_regexp_failed(const struct grep_pat *p,
-		const char *error)
-{
-	char where[1024];
-
-	if (p->no)
-		xsnprintf(where, sizeof(where), "In '%s' at %d, ", p->origin, p->no);
-	else if (p->origin)
-		xsnprintf(where, sizeof(where), "%s, ", p->origin);
-	else
-		where[0] = 0;
-
-	die("%s'%s': %s", where, p->pattern, error);
-}
-
-static int is_fixed(const char *s, size_t len)
-{
-	size_t i;
-
-	for (i = 0; i < len; i++) {
-		if (is_regex_special(s[i]))
-			return 0;
-	}
-
-	return 1;
-}
-
-#ifdef USE_LIBPCRE1
-static void compile_pcre1_regexp(struct grep_pat *p, const struct grep_opt *opt)
-{
-	const char *error;
-	int erroffset;
-	int options = PCRE_MULTILINE;
-	int study_options = 0;
-
-	if (opt->ignore_case) {
-		if (!opt->ignore_locale && has_non_ascii(p->pattern))
-			p->pcre1_tables = pcre_maketables();
-		options |= PCRE_CASELESS;
-	}
-	if (!opt->ignore_locale && is_utf8_locale() && has_non_ascii(p->pattern))
-		options |= PCRE_UTF8;
-
-	p->pcre1_regexp = pcre_compile(p->pattern, options, &error, &erroffset,
-				      p->pcre1_tables);
-	if (!p->pcre1_regexp)
-		compile_regexp_failed(p, error);
-
-#if defined(PCRE_CONFIG_JIT) && !defined(NO_LIBPCRE1_JIT)
-	pcre_config(PCRE_CONFIG_JIT, &p->pcre1_jit_on);
-	if (opt->debug)
-		fprintf(stderr, "pcre1_jit_on=%d\n", p->pcre1_jit_on);
-
-	if (p->pcre1_jit_on)
-		study_options = PCRE_STUDY_JIT_COMPILE;
-#endif
-
-	p->pcre1_extra_info = pcre_study(p->pcre1_regexp, study_options, &error);
-	if (!p->pcre1_extra_info && error)
-		die("%s", error);
-}
-
-static int pcre1match(struct grep_pat *p, const char *line, const char *eol,
-		regmatch_t *match, int eflags)
-{
-	int ovector[30], ret, flags = PCRE_NO_UTF8_CHECK;
-
-	if (eflags & REG_NOTBOL)
-		flags |= PCRE_NOTBOL;
-
-	ret = pcre_exec(p->pcre1_regexp, p->pcre1_extra_info, line,
-			eol - line, 0, flags, ovector,
-			ARRAY_SIZE(ovector));
-
-	if (ret < 0 && ret != PCRE_ERROR_NOMATCH)
-		die("pcre_exec failed with error code %d", ret);
-	if (ret > 0) {
-		ret = 0;
-		match->rm_so = ovector[0];
-		match->rm_eo = ovector[1];
-	}
-
-	return ret;
-}
-
-static void free_pcre1_regexp(struct grep_pat *p)
-{
-	pcre_free(p->pcre1_regexp);
-#ifdef PCRE_CONFIG_JIT
-	if (p->pcre1_jit_on)
-		pcre_free_study(p->pcre1_extra_info);
-	else
-#endif
-		pcre_free(p->pcre1_extra_info);
-	pcre_free((void *)p->pcre1_tables);
-}
-#else /* !USE_LIBPCRE1 */
-static void compile_pcre1_regexp(struct grep_pat *p, const struct grep_opt *opt)
-{
-	die("cannot use Perl-compatible regexes when not compiled with USE_LIBPCRE");
-}
-
-static int pcre1match(struct grep_pat *p, const char *line, const char *eol,
-		regmatch_t *match, int eflags)
-{
-	return 1;
-}
-
-static void free_pcre1_regexp(struct grep_pat *p)
-{
-}
-#endif /* !USE_LIBPCRE1 */
-
-#ifdef USE_LIBPCRE2
-static void compile_pcre2_pattern(struct grep_pat *p, const struct grep_opt *opt)
-{
-	int error;
-	PCRE2_UCHAR errbuf[256];
-	PCRE2_SIZE erroffset;
-	int options = PCRE2_MULTILINE;
-	int jitret;
-	int patinforet;
-	size_t jitsizearg;
-
-	assert(opt->pcre2);
-
-	p->pcre2_compile_context = NULL;
-
-	/* pcre2_global_context is initialized in append_grep_pattern */
-	if (opt->ignore_case) {
-		if (!opt->ignore_locale && has_non_ascii(p->pattern)) {
-			if (!pcre2_global_context)
-				BUG("pcre2_global_context uninitialized");
-			p->pcre2_tables = pcre2_maketables(pcre2_global_context);
-			p->pcre2_compile_context = pcre2_compile_context_create(NULL);
-			pcre2_set_character_tables(p->pcre2_compile_context,
-							p->pcre2_tables);
-		}
-		options |= PCRE2_CASELESS;
-	}
-	if (!opt->ignore_locale && is_utf8_locale() && has_non_ascii(p->pattern) &&
-	    !(!opt->ignore_case && (p->fixed || p->is_fixed)))
-		options |= PCRE2_UTF;
-
-	p->pcre2_pattern = pcre2_compile((PCRE2_SPTR)p->pattern,
-					 p->patternlen, options, &error, &erroffset,
-					 p->pcre2_compile_context);
-
-	if (p->pcre2_pattern) {
-		p->pcre2_match_data = pcre2_match_data_create_from_pattern(p->pcre2_pattern, NULL);
-		if (!p->pcre2_match_data)
-			die("Couldn't allocate PCRE2 match data");
-	} else {
-		pcre2_get_error_message(error, errbuf, sizeof(errbuf));
-		compile_regexp_failed(p, (const char *)&errbuf);
-	}
-
-	pcre2_config(PCRE2_CONFIG_JIT, &p->pcre2_jit_on);
-	if (opt->debug)
-		fprintf(stderr, "pcre2_jit_on=%d\n", p->pcre2_jit_on);
-	if (p->pcre2_jit_on) {
-		jitret = pcre2_jit_compile(p->pcre2_pattern, PCRE2_JIT_COMPLETE);
-		if (jitret)
-			die("Couldn't JIT the PCRE2 pattern '%s', got '%d'\n", p->pattern, jitret);
-
-		/*
-		 * The pcre2_config(PCRE2_CONFIG_JIT, ...) call just
-		 * tells us whether the library itself supports JIT,
-		 * but to see whether we're going to be actually using
-		 * JIT we need to extract PCRE2_INFO_JITSIZE from the
-		 * pattern *after* we do pcre2_jit_compile() above.
-		 *
-		 * This is because if the pattern contains the
-		 * (*NO_JIT) verb (see pcre2syntax(3))
-		 * pcre2_jit_compile() will exit early with 0. If we
-		 * then proceed to call pcre2_jit_match() further down
-		 * the line instead of pcre2_match() we'll either
-		 * segfault (pre PCRE 10.31) or run into a fatal error
-		 * (post PCRE2 10.31)
-		 */
-		patinforet = pcre2_pattern_info(p->pcre2_pattern, PCRE2_INFO_JITSIZE, &jitsizearg);
-		if (patinforet)
-			BUG("pcre2_pattern_info() failed: %d", patinforet);
-		if (jitsizearg == 0) {
-			p->pcre2_jit_on = 0;
-			if (opt->debug)
-				fprintf(stderr, "pcre2_jit_on=%d: (*NO_JIT) in regex\n",
-					p->pcre2_jit_on);
-			return;
-		}
-	}
-}
-
-static int pcre2match(struct grep_pat *p, const char *line, const char *eol,
-		regmatch_t *match, int eflags)
-{
-	int ret, flags = 0;
-	PCRE2_SIZE *ovector;
-	PCRE2_UCHAR errbuf[256];
-
-	if (eflags & REG_NOTBOL)
-		flags |= PCRE2_NOTBOL;
-
-	if (p->pcre2_jit_on)
-		ret = pcre2_jit_match(p->pcre2_pattern, (unsigned char *)line,
-				      eol - line, 0, flags, p->pcre2_match_data,
-				      NULL);
-	else
-		ret = pcre2_match(p->pcre2_pattern, (unsigned char *)line,
-				  eol - line, 0, flags, p->pcre2_match_data,
-				  NULL);
-
-	if (ret < 0 && ret != PCRE2_ERROR_NOMATCH) {
-		pcre2_get_error_message(ret, errbuf, sizeof(errbuf));
-		die("%s failed with error code %d: %s",
-		    (p->pcre2_jit_on ? "pcre2_jit_match" : "pcre2_match"), ret,
-		    errbuf);
-	}
-	if (ret > 0) {
-		ovector = pcre2_get_ovector_pointer(p->pcre2_match_data);
-		ret = 0;
-		match->rm_so = (int)ovector[0];
-		match->rm_eo = (int)ovector[1];
-	}
-
-	return ret;
-}
-
-static void free_pcre2_pattern(struct grep_pat *p)
-{
-	pcre2_compile_context_free(p->pcre2_compile_context);
-	pcre2_code_free(p->pcre2_pattern);
-	pcre2_match_data_free(p->pcre2_match_data);
-	free((void *)p->pcre2_tables);
-}
-#else /* !USE_LIBPCRE2 */
-static void compile_pcre2_pattern(struct grep_pat *p, const struct grep_opt *opt)
-{
-	/*
-	 * Unreachable until USE_LIBPCRE2 becomes synonymous with
-	 * USE_LIBPCRE. See the sibling comment in
-	 * grep_set_pattern_type_option().
-	 */
-	die("cannot use Perl-compatible regexes when not compiled with USE_LIBPCRE");
-}
-
-static int pcre2match(struct grep_pat *p, const char *line, const char *eol,
-		regmatch_t *match, int eflags)
-{
-	return 1;
-}
-
-static void free_pcre2_pattern(struct grep_pat *p)
-{
-}
-
-static void compile_fixed_regexp(struct grep_pat *p, struct grep_opt *opt)
-{
-	struct strbuf sb = STRBUF_INIT;
-	int err;
-	int regflags = 0;
-
-	basic_regex_quote_buf(&sb, p->pattern);
-	if (opt->ignore_case)
-		regflags |= REG_ICASE;
-	err = regcomp(&p->regexp, sb.buf, regflags);
-	if (opt->debug)
-		fprintf(stderr, "fixed %s\n", sb.buf);
-	strbuf_release(&sb);
-	if (err) {
-		char errbuf[1024];
-		regerror(err, &p->regexp, errbuf, sizeof(errbuf));
-		compile_regexp_failed(p, errbuf);
-	}
-}
-#endif /* !USE_LIBPCRE2 */
-
-static void compile_regexp(struct grep_pat *p, struct grep_opt *opt)
-{
-	int err;
-	int regflags = REG_NEWLINE;
-
-	p->word_regexp = opt->word_regexp;
-	p->ignore_case = opt->ignore_case;
-	p->fixed = opt->fixed;
-
-	if (memchr(p->pattern, 0, p->patternlen) && !opt->pcre2)
-		die(_("given pattern contains NULL byte (via -f <file>). This is only supported with -P under PCRE v2"));
-
-	p->is_fixed = is_fixed(p->pattern, p->patternlen);
-#ifdef USE_LIBPCRE2
-       if (!p->fixed && !p->is_fixed) {
-	       const char *no_jit = "(*NO_JIT)";
-	       const int no_jit_len = strlen(no_jit);
-	       if (starts_with(p->pattern, no_jit) &&
-		   is_fixed(p->pattern + no_jit_len,
-			    p->patternlen - no_jit_len))
-		       p->is_fixed = 1;
-       }
-#endif
-	if (p->fixed || p->is_fixed) {
-#ifdef USE_LIBPCRE2
-		opt->pcre2 = 1;
-		if (p->is_fixed) {
-			compile_pcre2_pattern(p, opt);
-		} else {
-			/*
-			 * E.g. t7811-grep-open.sh relies on the
-			 * pattern being restored.
-			 */
-			char *old_pattern = p->pattern;
-			size_t old_patternlen = p->patternlen;
-			struct strbuf sb = STRBUF_INIT;
-
-			/*
-			 * There is the PCRE2_LITERAL flag, but it's
-			 * only in PCRE v2 10.30 and later. Needing to
-			 * ifdef our way around that and dealing with
-			 * it + PCRE2_MULTILINE being an error is more
-			 * complex than just quoting this ourselves.
-			*/
-			strbuf_add(&sb, "\\Q", 2);
-			strbuf_add(&sb, p->pattern, p->patternlen);
-			strbuf_add(&sb, "\\E", 2);
-
-			p->pattern = sb.buf;
-			p->patternlen = sb.len;
-			compile_pcre2_pattern(p, opt);
-			p->pattern = old_pattern;
-			p->patternlen = old_patternlen;
-			strbuf_release(&sb);
-		}
-#else /* !USE_LIBPCRE2 */
-		compile_fixed_regexp(p, opt);
-#endif /* !USE_LIBPCRE2 */
-		return;
-	}
-
-	if (opt->pcre2) {
-		compile_pcre2_pattern(p, opt);
-		return;
-	}
-
-	if (opt->pcre1) {
-		compile_pcre1_regexp(p, opt);
-		return;
-	}
-
-	if (p->ignore_case)
-		regflags |= REG_ICASE;
-	if (opt->extended_regexp_option)
-		regflags |= REG_EXTENDED;
-	err = regcomp(&p->regexp, p->pattern, regflags);
-	if (err) {
-		char errbuf[1024];
-		regerror(err, &p->regexp, errbuf, 1024);
-		compile_regexp_failed(p, errbuf);
-	}
-}
-
-static struct grep_expr *compile_pattern_or(struct grep_pat **);
-static struct grep_expr *compile_pattern_atom(struct grep_pat **list)
-{
-	struct grep_pat *p;
-	struct grep_expr *x;
-
-	p = *list;
-	if (!p)
-		return NULL;
-	switch (p->token) {
-	case GREP_PATTERN: /* atom */
-	case GREP_PATTERN_HEAD:
-	case GREP_PATTERN_BODY:
-		x = xcalloc(1, sizeof (struct grep_expr));
-		x->node = GREP_NODE_ATOM;
-		x->u.atom = p;
-		*list = p->next;
-		return x;
-	case GREP_OPEN_PAREN:
-		*list = p->next;
-		x = compile_pattern_or(list);
-		if (!*list || (*list)->token != GREP_CLOSE_PAREN)
-			die("unmatched parenthesis");
-		*list = (*list)->next;
-		return x;
-	default:
-		return NULL;
-	}
-}
-
-static struct grep_expr *compile_pattern_not(struct grep_pat **list)
-{
-	struct grep_pat *p;
-	struct grep_expr *x;
-
-	p = *list;
-	if (!p)
-		return NULL;
-	switch (p->token) {
-	case GREP_NOT:
-		if (!p->next)
-			die("--not not followed by pattern expression");
-		*list = p->next;
-		x = xcalloc(1, sizeof (struct grep_expr));
-		x->node = GREP_NODE_NOT;
-		x->u.unary = compile_pattern_not(list);
-		if (!x->u.unary)
-			die("--not followed by non pattern expression");
-		return x;
-	default:
-		return compile_pattern_atom(list);
-	}
-}
-
-static struct grep_expr *compile_pattern_and(struct grep_pat **list)
-{
-	struct grep_pat *p;
-	struct grep_expr *x, *y, *z;
-
-	x = compile_pattern_not(list);
-	p = *list;
-	if (p && p->token == GREP_AND) {
-		if (!p->next)
-			die("--and not followed by pattern expression");
-		*list = p->next;
-		y = compile_pattern_and(list);
-		if (!y)
-			die("--and not followed by pattern expression");
-		z = xcalloc(1, sizeof (struct grep_expr));
-		z->node = GREP_NODE_AND;
-		z->u.binary.left = x;
-		z->u.binary.right = y;
-		return z;
-	}
-	return x;
-}
-
-static struct grep_expr *compile_pattern_or(struct grep_pat **list)
-{
-	struct grep_pat *p;
-	struct grep_expr *x, *y, *z;
-
-	x = compile_pattern_and(list);
-	p = *list;
-	if (x && p && p->token != GREP_CLOSE_PAREN) {
-		y = compile_pattern_or(list);
-		if (!y)
-			die("not a pattern expression %s", p->pattern);
-		z = xcalloc(1, sizeof (struct grep_expr));
-		z->node = GREP_NODE_OR;
-		z->u.binary.left = x;
-		z->u.binary.right = y;
-		return z;
-	}
-	return x;
-}
-
-static struct grep_expr *compile_pattern_expr(struct grep_pat **list)
-{
-	return compile_pattern_or(list);
-}
-
-static void indent(int in)
-{
-	while (in-- > 0)
-		fputc(' ', stderr);
-}
-
-static void dump_grep_pat(struct grep_pat *p)
-{
-	switch (p->token) {
-	case GREP_AND: fprintf(stderr, "*and*"); break;
-	case GREP_OPEN_PAREN: fprintf(stderr, "*(*"); break;
-	case GREP_CLOSE_PAREN: fprintf(stderr, "*)*"); break;
-	case GREP_NOT: fprintf(stderr, "*not*"); break;
-	case GREP_OR: fprintf(stderr, "*or*"); break;
-
-	case GREP_PATTERN: fprintf(stderr, "pattern"); break;
-	case GREP_PATTERN_HEAD: fprintf(stderr, "pattern_head"); break;
-	case GREP_PATTERN_BODY: fprintf(stderr, "pattern_body"); break;
-	}
-
-	switch (p->token) {
-	default: break;
-	case GREP_PATTERN_HEAD:
-		fprintf(stderr, "<head %d>", p->field); break;
-	case GREP_PATTERN_BODY:
-		fprintf(stderr, "<body>"); break;
-	}
-	switch (p->token) {
-	default: break;
-	case GREP_PATTERN_HEAD:
-	case GREP_PATTERN_BODY:
-	case GREP_PATTERN:
-		fprintf(stderr, "%.*s", (int)p->patternlen, p->pattern);
-		break;
-	}
-	fputc('\n', stderr);
-}
-
-static void dump_grep_expression_1(struct grep_expr *x, int in)
-{
-	indent(in);
-	switch (x->node) {
-	case GREP_NODE_TRUE:
-		fprintf(stderr, "true\n");
-		break;
-	case GREP_NODE_ATOM:
-		dump_grep_pat(x->u.atom);
-		break;
-	case GREP_NODE_NOT:
-		fprintf(stderr, "(not\n");
-		dump_grep_expression_1(x->u.unary, in+1);
-		indent(in);
-		fprintf(stderr, ")\n");
-		break;
-	case GREP_NODE_AND:
-		fprintf(stderr, "(and\n");
-		dump_grep_expression_1(x->u.binary.left, in+1);
-		dump_grep_expression_1(x->u.binary.right, in+1);
-		indent(in);
-		fprintf(stderr, ")\n");
-		break;
-	case GREP_NODE_OR:
-		fprintf(stderr, "(or\n");
-		dump_grep_expression_1(x->u.binary.left, in+1);
-		dump_grep_expression_1(x->u.binary.right, in+1);
-		indent(in);
-		fprintf(stderr, ")\n");
-		break;
-	}
-}
-
-static void dump_grep_expression(struct grep_opt *opt)
-{
-	struct grep_expr *x = opt->pattern_expression;
-
-	if (opt->all_match)
-		fprintf(stderr, "[all-match]\n");
-	dump_grep_expression_1(x, 0);
-	fflush(NULL);
-}
-
-static struct grep_expr *grep_true_expr(void)
-{
-	struct grep_expr *z = xcalloc(1, sizeof(*z));
-	z->node = GREP_NODE_TRUE;
-	return z;
-}
-
-static struct grep_expr *grep_or_expr(struct grep_expr *left, struct grep_expr *right)
-{
-	struct grep_expr *z = xcalloc(1, sizeof(*z));
-	z->node = GREP_NODE_OR;
-	z->u.binary.left = left;
-	z->u.binary.right = right;
-	return z;
-}
-
-static struct grep_expr *prep_header_patterns(struct grep_opt *opt)
-{
-	struct grep_pat *p;
-	struct grep_expr *header_expr;
-	struct grep_expr *(header_group[GREP_HEADER_FIELD_MAX]);
-	enum grep_header_field fld;
-
-	if (!opt->header_list)
-		return NULL;
-
-	for (p = opt->header_list; p; p = p->next) {
-		if (p->token != GREP_PATTERN_HEAD)
-			BUG("a non-header pattern in grep header list.");
-		if (p->field < GREP_HEADER_FIELD_MIN ||
-		    GREP_HEADER_FIELD_MAX <= p->field)
-			BUG("unknown header field %d", p->field);
-		compile_regexp(p, opt);
-	}
-
-	for (fld = 0; fld < GREP_HEADER_FIELD_MAX; fld++)
-		header_group[fld] = NULL;
-
-	for (p = opt->header_list; p; p = p->next) {
-		struct grep_expr *h;
-		struct grep_pat *pp = p;
-
-		h = compile_pattern_atom(&pp);
-		if (!h || pp != p->next)
-			BUG("malformed header expr");
-		if (!header_group[p->field]) {
-			header_group[p->field] = h;
-			continue;
-		}
-		header_group[p->field] = grep_or_expr(h, header_group[p->field]);
-	}
-
-	header_expr = NULL;
-
-	for (fld = 0; fld < GREP_HEADER_FIELD_MAX; fld++) {
-		if (!header_group[fld])
-			continue;
-		if (!header_expr)
-			header_expr = grep_true_expr();
-		header_expr = grep_or_expr(header_group[fld], header_expr);
-	}
-	return header_expr;
-}
-
-static struct grep_expr *grep_splice_or(struct grep_expr *x, struct grep_expr *y)
-{
-	struct grep_expr *z = x;
-
-	while (x) {
-		assert(x->node == GREP_NODE_OR);
-		if (x->u.binary.right &&
-		    x->u.binary.right->node == GREP_NODE_TRUE) {
-			x->u.binary.right = y;
-			break;
-		}
-		x = x->u.binary.right;
-	}
-	return z;
-}
-
-static void compile_grep_patterns_real(struct grep_opt *opt)
-{
-	struct grep_pat *p;
-	struct grep_expr *header_expr = prep_header_patterns(opt);
-
-	for (p = opt->pattern_list; p; p = p->next) {
-		switch (p->token) {
-		case GREP_PATTERN: /* atom */
-		case GREP_PATTERN_HEAD:
-		case GREP_PATTERN_BODY:
-			compile_regexp(p, opt);
-			break;
-		default:
-			opt->extended = 1;
-			break;
-		}
-	}
-
-	if (opt->all_match || header_expr)
-		opt->extended = 1;
-	else if (!opt->extended && !opt->debug)
-		return;
-
-	p = opt->pattern_list;
-	if (p)
-		opt->pattern_expression = compile_pattern_expr(&p);
-	if (p)
-		die("incomplete pattern expression: %s", p->pattern);
-
-	if (!header_expr)
-		return;
-
-	if (!opt->pattern_expression)
-		opt->pattern_expression = header_expr;
-	else if (opt->all_match)
-		opt->pattern_expression = grep_splice_or(header_expr,
-							 opt->pattern_expression);
-	else
-		opt->pattern_expression = grep_or_expr(opt->pattern_expression,
-						       header_expr);
-	opt->all_match = 1;
-}
-
-void compile_grep_patterns(struct grep_opt *opt)
-{
-	compile_grep_patterns_real(opt);
-	if (opt->debug)
-		dump_grep_expression(opt);
-}
-
-static void free_pattern_expr(struct grep_expr *x)
-{
-	switch (x->node) {
-	case GREP_NODE_TRUE:
-	case GREP_NODE_ATOM:
-		break;
-	case GREP_NODE_NOT:
-		free_pattern_expr(x->u.unary);
-		break;
-	case GREP_NODE_AND:
-	case GREP_NODE_OR:
-		free_pattern_expr(x->u.binary.left);
-		free_pattern_expr(x->u.binary.right);
-		break;
-	}
-	free(x);
-}
-
-void free_grep_patterns(struct grep_opt *opt)
-{
-	struct grep_pat *p, *n;
-
-	for (p = opt->pattern_list; p; p = n) {
-		n = p->next;
-		switch (p->token) {
-		case GREP_PATTERN: /* atom */
-		case GREP_PATTERN_HEAD:
-		case GREP_PATTERN_BODY:
-			if (p->pcre1_regexp)
-				free_pcre1_regexp(p);
-			else if (p->pcre2_pattern)
-				free_pcre2_pattern(p);
-			else
-				regfree(&p->regexp);
-			free(p->pattern);
-			break;
-		default:
-			break;
-		}
-		free(p);
-	}
-
-	if (!opt->extended)
-		return;
-	free_pattern_expr(opt->pattern_expression);
-}
-
-static char *end_of_line(char *cp, unsigned long *left)
-{
-	unsigned long l = *left;
-	while (l && *cp != '\n') {
-		l--;
-		cp++;
-	}
-	*left = l;
-	return cp;
-}
-
-static int word_char(char ch)
-{
-	return isalnum(ch) || ch == '_';
-}
-
-static void output_color(struct grep_opt *opt, const void *data, size_t size,
-			 const char *color)
-{
-	if (want_color(opt->color) && color && color[0]) {
-		opt->output(opt, color, strlen(color));
-		opt->output(opt, data, size);
-		opt->output(opt, GIT_COLOR_RESET, strlen(GIT_COLOR_RESET));
-	} else
-		opt->output(opt, data, size);
-}
-
-static void output_sep(struct grep_opt *opt, char sign)
-{
-	if (opt->null_following_name)
-		opt->output(opt, "\0", 1);
-	else
-		output_color(opt, &sign, 1, opt->colors[GREP_COLOR_SEP]);
-}
-
-static void show_name(struct grep_opt *opt, const char *name)
-{
-	output_color(opt, name, strlen(name), opt->colors[GREP_COLOR_FILENAME]);
-	opt->output(opt, opt->null_following_name ? "\0" : "\n", 1);
-}
-
-static int patmatch(struct grep_pat *p, char *line, char *eol,
-		    regmatch_t *match, int eflags)
-{
-	int hit;
-
-	if (p->pcre1_regexp)
-		hit = !pcre1match(p, line, eol, match, eflags);
-	else if (p->pcre2_pattern)
-		hit = !pcre2match(p, line, eol, match, eflags);
-	else
-		hit = !regexec_buf(&p->regexp, line, eol - line, 1, match,
-				   eflags);
-
-	return hit;
-}
-
-static int strip_timestamp(char *bol, char **eol_p)
-{
-	char *eol = *eol_p;
-	int ch;
-
-	while (bol < --eol) {
-		if (*eol != '>')
-			continue;
-		*eol_p = ++eol;
-		ch = *eol;
-		*eol = '\0';
-		return ch;
-	}
-	return 0;
-}
-
-static struct {
-	const char *field;
-	size_t len;
-} header_field[] = {
-	{ "author ", 7 },
-	{ "committer ", 10 },
-	{ "reflog ", 7 },
-};
-
-static int match_one_pattern(struct grep_pat *p, char *bol, char *eol,
-			     enum grep_context ctx,
-			     regmatch_t *pmatch, int eflags)
-{
-	int hit = 0;
-	int saved_ch = 0;
-	const char *start = bol;
-
-	if ((p->token != GREP_PATTERN) &&
-	    ((p->token == GREP_PATTERN_HEAD) != (ctx == GREP_CONTEXT_HEAD)))
-		return 0;
-
-	if (p->token == GREP_PATTERN_HEAD) {
-		const char *field;
-		size_t len;
-		assert(p->field < ARRAY_SIZE(header_field));
-		field = header_field[p->field].field;
-		len = header_field[p->field].len;
-		if (strncmp(bol, field, len))
-			return 0;
-		bol += len;
-		switch (p->field) {
-		case GREP_HEADER_AUTHOR:
-		case GREP_HEADER_COMMITTER:
-			saved_ch = strip_timestamp(bol, &eol);
-			break;
-		default:
-			break;
-		}
-	}
-
- again:
-	hit = patmatch(p, bol, eol, pmatch, eflags);
-
-	if (hit && p->word_regexp) {
-		if ((pmatch[0].rm_so < 0) ||
-		    (eol - bol) < pmatch[0].rm_so ||
-		    (pmatch[0].rm_eo < 0) ||
-		    (eol - bol) < pmatch[0].rm_eo)
-			die("regexp returned nonsense");
-
-		/* Match beginning must be either beginning of the
-		 * line, or at word boundary (i.e. the last char must
-		 * not be a word char).  Similarly, match end must be
-		 * either end of the line, or at word boundary
-		 * (i.e. the next char must not be a word char).
-		 */
-		if ( ((pmatch[0].rm_so == 0) ||
-		      !word_char(bol[pmatch[0].rm_so-1])) &&
-		     ((pmatch[0].rm_eo == (eol-bol)) ||
-		      !word_char(bol[pmatch[0].rm_eo])) )
-			;
-		else
-			hit = 0;
-
-		/* Words consist of at least one character. */
-		if (pmatch->rm_so == pmatch->rm_eo)
-			hit = 0;
-
-		if (!hit && pmatch[0].rm_so + bol + 1 < eol) {
-			/* There could be more than one match on the
-			 * line, and the first match might not be
-			 * strict word match.  But later ones could be!
-			 * Forward to the next possible start, i.e. the
-			 * next position following a non-word char.
-			 */
-			bol = pmatch[0].rm_so + bol + 1;
-			while (word_char(bol[-1]) && bol < eol)
-				bol++;
-			eflags |= REG_NOTBOL;
-			if (bol < eol)
-				goto again;
-		}
-	}
-	if (p->token == GREP_PATTERN_HEAD && saved_ch)
-		*eol = saved_ch;
-	if (hit) {
-		pmatch[0].rm_so += bol - start;
-		pmatch[0].rm_eo += bol - start;
-	}
-	return hit;
-}
-
-static int match_expr_eval(struct grep_opt *opt, struct grep_expr *x, char *bol,
-			   char *eol, enum grep_context ctx, ssize_t *col,
-			   ssize_t *icol, int collect_hits)
-{
-	int h = 0;
-
-	if (!x)
-		die("Not a valid grep expression");
-	switch (x->node) {
-	case GREP_NODE_TRUE:
-		h = 1;
-		break;
-	case GREP_NODE_ATOM:
-		{
-			regmatch_t tmp;
-			h = match_one_pattern(x->u.atom, bol, eol, ctx,
-					      &tmp, 0);
-			if (h && (*col < 0 || tmp.rm_so < *col))
-				*col = tmp.rm_so;
-		}
-		break;
-	case GREP_NODE_NOT:
-		/*
-		 * Upon visiting a GREP_NODE_NOT, col and icol become swapped.
-		 */
-		h = !match_expr_eval(opt, x->u.unary, bol, eol, ctx, icol, col,
-				     0);
-		break;
-	case GREP_NODE_AND:
-		h = match_expr_eval(opt, x->u.binary.left, bol, eol, ctx, col,
-				    icol, 0);
-		if (h || opt->columnnum) {
-			/*
-			 * Don't short-circuit AND when given --column, since a
-			 * NOT earlier in the tree may turn this into an OR. In
-			 * this case, see the below comment.
-			 */
-			h &= match_expr_eval(opt, x->u.binary.right, bol, eol,
-					     ctx, col, icol, 0);
-		}
-		break;
-	case GREP_NODE_OR:
-		if (!(collect_hits || opt->columnnum)) {
-			/*
-			 * Don't short-circuit OR when given --column (or
-			 * collecting hits) to ensure we don't skip a later
-			 * child that would produce an earlier match.
-			 */
-			return (match_expr_eval(opt, x->u.binary.left, bol, eol,
-						ctx, col, icol, 0) ||
-				match_expr_eval(opt, x->u.binary.right, bol,
-						eol, ctx, col, icol, 0));
-		}
-		h = match_expr_eval(opt, x->u.binary.left, bol, eol, ctx, col,
-				    icol, 0);
-		if (collect_hits)
-			x->u.binary.left->hit |= h;
-		h |= match_expr_eval(opt, x->u.binary.right, bol, eol, ctx, col,
-				     icol, collect_hits);
-		break;
-	default:
-		die("Unexpected node type (internal error) %d", x->node);
-	}
-	if (collect_hits)
-		x->hit |= h;
-	return h;
-}
-
-static int match_expr(struct grep_opt *opt, char *bol, char *eol,
-		      enum grep_context ctx, ssize_t *col,
-		      ssize_t *icol, int collect_hits)
-{
-	struct grep_expr *x = opt->pattern_expression;
-	return match_expr_eval(opt, x, bol, eol, ctx, col, icol, collect_hits);
-}
-
-static int match_line(struct grep_opt *opt, char *bol, char *eol,
-		      ssize_t *col, ssize_t *icol,
-		      enum grep_context ctx, int collect_hits)
-{
-	struct grep_pat *p;
-	int hit = 0;
-
-	if (opt->extended)
-		return match_expr(opt, bol, eol, ctx, col, icol,
-				  collect_hits);
-
-	/* we do not call with collect_hits without being extended */
-	for (p = opt->pattern_list; p; p = p->next) {
-		regmatch_t tmp;
-		if (match_one_pattern(p, bol, eol, ctx, &tmp, 0)) {
-			hit |= 1;
-			if (!opt->columnnum) {
-				/*
-				 * Without --column, any single match on a line
-				 * is enough to know that it needs to be
-				 * printed. With --column, scan _all_ patterns
-				 * to find the earliest.
-				 */
-				break;
-			}
-			if (*col < 0 || tmp.rm_so < *col)
-				*col = tmp.rm_so;
-		}
-	}
-	return hit;
-}
-
-static int match_next_pattern(struct grep_pat *p, char *bol, char *eol,
-			      enum grep_context ctx,
-			      regmatch_t *pmatch, int eflags)
-{
-	regmatch_t match;
-
-	if (!match_one_pattern(p, bol, eol, ctx, &match, eflags))
-		return 0;
-	if (match.rm_so < 0 || match.rm_eo < 0)
-		return 0;
-	if (pmatch->rm_so >= 0 && pmatch->rm_eo >= 0) {
-		if (match.rm_so > pmatch->rm_so)
-			return 1;
-		if (match.rm_so == pmatch->rm_so && match.rm_eo < pmatch->rm_eo)
-			return 1;
-	}
-	pmatch->rm_so = match.rm_so;
-	pmatch->rm_eo = match.rm_eo;
-	return 1;
-}
-
-static int next_match(struct grep_opt *opt, char *bol, char *eol,
-		      enum grep_context ctx, regmatch_t *pmatch, int eflags)
-{
-	struct grep_pat *p;
-	int hit = 0;
-
-	pmatch->rm_so = pmatch->rm_eo = -1;
-	if (bol < eol) {
-		for (p = opt->pattern_list; p; p = p->next) {
-			switch (p->token) {
-			case GREP_PATTERN: /* atom */
-			case GREP_PATTERN_HEAD:
-			case GREP_PATTERN_BODY:
-				hit |= match_next_pattern(p, bol, eol, ctx,
-							  pmatch, eflags);
-				break;
-			default:
-				break;
-			}
-		}
-	}
-	return hit;
-}
-
-static void show_line_header(struct grep_opt *opt, const char *name,
-			     unsigned lno, ssize_t cno, char sign)
-{
-	if (opt->heading && opt->last_shown == 0) {
-		output_color(opt, name, strlen(name), opt->colors[GREP_COLOR_FILENAME]);
-		opt->output(opt, "\n", 1);
-	}
-	opt->last_shown = lno;
-
-	if (!opt->heading && opt->pathname) {
-		output_color(opt, name, strlen(name), opt->colors[GREP_COLOR_FILENAME]);
-		output_sep(opt, sign);
-	}
-	if (opt->linenum) {
-		char buf[32];
-		xsnprintf(buf, sizeof(buf), "%d", lno);
-		output_color(opt, buf, strlen(buf), opt->colors[GREP_COLOR_LINENO]);
-		output_sep(opt, sign);
-	}
-	/*
-	 * Treat 'cno' as the 1-indexed offset from the start of a non-context
-	 * line to its first match. Otherwise, 'cno' is 0 indicating that we are
-	 * being called with a context line.
-	 */
-	if (opt->columnnum && cno) {
-		char buf[32];
-		xsnprintf(buf, sizeof(buf), "%"PRIuMAX, (uintmax_t)cno);
-		output_color(opt, buf, strlen(buf), opt->colors[GREP_COLOR_COLUMNNO]);
-		output_sep(opt, sign);
-	}
-}
-
-static void show_line(struct grep_opt *opt, char *bol, char *eol,
-		      const char *name, unsigned lno, ssize_t cno, char sign)
-{
-	int rest = eol - bol;
-	const char *match_color = NULL;
-	const char *line_color = NULL;
-
-	if (opt->file_break && opt->last_shown == 0) {
-		if (opt->show_hunk_mark)
-			opt->output(opt, "\n", 1);
-	} else if (opt->pre_context || opt->post_context || opt->funcbody) {
-		if (opt->last_shown == 0) {
-			if (opt->show_hunk_mark) {
-				output_color(opt, "--", 2, opt->colors[GREP_COLOR_SEP]);
-				opt->output(opt, "\n", 1);
-			}
-		} else if (lno > opt->last_shown + 1) {
-			output_color(opt, "--", 2, opt->colors[GREP_COLOR_SEP]);
-			opt->output(opt, "\n", 1);
-		}
-	}
-	if (!opt->only_matching) {
-		/*
-		 * In case the line we're being called with contains more than
-		 * one match, leave printing each header to the loop below.
-		 */
-		show_line_header(opt, name, lno, cno, sign);
-	}
-	if (opt->color || opt->only_matching) {
-		regmatch_t match;
-		enum grep_context ctx = GREP_CONTEXT_BODY;
-		int ch = *eol;
-		int eflags = 0;
-
-		if (opt->color) {
-			if (sign == ':')
-				match_color = opt->colors[GREP_COLOR_MATCH_SELECTED];
-			else
-				match_color = opt->colors[GREP_COLOR_MATCH_CONTEXT];
-			if (sign == ':')
-				line_color = opt->colors[GREP_COLOR_SELECTED];
-			else if (sign == '-')
-				line_color = opt->colors[GREP_COLOR_CONTEXT];
-			else if (sign == '=')
-				line_color = opt->colors[GREP_COLOR_FUNCTION];
-		}
-		*eol = '\0';
-		while (next_match(opt, bol, eol, ctx, &match, eflags)) {
-			if (match.rm_so == match.rm_eo)
-				break;
-
-			if (opt->only_matching)
-				show_line_header(opt, name, lno, cno, sign);
-			else
-				output_color(opt, bol, match.rm_so, line_color);
-			output_color(opt, bol + match.rm_so,
-				     match.rm_eo - match.rm_so, match_color);
-			if (opt->only_matching)
-				opt->output(opt, "\n", 1);
-			bol += match.rm_eo;
-			cno += match.rm_eo;
-			rest -= match.rm_eo;
-			eflags = REG_NOTBOL;
-		}
-		*eol = ch;
-	}
-	if (!opt->only_matching) {
-		output_color(opt, bol, rest, line_color);
-		opt->output(opt, "\n", 1);
-	}
-}
-
-int grep_use_locks;
-
-/*
- * This lock protects access to the gitattributes machinery, which is
- * not thread-safe.
- */
-pthread_mutex_t grep_attr_mutex;
-
-static inline void grep_attr_lock(void)
-{
-	if (grep_use_locks)
-		pthread_mutex_lock(&grep_attr_mutex);
-}
-
-static inline void grep_attr_unlock(void)
-{
-	if (grep_use_locks)
-		pthread_mutex_unlock(&grep_attr_mutex);
-}
-
-static int match_funcname(struct grep_opt *opt, struct grep_source *gs, char *bol, char *eol)
-{
-	xdemitconf_t *xecfg = opt->priv;
-	if (xecfg && !xecfg->find_func) {
-		grep_source_load_driver(gs, opt->repo->index);
-		if (gs->driver->funcname.pattern) {
-			const struct userdiff_funcname *pe = &gs->driver->funcname;
-			xdiff_set_find_func(xecfg, pe->pattern, pe->cflags);
-		} else {
-			xecfg = opt->priv = NULL;
-		}
-	}
-
-	if (xecfg) {
-		char buf[1];
-		return xecfg->find_func(bol, eol - bol, buf, 1,
-					xecfg->find_func_priv) >= 0;
-	}
-
-	if (bol == eol)
-		return 0;
-	if (isalpha(*bol) || *bol == '_' || *bol == '$')
-		return 1;
-	return 0;
-}
-
-static void show_funcname_line(struct grep_opt *opt, struct grep_source *gs,
-			       char *bol, unsigned lno)
-{
-	while (bol > gs->buf) {
-		char *eol = --bol;
-
-		while (bol > gs->buf && bol[-1] != '\n')
-			bol--;
-		lno--;
-
-		if (lno <= opt->last_shown)
-			break;
-
-		if (match_funcname(opt, gs, bol, eol)) {
-			show_line(opt, bol, eol, gs->name, lno, 0, '=');
-			break;
-		}
-	}
-}
-
-static int is_empty_line(const char *bol, const char *eol);
-
-static void show_pre_context(struct grep_opt *opt, struct grep_source *gs,
-			     char *bol, char *end, unsigned lno)
-{
-	unsigned cur = lno, from = 1, funcname_lno = 0, orig_from;
-	int funcname_needed = !!opt->funcname, comment_needed = 0;
-
-	if (opt->pre_context < lno)
-		from = lno - opt->pre_context;
-	if (from <= opt->last_shown)
-		from = opt->last_shown + 1;
-	orig_from = from;
-	if (opt->funcbody) {
-		if (match_funcname(opt, gs, bol, end))
-			comment_needed = 1;
-		else
-			funcname_needed = 1;
-		from = opt->last_shown + 1;
-	}
-
-	/* Rewind. */
-	while (bol > gs->buf && cur > from) {
-		char *next_bol = bol;
-		char *eol = --bol;
-
-		while (bol > gs->buf && bol[-1] != '\n')
-			bol--;
-		cur--;
-		if (comment_needed && (is_empty_line(bol, eol) ||
-				       match_funcname(opt, gs, bol, eol))) {
-			comment_needed = 0;
-			from = orig_from;
-			if (cur < from) {
-				cur++;
-				bol = next_bol;
-				break;
-			}
-		}
-		if (funcname_needed && match_funcname(opt, gs, bol, eol)) {
-			funcname_lno = cur;
-			funcname_needed = 0;
-			if (opt->funcbody)
-				comment_needed = 1;
-			else
-				from = orig_from;
-		}
-	}
-
-	/* We need to look even further back to find a function signature. */
-	if (opt->funcname && funcname_needed)
-		show_funcname_line(opt, gs, bol, cur);
-
-	/* Back forward. */
-	while (cur < lno) {
-		char *eol = bol, sign = (cur == funcname_lno) ? '=' : '-';
-
-		while (*eol != '\n')
-			eol++;
-		show_line(opt, bol, eol, gs->name, cur, 0, sign);
-		bol = eol + 1;
-		cur++;
-	}
-}
-
-static int should_lookahead(struct grep_opt *opt)
-{
-	struct grep_pat *p;
-
-	if (opt->extended)
-		return 0; /* punt for too complex stuff */
-	if (opt->invert)
-		return 0;
-	for (p = opt->pattern_list; p; p = p->next) {
-		if (p->token != GREP_PATTERN)
-			return 0; /* punt for "header only" and stuff */
-	}
-	return 1;
-}
-
-static int look_ahead(struct grep_opt *opt,
-		      unsigned long *left_p,
-		      unsigned *lno_p,
-		      char **bol_p)
-{
-	unsigned lno = *lno_p;
-	char *bol = *bol_p;
-	struct grep_pat *p;
-	char *sp, *last_bol;
-	regoff_t earliest = -1;
-
-	for (p = opt->pattern_list; p; p = p->next) {
-		int hit;
-		regmatch_t m;
-
-		hit = patmatch(p, bol, bol + *left_p, &m, 0);
-		if (!hit || m.rm_so < 0 || m.rm_eo < 0)
-			continue;
-		if (earliest < 0 || m.rm_so < earliest)
-			earliest = m.rm_so;
-	}
-
-	if (earliest < 0) {
-		*bol_p = bol + *left_p;
-		*left_p = 0;
-		return 1;
-	}
-	for (sp = bol + earliest; bol < sp && sp[-1] != '\n'; sp--)
-		; /* find the beginning of the line */
-	last_bol = sp;
-
-	for (sp = bol; sp < last_bol; sp++) {
-		if (*sp == '\n')
-			lno++;
-	}
-	*left_p -= last_bol - bol;
-	*bol_p = last_bol;
-	*lno_p = lno;
-	return 0;
-}
-
-static int fill_textconv_grep(struct repository *r,
-			      struct userdiff_driver *driver,
-			      struct grep_source *gs)
-{
-	struct diff_filespec *df;
-	char *buf;
-	size_t size;
-
-	if (!driver || !driver->textconv)
-		return grep_source_load(gs);
-
-	/*
-	 * The textconv interface is intimately tied to diff_filespecs, so we
-	 * have to pretend to be one. If we could unify the grep_source
-	 * and diff_filespec structs, this mess could just go away.
-	 */
-	df = alloc_filespec(gs->path);
-	switch (gs->type) {
-	case GREP_SOURCE_OID:
-		fill_filespec(df, gs->identifier, 1, 0100644);
-		break;
-	case GREP_SOURCE_FILE:
-		fill_filespec(df, &null_oid, 0, 0100644);
-		break;
-	default:
-		BUG("attempt to textconv something without a path?");
-	}
-
-	/*
-	 * fill_textconv is not remotely thread-safe; it modifies the global
-	 * diff tempfile structure, writes to the_repo's odb and might
-	 * internally call thread-unsafe functions such as the
-	 * prepare_packed_git() lazy-initializator. Because of the last two, we
-	 * must ensure mutual exclusion between this call and the object reading
-	 * API, thus we use obj_read_lock() here.
-	 *
-	 * TODO: allowing text conversion to run in parallel with object
-	 * reading operations might increase performance in the multithreaded
-	 * non-worktreee git-grep with --textconv.
-	 */
-	obj_read_lock();
-	size = fill_textconv(r, driver, df, &buf);
-	obj_read_unlock();
-	free_filespec(df);
-
-	/*
-	 * The normal fill_textconv usage by the diff machinery would just keep
-	 * the textconv'd buf separate from the diff_filespec. But much of the
-	 * grep code passes around a grep_source and assumes that its "buf"
-	 * pointer is the beginning of the thing we are searching. So let's
-	 * install our textconv'd version into the grep_source, taking care not
-	 * to leak any existing buffer.
-	 */
-	grep_source_clear_data(gs);
-	gs->buf = buf;
-	gs->size = size;
-
-	return 0;
-}
-
-static int is_empty_line(const char *bol, const char *eol)
-{
-	while (bol < eol && isspace(*bol))
-		bol++;
-	return bol == eol;
-}
-
-static int grep_source_1(struct grep_opt *opt, struct grep_source *gs, int collect_hits)
-{
-	char *bol;
-	char *peek_bol = NULL;
-	unsigned long left;
-	unsigned lno = 1;
-	unsigned last_hit = 0;
-	int binary_match_only = 0;
-	unsigned count = 0;
-	int try_lookahead = 0;
-	int show_function = 0;
-	struct userdiff_driver *textconv = NULL;
-	enum grep_context ctx = GREP_CONTEXT_HEAD;
-	xdemitconf_t xecfg;
-
-	if (!opt->status_only && gs->name == NULL)
-		BUG("grep call which could print a name requires "
-		    "grep_source.name be non-NULL");
-
-	if (!opt->output)
-		opt->output = std_output;
-
-	if (opt->pre_context || opt->post_context || opt->file_break ||
-	    opt->funcbody) {
-		/* Show hunk marks, except for the first file. */
-		if (opt->last_shown)
-			opt->show_hunk_mark = 1;
-		/*
-		 * If we're using threads then we can't easily identify
-		 * the first file.  Always put hunk marks in that case
-		 * and skip the very first one later in work_done().
-		 */
-		if (opt->output != std_output)
-			opt->show_hunk_mark = 1;
-	}
-	opt->last_shown = 0;
-
-	if (opt->allow_textconv) {
-		grep_source_load_driver(gs, opt->repo->index);
-		/*
-		 * We might set up the shared textconv cache data here, which
-		 * is not thread-safe. Also, get_oid_with_context() and
-		 * parse_object() might be internally called. As they are not
-		 * currently thread-safe and might be racy with object reading,
-		 * obj_read_lock() must be called.
-		 */
-		grep_attr_lock();
-		obj_read_lock();
-		textconv = userdiff_get_textconv(opt->repo, gs->driver);
-		obj_read_unlock();
-		grep_attr_unlock();
-	}
-
-	/*
-	 * We know the result of a textconv is text, so we only have to care
-	 * about binary handling if we are not using it.
-	 */
-	if (!textconv) {
-		switch (opt->binary) {
-		case GREP_BINARY_DEFAULT:
-			if (grep_source_is_binary(gs, opt->repo->index))
-				binary_match_only = 1;
-			break;
-		case GREP_BINARY_NOMATCH:
-			if (grep_source_is_binary(gs, opt->repo->index))
-				return 0; /* Assume unmatch */
-			break;
-		case GREP_BINARY_TEXT:
-			break;
-		default:
-			BUG("unknown binary handling mode");
-		}
-	}
-
-	memset(&xecfg, 0, sizeof(xecfg));
-	opt->priv = &xecfg;
-
-	try_lookahead = should_lookahead(opt);
-
-	if (fill_textconv_grep(opt->repo, textconv, gs) < 0)
-		return 0;
-
-	bol = gs->buf;
-	left = gs->size;
-	while (left) {
-		char *eol, ch;
-		int hit;
-		ssize_t cno;
-		ssize_t col = -1, icol = -1;
-
-		/*
-		 * look_ahead() skips quickly to the line that possibly
-		 * has the next hit; don't call it if we need to do
-		 * something more than just skipping the current line
-		 * in response to an unmatch for the current line.  E.g.
-		 * inside a post-context window, we will show the current
-		 * line as a context around the previous hit when it
-		 * doesn't hit.
-		 */
-		if (try_lookahead
-		    && !(last_hit
-			 && (show_function ||
-			     lno <= last_hit + opt->post_context))
-		    && look_ahead(opt, &left, &lno, &bol))
-			break;
-		eol = end_of_line(bol, &left);
-		ch = *eol;
-		*eol = 0;
-
-		if ((ctx == GREP_CONTEXT_HEAD) && (eol == bol))
-			ctx = GREP_CONTEXT_BODY;
-
-		hit = match_line(opt, bol, eol, &col, &icol, ctx, collect_hits);
-		*eol = ch;
-
-		if (collect_hits)
-			goto next_line;
-
-		/* "grep -v -e foo -e bla" should list lines
-		 * that do not have either, so inversion should
-		 * be done outside.
-		 */
-		if (opt->invert)
-			hit = !hit;
-		if (opt->unmatch_name_only) {
-			if (hit)
-				return 0;
-			goto next_line;
-		}
-		if (hit) {
-			count++;
-			if (opt->status_only)
-				return 1;
-			if (opt->name_only) {
-				show_name(opt, gs->name);
-				return 1;
-			}
-			if (opt->count)
-				goto next_line;
-			if (binary_match_only) {
-				opt->output(opt, "Binary file ", 12);
-				output_color(opt, gs->name, strlen(gs->name),
-					     opt->colors[GREP_COLOR_FILENAME]);
-				opt->output(opt, " matches\n", 9);
-				return 1;
-			}
-			/* Hit at this line.  If we haven't shown the
-			 * pre-context lines, we would need to show them.
-			 */
-			if (opt->pre_context || opt->funcbody)
-				show_pre_context(opt, gs, bol, eol, lno);
-			else if (opt->funcname)
-				show_funcname_line(opt, gs, bol, lno);
-			cno = opt->invert ? icol : col;
-			if (cno < 0) {
-				/*
-				 * A negative cno indicates that there was no
-				 * match on the line. We are thus inverted and
-				 * being asked to show all lines that _don't_
-				 * match a given expression. Therefore, set cno
-				 * to 0 to suggest the whole line matches.
-				 */
-				cno = 0;
-			}
-			show_line(opt, bol, eol, gs->name, lno, cno + 1, ':');
-			last_hit = lno;
-			if (opt->funcbody)
-				show_function = 1;
-			goto next_line;
-		}
-		if (show_function && (!peek_bol || peek_bol < bol)) {
-			unsigned long peek_left = left;
-			char *peek_eol = eol;
-
-			/*
-			 * Trailing empty lines are not interesting.
-			 * Peek past them to see if they belong to the
-			 * body of the current function.
-			 */
-			peek_bol = bol;
-			while (is_empty_line(peek_bol, peek_eol)) {
-				peek_bol = peek_eol + 1;
-				peek_eol = end_of_line(peek_bol, &peek_left);
-			}
-
-			if (match_funcname(opt, gs, peek_bol, peek_eol))
-				show_function = 0;
-		}
-		if (show_function ||
-		    (last_hit && lno <= last_hit + opt->post_context)) {
-			/* If the last hit is within the post context,
-			 * we need to show this line.
-			 */
-			show_line(opt, bol, eol, gs->name, lno, col + 1, '-');
-		}
-
-	next_line:
-		bol = eol + 1;
-		if (!left)
-			break;
-		left--;
-		lno++;
-	}
-
-	if (collect_hits)
-		return 0;
-
-	if (opt->status_only)
-		return opt->unmatch_name_only;
-	if (opt->unmatch_name_only) {
-		/* We did not see any hit, so we want to show this */
-		show_name(opt, gs->name);
-		return 1;
-	}
-
-	xdiff_clear_find_func(&xecfg);
-	opt->priv = NULL;
-
-	/* NEEDSWORK:
-	 * The real "grep -c foo *.c" gives many "bar.c:0" lines,
-	 * which feels mostly useless but sometimes useful.  Maybe
-	 * make it another option?  For now suppress them.
-	 */
-	if (opt->count && count) {
-		char buf[32];
-		if (opt->pathname) {
-			output_color(opt, gs->name, strlen(gs->name),
-				     opt->colors[GREP_COLOR_FILENAME]);
-			output_sep(opt, ':');
-		}
-		xsnprintf(buf, sizeof(buf), "%u\n", count);
-		opt->output(opt, buf, strlen(buf));
-		return 1;
-	}
-	return !!last_hit;
-}
-
-static void clr_hit_marker(struct grep_expr *x)
-{
-	/* All-hit markers are meaningful only at the very top level
-	 * OR node.
-	 */
-	while (1) {
-		x->hit = 0;
-		if (x->node != GREP_NODE_OR)
-			return;
-		x->u.binary.left->hit = 0;
-		x = x->u.binary.right;
-	}
-}
-
-static int chk_hit_marker(struct grep_expr *x)
-{
-	/* Top level nodes have hit markers.  See if they all are hits */
-	while (1) {
-		if (x->node != GREP_NODE_OR)
-			return x->hit;
-		if (!x->u.binary.left->hit)
-			return 0;
-		x = x->u.binary.right;
-	}
-}
-
-int grep_source(struct grep_opt *opt, struct grep_source *gs)
-{
-	/*
-	 * we do not have to do the two-pass grep when we do not check
-	 * buffer-wide "all-match".
-	 */
-	if (!opt->all_match)
-		return grep_source_1(opt, gs, 0);
-
-	/* Otherwise the toplevel "or" terms hit a bit differently.
-	 * We first clear hit markers from them.
-	 */
-	clr_hit_marker(opt->pattern_expression);
-	grep_source_1(opt, gs, 1);
-
-	if (!chk_hit_marker(opt->pattern_expression))
-		return 0;
-
-	return grep_source_1(opt, gs, 0);
-}
-
-int grep_buffer(struct grep_opt *opt, char *buf, unsigned long size)
-{
-	struct grep_source gs;
-	int r;
-
-	grep_source_init(&gs, GREP_SOURCE_BUF, NULL, NULL, NULL);
-	gs.buf = buf;
-	gs.size = size;
-
-	r = grep_source(opt, &gs);
-
-	grep_source_clear(&gs);
-	return r;
-}
-
-void grep_source_init(struct grep_source *gs, enum grep_source_type type,
-		      const char *name, const char *path,
-		      const void *identifier)
-{
-	gs->type = type;
-	gs->name = xstrdup_or_null(name);
-	gs->path = xstrdup_or_null(path);
-	gs->buf = NULL;
-	gs->size = 0;
-	gs->driver = NULL;
-
-	switch (type) {
-	case GREP_SOURCE_FILE:
-		gs->identifier = xstrdup(identifier);
-		break;
-	case GREP_SOURCE_OID:
-		gs->identifier = oiddup(identifier);
-		break;
-	case GREP_SOURCE_BUF:
-		gs->identifier = NULL;
-		break;
-	}
-}
-
-void grep_source_clear(struct grep_source *gs)
-{
-	FREE_AND_NULL(gs->name);
-	FREE_AND_NULL(gs->path);
-	FREE_AND_NULL(gs->identifier);
-	grep_source_clear_data(gs);
-}
-
-void grep_source_clear_data(struct grep_source *gs)
-{
-	switch (gs->type) {
-	case GREP_SOURCE_FILE:
-	case GREP_SOURCE_OID:
-		FREE_AND_NULL(gs->buf);
-		gs->size = 0;
-		break;
-	case GREP_SOURCE_BUF:
-		/* leave user-provided buf intact */
-		break;
-	}
-}
-
-static int grep_source_load_oid(struct grep_source *gs)
-{
-	enum object_type type;
-
-	gs->buf = read_object_file(gs->identifier, &type, &gs->size);
-	if (!gs->buf)
-		return error(_("'%s': unable to read %s"),
-			     gs->name,
-			     oid_to_hex(gs->identifier));
-	return 0;
-}
-
-static int grep_source_load_file(struct grep_source *gs)
-{
-	const char *filename = gs->identifier;
-	struct stat st;
-	char *data;
-	size_t size;
-	int i;
-
-	if (lstat(filename, &st) < 0) {
-	err_ret:
-		if (errno != ENOENT)
-			error_errno(_("failed to stat '%s'"), filename);
-		return -1;
-	}
-	if (!S_ISREG(st.st_mode))
-		return -1;
-	size = xsize_t(st.st_size);
-	i = open(filename, O_RDONLY);
-	if (i < 0)
-		goto err_ret;
-	data = xmallocz(size);
-	if (st.st_size != read_in_full(i, data, size)) {
-		error_errno(_("'%s': short read"), filename);
-		close(i);
-		free(data);
-		return -1;
-	}
-	close(i);
-
-	gs->buf = data;
-	gs->size = size;
-	return 0;
-}
-
-static int grep_source_load(struct grep_source *gs)
-{
-	if (gs->buf)
-		return 0;
-
-	switch (gs->type) {
-	case GREP_SOURCE_FILE:
-		return grep_source_load_file(gs);
-	case GREP_SOURCE_OID:
-		return grep_source_load_oid(gs);
-	case GREP_SOURCE_BUF:
-		return gs->buf ? 0 : -1;
-	}
-	BUG("invalid grep_source type to load");
-}
-
-void grep_source_load_driver(struct grep_source *gs,
-			     struct index_state *istate)
-{
-	if (gs->driver)
-		return;
-
-	grep_attr_lock();
-	if (gs->path)
-		gs->driver = userdiff_find_by_path(istate, gs->path);
-	if (!gs->driver)
-		gs->driver = userdiff_find_by_name("default");
-	grep_attr_unlock();
-}
-
-static int grep_source_is_binary(struct grep_source *gs,
-				 struct index_state *istate)
-{
-	grep_source_load_driver(gs, istate);
-	if (gs->driver->binary != -1)
-		return gs->driver->binary;
-
-	if (!grep_source_load(gs))
-		return buffer_is_binary(gs->buf, gs->size);
-
-	return 0;
-}