2 * Copyright (C) 2005 Junio C Hamano
3 * Copyright (C) 2010 Google Inc.
8 #include "xdiff-interface.h"
11 typedef int (*pickaxe_fn
)(mmfile_t
*one
, mmfile_t
*two
,
12 struct diff_options
*o
,
13 regex_t
*regexp
, kwset_t kws
);
20 static void diffgrep_consume(void *priv
, char *line
, unsigned long len
)
22 struct diffgrep_cb
*data
= priv
;
26 if (line
[0] != '+' && line
[0] != '-')
30 * NEEDSWORK: we should have a way to terminate the
34 /* Yuck -- line ought to be "const char *"! */
37 data
->hit
= !regexec(data
->regexp
, line
+ 1, 1, ®match
, 0);
41 static int diff_grep(mmfile_t
*one
, mmfile_t
*two
,
42 struct diff_options
*o
,
43 regex_t
*regexp
, kwset_t kws
)
46 struct diffgrep_cb ecbdata
;
51 return !regexec(regexp
, two
->ptr
, 1, ®match
, 0);
53 return !regexec(regexp
, one
->ptr
, 1, ®match
, 0);
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 xdi_diff_outf(one
, two
, diffgrep_consume
, &ecbdata
,
70 static unsigned int contains(mmfile_t
*mf
, regex_t
*regexp
, kwset_t kws
)
84 assert(data
[sz
] == '\0');
85 while (*data
&& !regexec(regexp
, data
, 1, ®match
, flags
)) {
87 data
+= regmatch
.rm_eo
;
88 if (*data
&& regmatch
.rm_so
== regmatch
.rm_eo
)
93 } else { /* Classic exact string match */
96 size_t offset
= kwsexec(kws
, data
, sz
, &kwsm
);
101 found
= data
+ offset
;
102 sz
-= found
- data
+ kwsm
.size
[0];
103 data
= found
+ kwsm
.size
[0];
110 static int has_changes(mmfile_t
*one
, mmfile_t
*two
,
111 struct diff_options
*o
,
112 regex_t
*regexp
, kwset_t kws
)
114 unsigned int one_contains
= one
? contains(one
, regexp
, kws
) : 0;
115 unsigned int two_contains
= two
? contains(two
, regexp
, kws
) : 0;
116 return one_contains
!= two_contains
;
119 static int pickaxe_match(struct diff_filepair
*p
, struct diff_options
*o
,
120 regex_t
*regexp
, kwset_t kws
, pickaxe_fn fn
)
122 struct userdiff_driver
*textconv_one
= NULL
;
123 struct userdiff_driver
*textconv_two
= NULL
;
130 /* ignore unmerged */
131 if (!DIFF_FILE_VALID(p
->one
) && !DIFF_FILE_VALID(p
->two
))
134 if (DIFF_OPT_TST(o
, ALLOW_TEXTCONV
)) {
135 textconv_one
= get_textconv(p
->one
);
136 textconv_two
= get_textconv(p
->two
);
140 * If we have an unmodified pair, we know that the count will be the
141 * same and don't even have to load the blobs. Unless textconv is in
142 * play, _and_ we are using two different textconv filters (e.g.,
143 * because a pair is an exact rename with different textconv attributes
144 * for each side, which might generate different content).
146 if (textconv_one
== textconv_two
&& diff_unmodified_pair(p
))
149 mf1
.size
= fill_textconv(textconv_one
, p
->one
, &mf1
.ptr
);
150 mf2
.size
= fill_textconv(textconv_two
, p
->two
, &mf2
.ptr
);
152 ret
= fn(DIFF_FILE_VALID(p
->one
) ? &mf1
: NULL
,
153 DIFF_FILE_VALID(p
->two
) ? &mf2
: NULL
,
160 diff_free_filespec_data(p
->one
);
161 diff_free_filespec_data(p
->two
);
166 static void pickaxe(struct diff_queue_struct
*q
, struct diff_options
*o
,
167 regex_t
*regexp
, kwset_t kws
, pickaxe_fn fn
)
170 struct diff_queue_struct outq
;
172 DIFF_QUEUE_CLEAR(&outq
);
174 if (o
->pickaxe_opts
& DIFF_PICKAXE_ALL
) {
175 /* Showing the whole changeset if needle exists */
176 for (i
= 0; i
< q
->nr
; i
++) {
177 struct diff_filepair
*p
= q
->queue
[i
];
178 if (pickaxe_match(p
, o
, regexp
, kws
, fn
))
179 return; /* do not munge the queue */
183 * Otherwise we will clear the whole queue by copying
184 * the empty outq at the end of this function, but
185 * first clear the current entries in the queue.
187 for (i
= 0; i
< q
->nr
; i
++)
188 diff_free_filepair(q
->queue
[i
]);
190 /* Showing only the filepairs that has the needle */
191 for (i
= 0; i
< q
->nr
; i
++) {
192 struct diff_filepair
*p
= q
->queue
[i
];
193 if (pickaxe_match(p
, o
, regexp
, kws
, fn
))
196 diff_free_filepair(p
);
204 void diffcore_pickaxe(struct diff_options
*o
)
206 const char *needle
= o
->pickaxe
;
207 int opts
= o
->pickaxe_opts
;
208 unsigned long len
= strlen(needle
);
209 regex_t regex
, *regexp
= NULL
;
212 if (opts
& (DIFF_PICKAXE_REGEX
| DIFF_PICKAXE_KIND_G
)) {
214 int cflags
= REG_EXTENDED
| REG_NEWLINE
;
215 if (DIFF_OPT_TST(o
, PICKAXE_IGNORE_CASE
))
217 err
= regcomp(®ex
, needle
, cflags
);
219 /* The POSIX.2 people are surely sick */
221 regerror(err
, ®ex
, errbuf
, 1024);
223 die("invalid regex: %s", errbuf
);
227 kws
= kwsalloc(DIFF_OPT_TST(o
, PICKAXE_IGNORE_CASE
)
228 ? tolower_trans_tbl
: NULL
);
229 kwsincr(kws
, needle
, len
);
233 /* Might want to warn when both S and G are on; I don't care... */
234 pickaxe(&diff_queued_diff
, o
, regexp
, kws
,
235 (opts
& DIFF_PICKAXE_KIND_G
) ? diff_grep
: has_changes
);