2 * Copyright (C) 2005 Junio C Hamano
3 * Copyright (C) 2010 Google Inc.
8 #include "xdiff-interface.h"
11 typedef int (*pickaxe_fn
)(struct diff_filepair
*p
, struct diff_options
*o
, regex_t
*regexp
, kwset_t kws
);
13 static void pickaxe(struct diff_queue_struct
*q
, struct diff_options
*o
,
14 regex_t
*regexp
, kwset_t kws
, pickaxe_fn fn
)
17 struct diff_queue_struct outq
;
19 DIFF_QUEUE_CLEAR(&outq
);
21 if (o
->pickaxe_opts
& DIFF_PICKAXE_ALL
) {
22 /* Showing the whole changeset if needle exists */
23 for (i
= 0; i
< q
->nr
; i
++) {
24 struct diff_filepair
*p
= q
->queue
[i
];
25 if (fn(p
, o
, regexp
, kws
))
26 return; /* do not munge the queue */
30 * Otherwise we will clear the whole queue by copying
31 * the empty outq at the end of this function, but
32 * first clear the current entries in the queue.
34 for (i
= 0; i
< q
->nr
; i
++)
35 diff_free_filepair(q
->queue
[i
]);
37 /* Showing only the filepairs that has the needle */
38 for (i
= 0; i
< q
->nr
; i
++) {
39 struct diff_filepair
*p
= q
->queue
[i
];
40 if (fn(p
, o
, regexp
, kws
))
43 diff_free_filepair(p
);
56 static void diffgrep_consume(void *priv
, char *line
, unsigned long len
)
58 struct diffgrep_cb
*data
= priv
;
62 if (line
[0] != '+' && line
[0] != '-')
66 * NEEDSWORK: we should have a way to terminate the
70 /* Yuck -- line ought to be "const char *"! */
73 data
->hit
= !regexec(data
->regexp
, line
+ 1, 1, ®match
, 0);
77 static int diff_grep(struct diff_filepair
*p
, struct diff_options
*o
,
78 regex_t
*regexp
, kwset_t kws
)
81 struct userdiff_driver
*textconv_one
= NULL
;
82 struct userdiff_driver
*textconv_two
= NULL
;
89 if (DIFF_OPT_TST(o
, ALLOW_TEXTCONV
)) {
90 textconv_one
= get_textconv(p
->one
);
91 textconv_two
= get_textconv(p
->two
);
94 if (textconv_one
== textconv_two
&& diff_unmodified_pair(p
))
97 mf1
.size
= fill_textconv(textconv_one
, p
->one
, &mf1
.ptr
);
98 mf2
.size
= fill_textconv(textconv_two
, p
->two
, &mf2
.ptr
);
100 if (!DIFF_FILE_VALID(p
->one
)) {
101 if (!DIFF_FILE_VALID(p
->two
))
102 hit
= 0; /* ignore unmerged */
104 /* created "two" -- does it have what we are looking for? */
105 hit
= !regexec(regexp
, mf2
.ptr
, 1, ®match
, 0);
106 } else if (!DIFF_FILE_VALID(p
->two
)) {
107 /* removed "one" -- did it have what we are looking for? */
108 hit
= !regexec(regexp
, mf1
.ptr
, 1, ®match
, 0);
111 * We have both sides; need to run textual diff and see if
112 * the pattern appears on added/deleted lines.
114 struct diffgrep_cb ecbdata
;
118 memset(&xpp
, 0, sizeof(xpp
));
119 memset(&xecfg
, 0, sizeof(xecfg
));
120 ecbdata
.regexp
= regexp
;
122 xecfg
.ctxlen
= o
->context
;
123 xecfg
.interhunkctxlen
= o
->interhunkcontext
;
124 xdi_diff_outf(&mf1
, &mf2
, diffgrep_consume
, &ecbdata
,
132 diff_free_filespec_data(p
->one
);
133 diff_free_filespec_data(p
->two
);
137 static void diffcore_pickaxe_grep(struct diff_options
*o
)
141 int cflags
= REG_EXTENDED
| REG_NEWLINE
;
143 if (DIFF_OPT_TST(o
, PICKAXE_IGNORE_CASE
))
146 err
= regcomp(®ex
, o
->pickaxe
, cflags
);
149 regerror(err
, ®ex
, errbuf
, 1024);
151 die("invalid log-grep regex: %s", errbuf
);
154 pickaxe(&diff_queued_diff
, o
, ®ex
, NULL
, diff_grep
);
160 static unsigned int contains(mmfile_t
*mf
, struct diff_options
*o
,
161 regex_t
*regexp
, kwset_t kws
)
175 assert(data
[sz
] == '\0');
176 while (*data
&& !regexec(regexp
, data
, 1, ®match
, flags
)) {
178 data
+= regmatch
.rm_eo
;
179 if (*data
&& regmatch
.rm_so
== regmatch
.rm_eo
)
184 } else { /* Classic exact string match */
186 struct kwsmatch kwsm
;
187 size_t offset
= kwsexec(kws
, data
, sz
, &kwsm
);
192 found
= data
+ offset
;
193 sz
-= found
- data
+ kwsm
.size
[0];
194 data
= found
+ kwsm
.size
[0];
201 static int has_changes(struct diff_filepair
*p
, struct diff_options
*o
,
202 regex_t
*regexp
, kwset_t kws
)
204 struct userdiff_driver
*textconv_one
= NULL
;
205 struct userdiff_driver
*textconv_two
= NULL
;
212 if (DIFF_OPT_TST(o
, ALLOW_TEXTCONV
)) {
213 textconv_one
= get_textconv(p
->one
);
214 textconv_two
= get_textconv(p
->two
);
218 * If we have an unmodified pair, we know that the count will be the
219 * same and don't even have to load the blobs. Unless textconv is in
220 * play, _and_ we are using two different textconv filters (e.g.,
221 * because a pair is an exact rename with different textconv attributes
222 * for each side, which might generate different content).
224 if (textconv_one
== textconv_two
&& diff_unmodified_pair(p
))
227 mf1
.size
= fill_textconv(textconv_one
, p
->one
, &mf1
.ptr
);
228 mf2
.size
= fill_textconv(textconv_two
, p
->two
, &mf2
.ptr
);
230 if (!DIFF_FILE_VALID(p
->one
)) {
231 if (!DIFF_FILE_VALID(p
->two
))
232 ret
= 0; /* ignore unmerged */
235 ret
= contains(&mf2
, o
, regexp
, kws
) != 0;
237 else if (!DIFF_FILE_VALID(p
->two
)) /* removed */
238 ret
= contains(&mf1
, o
, regexp
, kws
) != 0;
240 ret
= contains(&mf1
, o
, regexp
, kws
) !=
241 contains(&mf2
, o
, regexp
, kws
);
247 diff_free_filespec_data(p
->one
);
248 diff_free_filespec_data(p
->two
);
253 static void diffcore_pickaxe_count(struct diff_options
*o
)
255 const char *needle
= o
->pickaxe
;
256 int opts
= o
->pickaxe_opts
;
257 unsigned long len
= strlen(needle
);
258 regex_t regex
, *regexp
= NULL
;
261 if (opts
& DIFF_PICKAXE_REGEX
) {
263 err
= regcomp(®ex
, needle
, REG_EXTENDED
| REG_NEWLINE
);
265 /* The POSIX.2 people are surely sick */
267 regerror(err
, ®ex
, errbuf
, 1024);
269 die("invalid pickaxe regex: %s", errbuf
);
273 kws
= kwsalloc(DIFF_OPT_TST(o
, PICKAXE_IGNORE_CASE
)
274 ? tolower_trans_tbl
: NULL
);
275 kwsincr(kws
, needle
, len
);
279 pickaxe(&diff_queued_diff
, o
, regexp
, kws
, has_changes
);
281 if (opts
& DIFF_PICKAXE_REGEX
)
288 void diffcore_pickaxe(struct diff_options
*o
)
290 /* Might want to warn when both S and G are on; I don't care... */
291 if (o
->pickaxe_opts
& DIFF_PICKAXE_KIND_G
)
292 diffcore_pickaxe_grep(o
);
294 diffcore_pickaxe_count(o
);