submodule: Use cat instead of echo to avoid DOS line-endings
[git/dscho.git] / diffcore-pickaxe.c
blobc3760cfefd5dd123481b869eac3081b6e7d93201
1 /*
2 * Copyright (C) 2005 Junio C Hamano
3 * Copyright (C) 2010 Google Inc.
4 */
5 #include "cache.h"
6 #include "diff.h"
7 #include "diffcore.h"
8 #include "xdiff-interface.h"
9 #include "kwset.h"
11 struct diffgrep_cb {
12 regex_t *regexp;
13 int hit;
16 static void diffgrep_consume(void *priv, char *line, unsigned long len)
18 struct diffgrep_cb *data = priv;
19 regmatch_t regmatch;
20 int hold;
22 if (line[0] != '+' && line[0] != '-')
23 return;
24 if (data->hit)
26 * NEEDSWORK: we should have a way to terminate the
27 * caller early.
29 return;
30 /* Yuck -- line ought to be "const char *"! */
31 hold = line[len];
32 line[len] = '\0';
33 data->hit = !regexec(data->regexp, line + 1, 1, &regmatch, 0);
34 line[len] = hold;
37 static void fill_one(struct diff_filespec *one,
38 mmfile_t *mf, struct userdiff_driver **textconv)
40 if (DIFF_FILE_VALID(one)) {
41 *textconv = get_textconv(one);
42 mf->size = fill_textconv(*textconv, one, &mf->ptr);
43 } else {
44 memset(mf, 0, sizeof(*mf));
48 static int diff_grep(struct diff_filepair *p, regex_t *regexp, struct diff_options *o)
50 regmatch_t regmatch;
51 struct userdiff_driver *textconv_one = NULL;
52 struct userdiff_driver *textconv_two = NULL;
53 mmfile_t mf1, mf2;
54 int hit;
56 if (diff_unmodified_pair(p))
57 return 0;
59 fill_one(p->one, &mf1, &textconv_one);
60 fill_one(p->two, &mf2, &textconv_two);
62 if (!mf1.ptr) {
63 if (!mf2.ptr)
64 return 0; /* ignore unmerged */
65 /* created "two" -- does it have what we are looking for? */
66 hit = !regexec(regexp, p->two->data, 1, &regmatch, 0);
67 } else if (!mf2.ptr) {
68 /* removed "one" -- did it have what we are looking for? */
69 hit = !regexec(regexp, p->one->data, 1, &regmatch, 0);
70 } else {
72 * We have both sides; need to run textual diff and see if
73 * the pattern appears on added/deleted lines.
75 struct diffgrep_cb ecbdata;
76 xpparam_t xpp;
77 xdemitconf_t xecfg;
79 memset(&xpp, 0, sizeof(xpp));
80 memset(&xecfg, 0, sizeof(xecfg));
81 ecbdata.regexp = regexp;
82 ecbdata.hit = 0;
83 xecfg.ctxlen = o->context;
84 xecfg.interhunkctxlen = o->interhunkcontext;
85 xdi_diff_outf(&mf1, &mf2, diffgrep_consume, &ecbdata,
86 &xpp, &xecfg);
87 hit = ecbdata.hit;
89 if (textconv_one)
90 free(mf1.ptr);
91 if (textconv_two)
92 free(mf2.ptr);
93 return hit;
96 static void diffcore_pickaxe_grep(struct diff_options *o)
98 struct diff_queue_struct *q = &diff_queued_diff;
99 int i, has_changes, err;
100 regex_t regex;
101 struct diff_queue_struct outq;
102 outq.queue = NULL;
103 outq.nr = outq.alloc = 0;
105 err = regcomp(&regex, o->pickaxe, REG_EXTENDED | REG_NEWLINE);
106 if (err) {
107 char errbuf[1024];
108 regerror(err, &regex, errbuf, 1024);
109 regfree(&regex);
110 die("invalid log-grep regex: %s", errbuf);
113 if (o->pickaxe_opts & DIFF_PICKAXE_ALL) {
114 /* Showing the whole changeset if needle exists */
115 for (i = has_changes = 0; !has_changes && i < q->nr; i++) {
116 struct diff_filepair *p = q->queue[i];
117 if (diff_grep(p, &regex, o))
118 has_changes++;
120 if (has_changes)
121 return; /* do not munge the queue */
124 * Otherwise we will clear the whole queue by copying
125 * the empty outq at the end of this function, but
126 * first clear the current entries in the queue.
128 for (i = 0; i < q->nr; i++)
129 diff_free_filepair(q->queue[i]);
130 } else {
131 /* Showing only the filepairs that has the needle */
132 for (i = 0; i < q->nr; i++) {
133 struct diff_filepair *p = q->queue[i];
134 if (diff_grep(p, &regex, o))
135 diff_q(&outq, p);
136 else
137 diff_free_filepair(p);
141 regfree(&regex);
143 free(q->queue);
144 *q = outq;
145 return;
148 static unsigned int contains(struct diff_filespec *one,
149 const char *needle, unsigned long len,
150 regex_t *regexp, kwset_t kws)
152 unsigned int cnt;
153 unsigned long sz;
154 const char *data;
155 if (diff_populate_filespec(one, 0))
156 return 0;
157 if (!len)
158 return 0;
160 sz = one->size;
161 data = one->data;
162 cnt = 0;
164 if (regexp) {
165 regmatch_t regmatch;
166 int flags = 0;
168 assert(data[sz] == '\0');
169 while (*data && !regexec(regexp, data, 1, &regmatch, flags)) {
170 flags |= REG_NOTBOL;
171 data += regmatch.rm_eo;
172 if (*data && regmatch.rm_so == regmatch.rm_eo)
173 data++;
174 cnt++;
177 } else { /* Classic exact string match */
178 while (sz) {
179 size_t offset = kwsexec(kws, data, sz, NULL);
180 const char *found;
181 if (offset == -1)
182 break;
183 else
184 found = data + offset;
185 sz -= found - data + len;
186 data = found + len;
187 cnt++;
190 diff_free_filespec_data(one);
191 return cnt;
194 static void diffcore_pickaxe_count(struct diff_options *o)
196 const char *needle = o->pickaxe;
197 int opts = o->pickaxe_opts;
198 struct diff_queue_struct *q = &diff_queued_diff;
199 unsigned long len = strlen(needle);
200 int i, has_changes;
201 regex_t regex, *regexp = NULL;
202 kwset_t kws = NULL;
203 struct diff_queue_struct outq;
204 DIFF_QUEUE_CLEAR(&outq);
206 if (opts & DIFF_PICKAXE_REGEX) {
207 int err;
208 err = regcomp(&regex, needle, REG_EXTENDED | REG_NEWLINE);
209 if (err) {
210 /* The POSIX.2 people are surely sick */
211 char errbuf[1024];
212 regerror(err, &regex, errbuf, 1024);
213 regfree(&regex);
214 die("invalid pickaxe regex: %s", errbuf);
216 regexp = &regex;
217 } else {
218 kws = kwsalloc(NULL);
219 kwsincr(kws, needle, len);
220 kwsprep(kws);
223 if (opts & DIFF_PICKAXE_ALL) {
224 /* Showing the whole changeset if needle exists */
225 for (i = has_changes = 0; !has_changes && i < q->nr; i++) {
226 struct diff_filepair *p = q->queue[i];
227 if (!DIFF_FILE_VALID(p->one)) {
228 if (!DIFF_FILE_VALID(p->two))
229 continue; /* ignore unmerged */
230 /* created */
231 if (contains(p->two, needle, len, regexp, kws))
232 has_changes++;
234 else if (!DIFF_FILE_VALID(p->two)) {
235 if (contains(p->one, needle, len, regexp, kws))
236 has_changes++;
238 else if (!diff_unmodified_pair(p) &&
239 contains(p->one, needle, len, regexp, kws) !=
240 contains(p->two, needle, len, regexp, kws))
241 has_changes++;
243 if (has_changes)
244 return; /* not munge the queue */
246 /* otherwise we will clear the whole queue
247 * by copying the empty outq at the end of this
248 * function, but first clear the current entries
249 * in the queue.
251 for (i = 0; i < q->nr; i++)
252 diff_free_filepair(q->queue[i]);
254 else
255 /* Showing only the filepairs that has the needle */
256 for (i = 0; i < q->nr; i++) {
257 struct diff_filepair *p = q->queue[i];
258 has_changes = 0;
259 if (!DIFF_FILE_VALID(p->one)) {
260 if (!DIFF_FILE_VALID(p->two))
261 ; /* ignore unmerged */
262 /* created */
263 else if (contains(p->two, needle, len, regexp,
264 kws))
265 has_changes = 1;
267 else if (!DIFF_FILE_VALID(p->two)) {
268 if (contains(p->one, needle, len, regexp, kws))
269 has_changes = 1;
271 else if (!diff_unmodified_pair(p) &&
272 contains(p->one, needle, len, regexp, kws) !=
273 contains(p->two, needle, len, regexp, kws))
274 has_changes = 1;
276 if (has_changes)
277 diff_q(&outq, p);
278 else
279 diff_free_filepair(p);
282 if (opts & DIFF_PICKAXE_REGEX)
283 regfree(&regex);
284 else
285 kwsfree(kws);
287 free(q->queue);
288 *q = outq;
289 return;
292 void diffcore_pickaxe(struct diff_options *o)
294 /* Might want to warn when both S and G are on; I don't care... */
295 if (o->pickaxe_opts & DIFF_PICKAXE_KIND_G)
296 diffcore_pickaxe_grep(o);
297 else
298 diffcore_pickaxe_count(o);