]>
git.ipfire.org Git - thirdparty/git.git/blob - diffcore-pickaxe.c
a278b9b71d9b58af197269cc6340050bba98acbe
2 * Copyright (C) 2005 Junio C Hamano
3 * Copyright (C) 2010 Google Inc.
8 #include "xdiff-interface.h"
13 typedef int (*pickaxe_fn
)(mmfile_t
*one
, mmfile_t
*two
,
14 struct diff_options
*o
,
15 regex_t
*regexp
, kwset_t kws
);
22 static void diffgrep_consume(void *priv
, char *line
, unsigned long len
)
24 struct diffgrep_cb
*data
= priv
;
27 if (line
[0] != '+' && line
[0] != '-')
31 * NEEDSWORK: we should have a way to terminate the
35 data
->hit
= !regexec_buf(data
->regexp
, line
+ 1, len
- 1, 1,
39 static int diff_grep(mmfile_t
*one
, mmfile_t
*two
,
40 struct diff_options
*o
,
41 regex_t
*regexp
, kwset_t kws
)
44 struct diffgrep_cb ecbdata
;
49 return !regexec_buf(regexp
, two
->ptr
, two
->size
,
52 return !regexec_buf(regexp
, one
->ptr
, one
->size
,
56 * We have both sides; need to run textual diff and see if
57 * the pattern appears on added/deleted lines.
59 memset(&xpp
, 0, sizeof(xpp
));
60 memset(&xecfg
, 0, sizeof(xecfg
));
61 ecbdata
.regexp
= regexp
;
63 xecfg
.ctxlen
= o
->context
;
64 xecfg
.interhunkctxlen
= o
->interhunkcontext
;
65 if (xdi_diff_outf(one
, two
, discard_hunk_line
, diffgrep_consume
,
66 &ecbdata
, &xpp
, &xecfg
))
71 static unsigned int contains(mmfile_t
*mf
, regex_t
*regexp
, kwset_t kws
)
74 unsigned long sz
= mf
->size
;
75 const char *data
= mf
->ptr
;
82 !regexec_buf(regexp
, data
, sz
, 1, ®match
, flags
)) {
84 data
+= regmatch
.rm_eo
;
86 if (sz
&& *data
&& regmatch
.rm_so
== regmatch
.rm_eo
) {
93 } else { /* Classic exact string match */
96 size_t offset
= kwsexec(kws
, data
, sz
, &kwsm
);
99 sz
-= offset
+ kwsm
.size
[0];
100 data
+= offset
+ kwsm
.size
[0];
107 static int has_changes(mmfile_t
*one
, mmfile_t
*two
,
108 struct diff_options
*o
,
109 regex_t
*regexp
, kwset_t kws
)
111 unsigned int one_contains
= one
? contains(one
, regexp
, kws
) : 0;
112 unsigned int two_contains
= two
? contains(two
, regexp
, kws
) : 0;
113 return one_contains
!= two_contains
;
116 static int pickaxe_match(struct diff_filepair
*p
, struct diff_options
*o
,
117 regex_t
*regexp
, kwset_t kws
, pickaxe_fn fn
)
119 struct userdiff_driver
*textconv_one
= NULL
;
120 struct userdiff_driver
*textconv_two
= NULL
;
124 /* ignore unmerged */
125 if (!DIFF_FILE_VALID(p
->one
) && !DIFF_FILE_VALID(p
->two
))
129 return (DIFF_FILE_VALID(p
->one
) &&
130 oidset_contains(o
->objfind
, &p
->one
->oid
)) ||
131 (DIFF_FILE_VALID(p
->two
) &&
132 oidset_contains(o
->objfind
, &p
->two
->oid
));
138 if (o
->flags
.allow_textconv
) {
139 textconv_one
= get_textconv(o
->repo
, p
->one
);
140 textconv_two
= get_textconv(o
->repo
, p
->two
);
144 * If we have an unmodified pair, we know that the count will be the
145 * same and don't even have to load the blobs. Unless textconv is in
146 * play, _and_ we are using two different textconv filters (e.g.,
147 * because a pair is an exact rename with different textconv attributes
148 * for each side, which might generate different content).
150 if (textconv_one
== textconv_two
&& diff_unmodified_pair(p
))
153 if ((o
->pickaxe_opts
& DIFF_PICKAXE_KIND_G
) &&
155 ((!textconv_one
&& diff_filespec_is_binary(o
->repo
, p
->one
)) ||
156 (!textconv_two
&& diff_filespec_is_binary(o
->repo
, p
->two
))))
159 mf1
.size
= fill_textconv(o
->repo
, textconv_one
, p
->one
, &mf1
.ptr
);
160 mf2
.size
= fill_textconv(o
->repo
, textconv_two
, p
->two
, &mf2
.ptr
);
162 ret
= fn(DIFF_FILE_VALID(p
->one
) ? &mf1
: NULL
,
163 DIFF_FILE_VALID(p
->two
) ? &mf2
: NULL
,
170 diff_free_filespec_data(p
->one
);
171 diff_free_filespec_data(p
->two
);
176 static void pickaxe(struct diff_queue_struct
*q
, struct diff_options
*o
,
177 regex_t
*regexp
, kwset_t kws
, pickaxe_fn fn
)
180 struct diff_queue_struct outq
;
182 DIFF_QUEUE_CLEAR(&outq
);
184 if (o
->pickaxe_opts
& DIFF_PICKAXE_ALL
) {
185 /* Showing the whole changeset if needle exists */
186 for (i
= 0; i
< q
->nr
; i
++) {
187 struct diff_filepair
*p
= q
->queue
[i
];
188 if (pickaxe_match(p
, o
, regexp
, kws
, fn
))
189 return; /* do not munge the queue */
193 * Otherwise we will clear the whole queue by copying
194 * the empty outq at the end of this function, but
195 * first clear the current entries in the queue.
197 for (i
= 0; i
< q
->nr
; i
++)
198 diff_free_filepair(q
->queue
[i
]);
200 /* Showing only the filepairs that has the needle */
201 for (i
= 0; i
< q
->nr
; i
++) {
202 struct diff_filepair
*p
= q
->queue
[i
];
203 if (pickaxe_match(p
, o
, regexp
, kws
, fn
))
206 diff_free_filepair(p
);
214 static void regcomp_or_die(regex_t
*regex
, const char *needle
, int cflags
)
216 int err
= regcomp(regex
, needle
, cflags
);
218 /* The POSIX.2 people are surely sick */
220 regerror(err
, regex
, errbuf
, 1024);
221 die("invalid regex: %s", errbuf
);
225 void diffcore_pickaxe(struct diff_options
*o
)
227 const char *needle
= o
->pickaxe
;
228 int opts
= o
->pickaxe_opts
;
229 regex_t regex
, *regexp
= NULL
;
232 if (opts
& (DIFF_PICKAXE_REGEX
| DIFF_PICKAXE_KIND_G
)) {
233 int cflags
= REG_EXTENDED
| REG_NEWLINE
;
234 if (o
->pickaxe_opts
& DIFF_PICKAXE_IGNORE_CASE
)
236 regcomp_or_die(®ex
, needle
, cflags
);
238 } else if (opts
& DIFF_PICKAXE_KIND_S
) {
239 if (o
->pickaxe_opts
& DIFF_PICKAXE_IGNORE_CASE
&&
240 has_non_ascii(needle
)) {
241 struct strbuf sb
= STRBUF_INIT
;
242 int cflags
= REG_NEWLINE
| REG_ICASE
;
244 basic_regex_quote_buf(&sb
, needle
);
245 regcomp_or_die(®ex
, sb
.buf
, cflags
);
249 kws
= kwsalloc(o
->pickaxe_opts
& DIFF_PICKAXE_IGNORE_CASE
250 ? tolower_trans_tbl
: NULL
);
251 kwsincr(kws
, needle
, strlen(needle
));
256 pickaxe(&diff_queued_diff
, o
, regexp
, kws
,
257 (opts
& DIFF_PICKAXE_KIND_G
) ? diff_grep
: has_changes
);