[thirdparty/git.git] / diffcore-pickaxe.c

/*
 * Copyright (C) 2005 Junio C Hamano
 * Copyright (C) 2010 Google Inc.
 */
#include "cache.h"
#include "diff.h"
#include "diffcore.h"
#include "xdiff-interface.h"

struct diffgrep_cb {
	regex_t *regexp;
	int hit;
};

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;
	if (data->hit)
		/*
		 * NEEDSWORK: we should have a way to terminate the
		 * 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;
}

static void fill_one(struct diff_filespec *one,
		     mmfile_t *mf, struct userdiff_driver **textconv)
{
	if (DIFF_FILE_VALID(one)) {
		*textconv = get_textconv(one);
		mf->size = fill_textconv(*textconv, one, &mf->ptr);
	} else {
		memset(mf, 0, sizeof(*mf));
	}
}

static int diff_grep(struct diff_filepair *p, regex_t *regexp, struct diff_options *o)
{
	regmatch_t regmatch;
	struct userdiff_driver *textconv_one = NULL;
	struct userdiff_driver *textconv_two = NULL;
	mmfile_t mf1, mf2;
	int hit;

	if (diff_unmodified_pair(p))
		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;
	}
	if (textconv_one)
		free(mf1.ptr);
	if (textconv_two)
		free(mf2.ptr);
	return hit;
}

static void diffcore_pickaxe_grep(struct diff_options *o)
{
	struct diff_queue_struct *q = &diff_queued_diff;
	int i, has_changes, err;
	regex_t regex;
	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);
	}

	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++) {
			struct diff_filepair *p = q->queue[i];
			if (diff_grep(p, &regex, o))
				has_changes++;
		}
		if (has_changes)
			return; /* do not munge the queue */

		/*
		 * 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]);
	} else {
		/* 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))
				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)
{
	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++;
		}
	}
	diff_free_filespec_data(one);
	return cnt;
}

static void diffcore_pickaxe_count(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);

	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);
		}
		regexp = &regex;
	}

	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 */

		/* 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]);
	}
	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;
	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);
}
Commit	Line	Data
52e95789 JH	1	/*
52e95789 JH	2	* Copyright (C) 2005 Junio C Hamano
f506b8e8	3	* Copyright (C) 2010 Google Inc.
52e95789 JH	4	*/
	5	#include "cache.h"
	6	#include "diff.h"
	7	#include "diffcore.h"
f506b8e8 JH	8	#include "xdiff-interface.h"
	9
	10	struct diffgrep_cb {
	11	regex_t *regexp;
	12	int hit;
	13	};
	14
	15	static void diffgrep_consume(void priv, char line, unsigned long len)
	16	{
	17	struct diffgrep_cb *data = priv;
	18	regmatch_t regmatch;
	19	int hold;
	20
	21	if (line[0] != '+' && line[0] != '-')
	22	return;
	23	if (data->hit)
	24	/*
	25	* NEEDSWORK: we should have a way to terminate the
	26	* caller early.
	27	*/
	28	return;
	29	/* Yuck -- line ought to be "const char "! /
	30	hold = line[len];
	31	line[len] = '\0';
	32	data->hit = !regexec(data->regexp, line + 1, 1, &regmatch, 0);
	33	line[len] = hold;
	34	}
	35
	36	static void fill_one(struct diff_filespec *one,
	37	mmfile_t mf, struct userdiff_driver *textconv)
	38	{
	39	if (DIFF_FILE_VALID(one)) {
	40	*textconv = get_textconv(one);
	41	mf->size = fill_textconv(*textconv, one, &mf->ptr);
	42	} else {
	43	memset(mf, 0, sizeof(*mf));
	44	}
	45	}
	46
	47	static int diff_grep(struct diff_filepair p, regex_t regexp, struct diff_options *o)
	48	{
	49	regmatch_t regmatch;
	50	struct userdiff_driver *textconv_one = NULL;
	51	struct userdiff_driver *textconv_two = NULL;
	52	mmfile_t mf1, mf2;
	53	int hit;
	54
	55	if (diff_unmodified_pair(p))
	56	return 0;
	57
	58	fill_one(p->one, &mf1, &textconv_one);
	59	fill_one(p->two, &mf2, &textconv_two);
	60
	61	if (!mf1.ptr) {
	62	if (!mf2.ptr)
	63	return 0; /* ignore unmerged */
	64	/* created "two" -- does it have what we are looking for? */
	65	hit = !regexec(regexp, p->two->data, 1, &regmatch, 0);
	66	} else if (!mf2.ptr) {
	67	/* removed "one" -- did it have what we are looking for? */
	68	hit = !regexec(regexp, p->one->data, 1, &regmatch, 0);
	69	} else {
	70	/*
	71	* We have both sides; need to run textual diff and see if
72	* the pattern appears on added/deleted lines.
73	*/
74	struct diffgrep_cb ecbdata;
75	xpparam_t xpp;
76	xdemitconf_t xecfg;
77
78	memset(&xpp, 0, sizeof(xpp));
79	memset(&xecfg, 0, sizeof(xecfg));
80	ecbdata.regexp = regexp;
81	ecbdata.hit = 0;
82	xecfg.ctxlen = o->context;
83	xecfg.interhunkctxlen = o->interhunkcontext;
84	xdi_diff_outf(&mf1, &mf2, diffgrep_consume, &ecbdata,
85	&xpp, &xecfg);
86	hit = ecbdata.hit;
87	}
88	if (textconv_one)
89	free(mf1.ptr);
90	if (textconv_two)
91	free(mf2.ptr);
92	return hit;
93	}
94
95	static void diffcore_pickaxe_grep(struct diff_options *o)
96	{
97	struct diff_queue_struct *q = &diff_queued_diff;
98	int i, has_changes, err;
99	regex_t regex;
100	struct diff_queue_struct outq;
101	outq.queue = NULL;
102	outq.nr = outq.alloc = 0;
103
104	err = regcomp(&regex, o->pickaxe, REG_EXTENDED \| REG_NEWLINE);
105	if (err) {
106	char errbuf[1024];
107	regerror(err, &regex, errbuf, 1024);
108	regfree(&regex);
109	die("invalid log-grep regex: %s", errbuf);
110	}
111
112	if (o->pickaxe_opts & DIFF_PICKAXE_ALL) {
113	/* Showing the whole changeset if needle exists */
114	for (i = has_changes = 0; !has_changes && i < q->nr; i++) {
115	struct diff_filepair *p = q->queue[i];
116	if (diff_grep(p, &regex, o))
117	has_changes++;
118	}
119	if (has_changes)
120	return; /* do not munge the queue */
121
122	/*
123	* Otherwise we will clear the whole queue by copying
124	* the empty outq at the end of this function, but
125	* first clear the current entries in the queue.
126	*/
127	for (i = 0; i < q->nr; i++)
128	diff_free_filepair(q->queue[i]);
129	} else {
130	/* Showing only the filepairs that has the needle */
131	for (i = 0; i < q->nr; i++) {
132	struct diff_filepair *p = q->queue[i];
133	if (diff_grep(p, &regex, o))
134	diff_q(&outq, p);
135	else
136	diff_free_filepair(p);
137	}
138	}
139
140	regfree(&regex);
141
142	free(q->queue);
143	*q = outq;
144	return;
145	}
52e95789	146
2002eed6	147	static unsigned int contains(struct diff_filespec *one,
d01d8c67 PB	148	const char *needle, unsigned long len,
d01d8c67 PB	149	regex_t *regexp)
52e95789	150	{
2002eed6	151	unsigned int cnt;
ce163c79	152	unsigned long sz;
52e95789	153	const char *data;
f0c6b2a2	154	if (diff_populate_filespec(one, 0))
52e95789	155	return 0;
e1b16116 JK	156	if (!len)
e1b16116 JK	157	return 0;
2002eed6	158
52e95789 JH	159	sz = one->size;
52e95789 JH	160	data = one->data;
2002eed6 JH	161	cnt = 0;
2002eed6 JH	162
d01d8c67 PB	163	if (regexp) {
	164	regmatch_t regmatch;
	165	int flags = 0;
	166
50fd6997	167	assert(data[sz] == '\0');
d01d8c67 PB	168	while (*data && !regexec(regexp, data, 1, &regmatch, flags)) {
d01d8c67 PB	169	flags \|= REG_NOTBOL;
50fd6997 RS	170	data += regmatch.rm_eo;
	171	if (*data && regmatch.rm_so == regmatch.rm_eo)
	172	data++;
2002eed6 JH	173	cnt++;
2002eed6 JH	174	}
d01d8c67 PB	175
d01d8c67 PB	176	} else { /* Classic exact string match */
ce163c79 RS	177	while (sz) {
	178	const char *found = memmem(data, sz, needle, len);
	179	if (!found)
	180	break;
	181	sz -= found - data + len;
	182	data = found + len;
	183	cnt++;
d01d8c67	184	}
2002eed6	185	}
a0cb9400	186	diff_free_filespec_data(one);
2002eed6	187	return cnt;
52e95789 JH	188	}
52e95789 JH	189
f506b8e8	190	static void diffcore_pickaxe_count(struct diff_options *o)
52e95789	191	{
382f013b JH	192	const char *needle = o->pickaxe;
382f013b JH	193	int opts = o->pickaxe_opts;
38c6f780	194	struct diff_queue_struct *q = &diff_queued_diff;
52e95789	195	unsigned long len = strlen(needle);
367cec1c	196	int i, has_changes;
d01d8c67	197	regex_t regex, *regexp = NULL;
52e95789	198	struct diff_queue_struct outq;
9ca5df90	199	DIFF_QUEUE_CLEAR(&outq);
52e95789	200
d01d8c67 PB	201	if (opts & DIFF_PICKAXE_REGEX) {
	202	int err;
	203	err = regcomp(&regex, needle, REG_EXTENDED \| REG_NEWLINE);
	204	if (err) {
	205	/* The POSIX.2 people are surely sick */
	206	char errbuf[1024];
	207	regerror(err, &regex, errbuf, 1024);
	208	regfree(&regex);
	209	die("invalid pickaxe regex: %s", errbuf);
	210	}
	211	regexp = &regex;
	212	}
	213
367cec1c JH	214	if (opts & DIFF_PICKAXE_ALL) {
	215	/* Showing the whole changeset if needle exists */
	216	for (i = has_changes = 0; !has_changes && i < q->nr; i++) {
	217	struct diff_filepair *p = q->queue[i];
	218	if (!DIFF_FILE_VALID(p->one)) {
	219	if (!DIFF_FILE_VALID(p->two))
	220	continue; /* ignore unmerged */
	221	/* created */
d01d8c67	222	if (contains(p->two, needle, len, regexp))
367cec1c JH	223	has_changes++;
	224	}
	225	else if (!DIFF_FILE_VALID(p->two)) {
d01d8c67	226	if (contains(p->one, needle, len, regexp))
367cec1c JH	227	has_changes++;
	228	}
	229	else if (!diff_unmodified_pair(p) &&
d01d8c67 PB	230	contains(p->one, needle, len, regexp) !=
d01d8c67 PB	231	contains(p->two, needle, len, regexp))
367cec1c	232	has_changes++;
52e95789	233	}
367cec1c JH	234	if (has_changes)
	235	return; /* not munge the queue */
	236
	237	/* otherwise we will clear the whole queue
	238	* by copying the empty outq at the end of this
	239	* function, but first clear the current entries
	240	* in the queue.
	241	*/
	242	for (i = 0; i < q->nr; i++)
	243	diff_free_filepair(q->queue[i]);
	244	}
a6080a0a	245	else
367cec1c JH	246	/* Showing only the filepairs that has the needle */
	247	for (i = 0; i < q->nr; i++) {
	248	struct diff_filepair *p = q->queue[i];
	249	has_changes = 0;
	250	if (!DIFF_FILE_VALID(p->one)) {
	251	if (!DIFF_FILE_VALID(p->two))
	252	; /* ignore unmerged */
	253	/* created */
d01d8c67	254	else if (contains(p->two, needle, len, regexp))
367cec1c JH	255	has_changes = 1;
	256	}
	257	else if (!DIFF_FILE_VALID(p->two)) {
d01d8c67	258	if (contains(p->one, needle, len, regexp))
367cec1c JH	259	has_changes = 1;
	260	}
	261	else if (!diff_unmodified_pair(p) &&
d01d8c67 PB	262	contains(p->one, needle, len, regexp) !=
d01d8c67 PB	263	contains(p->two, needle, len, regexp))
367cec1c JH	264	has_changes = 1;
	265
	266	if (has_changes)
6b14d7fa	267	diff_q(&outq, p);
367cec1c JH	268	else
367cec1c JH	269	diff_free_filepair(p);
52e95789	270	}
367cec1c	271
95ae69b9	272	if (opts & DIFF_PICKAXE_REGEX)
d01d8c67	273	regfree(&regex);
d01d8c67	274
52e95789 JH	275	free(q->queue);
	276	*q = outq;
	277	return;
	278	}
f506b8e8 JH	279
	280	void diffcore_pickaxe(struct diff_options *o)
	281	{
	282	/* Might want to warn when both S and G are on; I don't care... */
	283	if (o->pickaxe_opts & DIFF_PICKAXE_KIND_G)
8520913c	284	diffcore_pickaxe_grep(o);
f506b8e8	285	else
8520913c	286	diffcore_pickaxe_count(o);
f506b8e8	287	}