summaryrefslogtreecommitdiff
path: root/diffcore-pickaxe.c
diff options
context:
space:
mode:
Diffstat (limited to 'diffcore-pickaxe.c')
-rw-r--r--diffcore-pickaxe.c355
1 files changed, 161 insertions, 194 deletions
diff --git a/diffcore-pickaxe.c b/diffcore-pickaxe.c
index ea03b9107e..341529b5a8 100644
--- a/diffcore-pickaxe.c
+++ b/diffcore-pickaxe.c
@@ -6,6 +6,13 @@
#include "diff.h"
#include "diffcore.h"
#include "xdiff-interface.h"
+#include "kwset.h"
+#include "commit.h"
+#include "quote.h"
+
+typedef int (*pickaxe_fn)(mmfile_t *one, mmfile_t *two,
+ struct diff_options *o,
+ regex_t *regexp, kwset_t kws);
struct diffgrep_cb {
regex_t *regexp;
@@ -16,7 +23,6 @@ static void diffgrep_consume(void *priv, char *line, unsigned long len)
{
struct diffgrep_cb *data = priv;
regmatch_t regmatch;
- int hold;
if (line[0] != '+' && line[0] != '-')
return;
@@ -26,98 +32,152 @@ static void diffgrep_consume(void *priv, char *line, unsigned long len)
* caller early.
*/
return;
- /* Yuck -- line ought to be "const char *"! */
- hold = line[len];
- line[len] = '\0';
- data->hit = !regexec(data->regexp, line + 1, 1, &regmatch, 0);
- line[len] = hold;
+ data->hit = !regexec_buf(data->regexp, line + 1, len - 1, 1,
+ &regmatch, 0);
}
-static void fill_one(struct diff_filespec *one,
- mmfile_t *mf, struct userdiff_driver **textconv)
+static int diff_grep(mmfile_t *one, mmfile_t *two,
+ struct diff_options *o,
+ regex_t *regexp, kwset_t kws)
{
- if (DIFF_FILE_VALID(one)) {
- *textconv = get_textconv(one);
- mf->size = fill_textconv(*textconv, one, &mf->ptr);
- } else {
- memset(mf, 0, sizeof(*mf));
+ regmatch_t regmatch;
+ struct diffgrep_cb ecbdata;
+ xpparam_t xpp;
+ xdemitconf_t xecfg;
+
+ if (!one)
+ return !regexec_buf(regexp, two->ptr, two->size,
+ 1, &regmatch, 0);
+ if (!two)
+ return !regexec_buf(regexp, one->ptr, one->size,
+ 1, &regmatch, 0);
+
+ /*
+ * We have both sides; need to run textual diff and see if
+ * the pattern appears on added/deleted lines.
+ */
+ memset(&xpp, 0, sizeof(xpp));
+ memset(&xecfg, 0, sizeof(xecfg));
+ ecbdata.regexp = regexp;
+ ecbdata.hit = 0;
+ xecfg.ctxlen = o->context;
+ xecfg.interhunkctxlen = o->interhunkcontext;
+ if (xdi_diff_outf(one, two, diffgrep_consume, &ecbdata, &xpp, &xecfg))
+ return 0;
+ return ecbdata.hit;
+}
+
+static unsigned int contains(mmfile_t *mf, regex_t *regexp, kwset_t kws)
+{
+ unsigned int cnt;
+ unsigned long sz;
+ const char *data;
+
+ sz = mf->size;
+ data = mf->ptr;
+ cnt = 0;
+
+ if (regexp) {
+ regmatch_t regmatch;
+ int flags = 0;
+
+ while (sz && *data &&
+ !regexec_buf(regexp, data, sz, 1, &regmatch, flags)) {
+ flags |= REG_NOTBOL;
+ data += regmatch.rm_eo;
+ sz -= regmatch.rm_eo;
+ if (sz && *data && regmatch.rm_so == regmatch.rm_eo) {
+ data++;
+ sz--;
+ }
+ cnt++;
+ }
+
+ } else { /* Classic exact string match */
+ while (sz) {
+ struct kwsmatch kwsm;
+ size_t offset = kwsexec(kws, data, sz, &kwsm);
+ if (offset == -1)
+ break;
+ sz -= offset + kwsm.size[0];
+ data += offset + kwsm.size[0];
+ cnt++;
+ }
}
+ return cnt;
}
-static int diff_grep(struct diff_filepair *p, regex_t *regexp, struct diff_options *o)
+static int has_changes(mmfile_t *one, mmfile_t *two,
+ struct diff_options *o,
+ regex_t *regexp, kwset_t kws)
+{
+ unsigned int one_contains = one ? contains(one, regexp, kws) : 0;
+ unsigned int two_contains = two ? contains(two, regexp, kws) : 0;
+ return one_contains != two_contains;
+}
+
+static int pickaxe_match(struct diff_filepair *p, struct diff_options *o,
+ regex_t *regexp, kwset_t kws, pickaxe_fn fn)
{
- regmatch_t regmatch;
struct userdiff_driver *textconv_one = NULL;
struct userdiff_driver *textconv_two = NULL;
mmfile_t mf1, mf2;
- int hit;
+ int ret;
- if (diff_unmodified_pair(p))
+ if (!o->pickaxe[0])
return 0;
- fill_one(p->one, &mf1, &textconv_one);
- fill_one(p->two, &mf2, &textconv_two);
-
- if (!mf1.ptr) {
- if (!mf2.ptr)
- return 0; /* ignore unmerged */
- /* created "two" -- does it have what we are looking for? */
- hit = !regexec(regexp, p->two->data, 1, &regmatch, 0);
- } else if (!mf2.ptr) {
- /* removed "one" -- did it have what we are looking for? */
- hit = !regexec(regexp, p->one->data, 1, &regmatch, 0);
- } else {
- /*
- * We have both sides; need to run textual diff and see if
- * the pattern appears on added/deleted lines.
- */
- struct diffgrep_cb ecbdata;
- xpparam_t xpp;
- xdemitconf_t xecfg;
-
- memset(&xpp, 0, sizeof(xpp));
- memset(&xecfg, 0, sizeof(xecfg));
- ecbdata.regexp = regexp;
- ecbdata.hit = 0;
- xecfg.ctxlen = o->context;
- xecfg.interhunkctxlen = o->interhunkcontext;
- xdi_diff_outf(&mf1, &mf2, diffgrep_consume, &ecbdata,
- &xpp, &xecfg);
- hit = ecbdata.hit;
+ /* ignore unmerged */
+ if (!DIFF_FILE_VALID(p->one) && !DIFF_FILE_VALID(p->two))
+ return 0;
+
+ if (DIFF_OPT_TST(o, ALLOW_TEXTCONV)) {
+ textconv_one = get_textconv(p->one);
+ textconv_two = get_textconv(p->two);
}
+
+ /*
+ * If we have an unmodified pair, we know that the count will be the
+ * same and don't even have to load the blobs. Unless textconv is in
+ * play, _and_ we are using two different textconv filters (e.g.,
+ * because a pair is an exact rename with different textconv attributes
+ * for each side, which might generate different content).
+ */
+ if (textconv_one == textconv_two && diff_unmodified_pair(p))
+ return 0;
+
+ mf1.size = fill_textconv(textconv_one, p->one, &mf1.ptr);
+ mf2.size = fill_textconv(textconv_two, p->two, &mf2.ptr);
+
+ ret = fn(DIFF_FILE_VALID(p->one) ? &mf1 : NULL,
+ DIFF_FILE_VALID(p->two) ? &mf2 : NULL,
+ o, regexp, kws);
+
if (textconv_one)
free(mf1.ptr);
if (textconv_two)
free(mf2.ptr);
- return hit;
+ diff_free_filespec_data(p->one);
+ diff_free_filespec_data(p->two);
+
+ return ret;
}
-static void diffcore_pickaxe_grep(struct diff_options *o)
+static void pickaxe(struct diff_queue_struct *q, struct diff_options *o,
+ regex_t *regexp, kwset_t kws, pickaxe_fn fn)
{
- struct diff_queue_struct *q = &diff_queued_diff;
- int i, has_changes, err;
- regex_t regex;
+ int i;
struct diff_queue_struct outq;
- outq.queue = NULL;
- outq.nr = outq.alloc = 0;
- err = regcomp(&regex, o->pickaxe, REG_EXTENDED | REG_NEWLINE);
- if (err) {
- char errbuf[1024];
- regerror(err, &regex, errbuf, 1024);
- regfree(&regex);
- die("invalid log-grep regex: %s", errbuf);
- }
+ DIFF_QUEUE_CLEAR(&outq);
if (o->pickaxe_opts & DIFF_PICKAXE_ALL) {
/* Showing the whole changeset if needle exists */
- for (i = has_changes = 0; !has_changes && i < q->nr; i++) {
+ for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
- if (diff_grep(p, &regex, o))
- has_changes++;
+ if (pickaxe_match(p, o, regexp, kws, fn))
+ return; /* do not munge the queue */
}
- if (has_changes)
- return; /* do not munge the queue */
/*
* Otherwise we will clear the whole queue by copying
@@ -130,158 +190,65 @@ static void diffcore_pickaxe_grep(struct diff_options *o)
/* Showing only the filepairs that has the needle */
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
- if (diff_grep(p, &regex, o))
+ if (pickaxe_match(p, o, regexp, kws, fn))
diff_q(&outq, p);
else
diff_free_filepair(p);
}
}
- regfree(&regex);
-
free(q->queue);
*q = outq;
- return;
}
-static unsigned int contains(struct diff_filespec *one,
- const char *needle, unsigned long len,
- regex_t *regexp)
+static void regcomp_or_die(regex_t *regex, const char *needle, int cflags)
{
- unsigned int cnt;
- unsigned long sz;
- const char *data;
- if (diff_populate_filespec(one, 0))
- return 0;
- if (!len)
- return 0;
-
- sz = one->size;
- data = one->data;
- cnt = 0;
-
- if (regexp) {
- regmatch_t regmatch;
- int flags = 0;
-
- assert(data[sz] == '\0');
- while (*data && !regexec(regexp, data, 1, &regmatch, flags)) {
- flags |= REG_NOTBOL;
- data += regmatch.rm_eo;
- if (*data && regmatch.rm_so == regmatch.rm_eo)
- data++;
- cnt++;
- }
-
- } else { /* Classic exact string match */
- while (sz) {
- const char *found = memmem(data, sz, needle, len);
- if (!found)
- break;
- sz -= found - data + len;
- data = found + len;
- cnt++;
- }
+ int err = regcomp(regex, needle, cflags);
+ if (err) {
+ /* The POSIX.2 people are surely sick */
+ char errbuf[1024];
+ regerror(err, regex, errbuf, 1024);
+ regfree(regex);
+ die("invalid regex: %s", errbuf);
}
- diff_free_filespec_data(one);
- return cnt;
}
-static void diffcore_pickaxe_count(struct diff_options *o)
+void diffcore_pickaxe(struct diff_options *o)
{
const char *needle = o->pickaxe;
int opts = o->pickaxe_opts;
- struct diff_queue_struct *q = &diff_queued_diff;
- unsigned long len = strlen(needle);
- int i, has_changes;
regex_t regex, *regexp = NULL;
- struct diff_queue_struct outq;
- DIFF_QUEUE_CLEAR(&outq);
+ kwset_t kws = NULL;
- if (opts & DIFF_PICKAXE_REGEX) {
- int err;
- err = regcomp(&regex, needle, REG_EXTENDED | REG_NEWLINE);
- if (err) {
- /* The POSIX.2 people are surely sick */
- char errbuf[1024];
- regerror(err, &regex, errbuf, 1024);
- regfree(&regex);
- die("invalid pickaxe regex: %s", errbuf);
- }
+ if (opts & (DIFF_PICKAXE_REGEX | DIFF_PICKAXE_KIND_G)) {
+ int cflags = REG_EXTENDED | REG_NEWLINE;
+ if (DIFF_OPT_TST(o, PICKAXE_IGNORE_CASE))
+ cflags |= REG_ICASE;
+ regcomp_or_die(&regex, needle, cflags);
+ regexp = &regex;
+ } else if (DIFF_OPT_TST(o, PICKAXE_IGNORE_CASE) &&
+ has_non_ascii(needle)) {
+ struct strbuf sb = STRBUF_INIT;
+ int cflags = REG_NEWLINE | REG_ICASE;
+
+ basic_regex_quote_buf(&sb, needle);
+ regcomp_or_die(&regex, sb.buf, cflags);
+ strbuf_release(&sb);
regexp = &regex;
+ } else {
+ kws = kwsalloc(DIFF_OPT_TST(o, PICKAXE_IGNORE_CASE)
+ ? tolower_trans_tbl : NULL);
+ kwsincr(kws, needle, strlen(needle));
+ kwsprep(kws);
}
- if (opts & DIFF_PICKAXE_ALL) {
- /* Showing the whole changeset if needle exists */
- for (i = has_changes = 0; !has_changes && i < q->nr; i++) {
- struct diff_filepair *p = q->queue[i];
- if (!DIFF_FILE_VALID(p->one)) {
- if (!DIFF_FILE_VALID(p->two))
- continue; /* ignore unmerged */
- /* created */
- if (contains(p->two, needle, len, regexp))
- has_changes++;
- }
- else if (!DIFF_FILE_VALID(p->two)) {
- if (contains(p->one, needle, len, regexp))
- has_changes++;
- }
- else if (!diff_unmodified_pair(p) &&
- contains(p->one, needle, len, regexp) !=
- contains(p->two, needle, len, regexp))
- has_changes++;
- }
- if (has_changes)
- return; /* not munge the queue */
+ /* Might want to warn when both S and G are on; I don't care... */
+ pickaxe(&diff_queued_diff, o, regexp, kws,
+ (opts & DIFF_PICKAXE_KIND_G) ? diff_grep : has_changes);
- /* otherwise we will clear the whole queue
- * by copying the empty outq at the end of this
- * function, but first clear the current entries
- * in the queue.
- */
- for (i = 0; i < q->nr; i++)
- diff_free_filepair(q->queue[i]);
- }
+ if (regexp)
+ regfree(regexp);
else
- /* Showing only the filepairs that has the needle */
- for (i = 0; i < q->nr; i++) {
- struct diff_filepair *p = q->queue[i];
- has_changes = 0;
- if (!DIFF_FILE_VALID(p->one)) {
- if (!DIFF_FILE_VALID(p->two))
- ; /* ignore unmerged */
- /* created */
- else if (contains(p->two, needle, len, regexp))
- has_changes = 1;
- }
- else if (!DIFF_FILE_VALID(p->two)) {
- if (contains(p->one, needle, len, regexp))
- has_changes = 1;
- }
- else if (!diff_unmodified_pair(p) &&
- contains(p->one, needle, len, regexp) !=
- contains(p->two, needle, len, regexp))
- has_changes = 1;
-
- if (has_changes)
- diff_q(&outq, p);
- else
- diff_free_filepair(p);
- }
-
- if (opts & DIFF_PICKAXE_REGEX)
- regfree(&regex);
-
- free(q->queue);
- *q = outq;
+ kwsfree(kws);
return;
}
-
-void diffcore_pickaxe(struct diff_options *o)
-{
- /* Might want to warn when both S and G are on; I don't care... */
- if (o->pickaxe_opts & DIFF_PICKAXE_KIND_G)
- diffcore_pickaxe_grep(o);
- else
- diffcore_pickaxe_count(o);
-}
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-13 07:18:23 +0000