Adapt the kwset code to Git
[git/git.git] / diffcore-pickaxe.c
CommitLineData
52e95789
JH
1/*
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
10struct diffgrep_cb {
11 regex_t *regexp;
12 int hit;
13};
14
15static 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
36static 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
47static 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
95static 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 147static unsigned int contains(struct diff_filespec *one,
d01d8c67
PB
148 const char *needle, unsigned long len,
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)
157 return 0;
2002eed6 158
52e95789
JH
159 sz = one->size;
160 data = one->data;
2002eed6
JH
161 cnt = 0;
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)) {
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++;
174 }
d01d8c67
PB
175
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}
189
f506b8e8 190static void diffcore_pickaxe_count(struct diff_options *o)
52e95789 191{
382f013b
JH
192 const char *needle = o->pickaxe;
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) !=
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) !=
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
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
280void 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}