xdiff-interface: provide a separate consume callback for hunks
[git] / xdiff-interface.c
1 #include "cache.h"
2 #include "config.h"
3 #include "object-store.h"
4 #include "xdiff-interface.h"
5 #include "xdiff/xtypes.h"
6 #include "xdiff/xdiffi.h"
7 #include "xdiff/xemit.h"
8 #include "xdiff/xmacros.h"
9 #include "xdiff/xutils.h"
10
11 struct xdiff_emit_state {
12         xdiff_emit_hunk_fn hunk_fn;
13         xdiff_emit_line_fn line_fn;
14         void *consume_callback_data;
15         struct strbuf remainder;
16 };
17
18 static int parse_num(char **cp_p, int *num_p)
19 {
20         char *cp = *cp_p;
21         int num = 0;
22
23         while ('0' <= *cp && *cp <= '9')
24                 num = num * 10 + *cp++ - '0';
25         if (!(cp - *cp_p))
26                 return -1;
27         *cp_p = cp;
28         *num_p = num;
29         return 0;
30 }
31
32 int parse_hunk_header(char *line, int len,
33                       int *ob, int *on,
34                       int *nb, int *nn)
35 {
36         char *cp;
37         cp = line + 4;
38         if (parse_num(&cp, ob)) {
39         bad_line:
40                 return error("malformed diff output: %s", line);
41         }
42         if (*cp == ',') {
43                 cp++;
44                 if (parse_num(&cp, on))
45                         goto bad_line;
46         }
47         else
48                 *on = 1;
49         if (*cp++ != ' ' || *cp++ != '+')
50                 goto bad_line;
51         if (parse_num(&cp, nb))
52                 goto bad_line;
53         if (*cp == ',') {
54                 cp++;
55                 if (parse_num(&cp, nn))
56                         goto bad_line;
57         }
58         else
59                 *nn = 1;
60         return -!!memcmp(cp, " @@", 3);
61 }
62
63 static int xdiff_out_hunk(void *priv_,
64                           long old_begin, long old_nr,
65                           long new_begin, long new_nr,
66                           const char *func, long funclen)
67 {
68         struct xdiff_emit_state *priv = priv_;
69
70         if (priv->remainder.len)
71                 BUG("xdiff emitted hunk in the middle of a line");
72
73         priv->hunk_fn(priv->consume_callback_data,
74                       old_begin, old_nr, new_begin, new_nr,
75                       func, funclen);
76         return 0;
77 }
78
79 static void consume_one(void *priv_, char *s, unsigned long size)
80 {
81         struct xdiff_emit_state *priv = priv_;
82         char *ep;
83         while (size) {
84                 unsigned long this_size;
85                 ep = memchr(s, '\n', size);
86                 this_size = (ep == NULL) ? size : (ep - s + 1);
87                 priv->line_fn(priv->consume_callback_data, s, this_size);
88                 size -= this_size;
89                 s += this_size;
90         }
91 }
92
93 static int xdiff_outf(void *priv_, mmbuffer_t *mb, int nbuf)
94 {
95         struct xdiff_emit_state *priv = priv_;
96         int i;
97
98         for (i = 0; i < nbuf; i++) {
99                 if (mb[i].ptr[mb[i].size-1] != '\n') {
100                         /* Incomplete line */
101                         strbuf_add(&priv->remainder, mb[i].ptr, mb[i].size);
102                         continue;
103                 }
104
105                 /* we have a complete line */
106                 if (!priv->remainder.len) {
107                         consume_one(priv, mb[i].ptr, mb[i].size);
108                         continue;
109                 }
110                 strbuf_add(&priv->remainder, mb[i].ptr, mb[i].size);
111                 consume_one(priv, priv->remainder.buf, priv->remainder.len);
112                 strbuf_reset(&priv->remainder);
113         }
114         if (priv->remainder.len) {
115                 consume_one(priv, priv->remainder.buf, priv->remainder.len);
116                 strbuf_reset(&priv->remainder);
117         }
118         return 0;
119 }
120
121 /*
122  * Trim down common substring at the end of the buffers,
123  * but end on a complete line.
124  */
125 static void trim_common_tail(mmfile_t *a, mmfile_t *b)
126 {
127         const int blk = 1024;
128         long trimmed = 0, recovered = 0;
129         char *ap = a->ptr + a->size;
130         char *bp = b->ptr + b->size;
131         long smaller = (a->size < b->size) ? a->size : b->size;
132
133         while (blk + trimmed <= smaller && !memcmp(ap - blk, bp - blk, blk)) {
134                 trimmed += blk;
135                 ap -= blk;
136                 bp -= blk;
137         }
138
139         while (recovered < trimmed)
140                 if (ap[recovered++] == '\n')
141                         break;
142         a->size -= trimmed - recovered;
143         b->size -= trimmed - recovered;
144 }
145
146 int xdi_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, xdemitconf_t const *xecfg, xdemitcb_t *xecb)
147 {
148         mmfile_t a = *mf1;
149         mmfile_t b = *mf2;
150
151         if (mf1->size > MAX_XDIFF_SIZE || mf2->size > MAX_XDIFF_SIZE)
152                 return -1;
153
154         if (!xecfg->ctxlen && !(xecfg->flags & XDL_EMIT_FUNCCONTEXT))
155                 trim_common_tail(&a, &b);
156
157         return xdl_diff(&a, &b, xpp, xecfg, xecb);
158 }
159
160 int xdi_diff_outf(mmfile_t *mf1, mmfile_t *mf2,
161                   xdiff_emit_hunk_fn hunk_fn,
162                   xdiff_emit_line_fn line_fn,
163                   void *consume_callback_data,
164                   xpparam_t const *xpp, xdemitconf_t const *xecfg)
165 {
166         int ret;
167         struct xdiff_emit_state state;
168         xdemitcb_t ecb;
169
170         memset(&state, 0, sizeof(state));
171         state.hunk_fn = hunk_fn;
172         state.line_fn = line_fn;
173         state.consume_callback_data = consume_callback_data;
174         memset(&ecb, 0, sizeof(ecb));
175         if (hunk_fn)
176                 ecb.out_hunk = xdiff_out_hunk;
177         ecb.out_line = xdiff_outf;
178         ecb.priv = &state;
179         strbuf_init(&state.remainder, 0);
180         ret = xdi_diff(mf1, mf2, xpp, xecfg, &ecb);
181         strbuf_release(&state.remainder);
182         return ret;
183 }
184
185 int read_mmfile(mmfile_t *ptr, const char *filename)
186 {
187         struct stat st;
188         FILE *f;
189         size_t sz;
190
191         if (stat(filename, &st))
192                 return error_errno("Could not stat %s", filename);
193         if ((f = fopen(filename, "rb")) == NULL)
194                 return error_errno("Could not open %s", filename);
195         sz = xsize_t(st.st_size);
196         ptr->ptr = xmalloc(sz ? sz : 1);
197         if (sz && fread(ptr->ptr, sz, 1, f) != 1) {
198                 fclose(f);
199                 return error("Could not read %s", filename);
200         }
201         fclose(f);
202         ptr->size = sz;
203         return 0;
204 }
205
206 void read_mmblob(mmfile_t *ptr, const struct object_id *oid)
207 {
208         unsigned long size;
209         enum object_type type;
210
211         if (!oidcmp(oid, &null_oid)) {
212                 ptr->ptr = xstrdup("");
213                 ptr->size = 0;
214                 return;
215         }
216
217         ptr->ptr = read_object_file(oid, &type, &size);
218         if (!ptr->ptr || type != OBJ_BLOB)
219                 die("unable to read blob object %s", oid_to_hex(oid));
220         ptr->size = size;
221 }
222
223 #define FIRST_FEW_BYTES 8000
224 int buffer_is_binary(const char *ptr, unsigned long size)
225 {
226         if (FIRST_FEW_BYTES < size)
227                 size = FIRST_FEW_BYTES;
228         return !!memchr(ptr, 0, size);
229 }
230
231 struct ff_regs {
232         int nr;
233         struct ff_reg {
234                 regex_t re;
235                 int negate;
236         } *array;
237 };
238
239 static long ff_regexp(const char *line, long len,
240                 char *buffer, long buffer_size, void *priv)
241 {
242         struct ff_regs *regs = priv;
243         regmatch_t pmatch[2];
244         int i;
245         int result;
246
247         /* Exclude terminating newline (and cr) from matching */
248         if (len > 0 && line[len-1] == '\n') {
249                 if (len > 1 && line[len-2] == '\r')
250                         len -= 2;
251                 else
252                         len--;
253         }
254
255         for (i = 0; i < regs->nr; i++) {
256                 struct ff_reg *reg = regs->array + i;
257                 if (!regexec_buf(&reg->re, line, len, 2, pmatch, 0)) {
258                         if (reg->negate)
259                                 return -1;
260                         break;
261                 }
262         }
263         if (regs->nr <= i)
264                 return -1;
265         i = pmatch[1].rm_so >= 0 ? 1 : 0;
266         line += pmatch[i].rm_so;
267         result = pmatch[i].rm_eo - pmatch[i].rm_so;
268         if (result > buffer_size)
269                 result = buffer_size;
270         while (result > 0 && (isspace(line[result - 1])))
271                 result--;
272         memcpy(buffer, line, result);
273         return result;
274 }
275
276 void xdiff_set_find_func(xdemitconf_t *xecfg, const char *value, int cflags)
277 {
278         int i;
279         struct ff_regs *regs;
280
281         xecfg->find_func = ff_regexp;
282         regs = xecfg->find_func_priv = xmalloc(sizeof(struct ff_regs));
283         for (i = 0, regs->nr = 1; value[i]; i++)
284                 if (value[i] == '\n')
285                         regs->nr++;
286         ALLOC_ARRAY(regs->array, regs->nr);
287         for (i = 0; i < regs->nr; i++) {
288                 struct ff_reg *reg = regs->array + i;
289                 const char *ep = strchr(value, '\n'), *expression;
290                 char *buffer = NULL;
291
292                 reg->negate = (*value == '!');
293                 if (reg->negate && i == regs->nr - 1)
294                         die("Last expression must not be negated: %s", value);
295                 if (*value == '!')
296                         value++;
297                 if (ep)
298                         expression = buffer = xstrndup(value, ep - value);
299                 else
300                         expression = value;
301                 if (regcomp(&reg->re, expression, cflags))
302                         die("Invalid regexp to look for hunk header: %s", expression);
303                 free(buffer);
304                 value = ep + 1;
305         }
306 }
307
308 void xdiff_clear_find_func(xdemitconf_t *xecfg)
309 {
310         if (xecfg->find_func) {
311                 int i;
312                 struct ff_regs *regs = xecfg->find_func_priv;
313
314                 for (i = 0; i < regs->nr; i++)
315                         regfree(&regs->array[i].re);
316                 free(regs->array);
317                 free(regs);
318                 xecfg->find_func = NULL;
319                 xecfg->find_func_priv = NULL;
320         }
321 }
322
323 unsigned long xdiff_hash_string(const char *s, size_t len, long flags)
324 {
325         return xdl_hash_record(&s, s + len, flags);
326 }
327
328 int xdiff_compare_lines(const char *l1, long s1,
329                         const char *l2, long s2, long flags)
330 {
331         return xdl_recmatch(l1, s1, l2, s2, flags);
332 }
333
334 int git_xmerge_style = -1;
335
336 int git_xmerge_config(const char *var, const char *value, void *cb)
337 {
338         if (!strcmp(var, "merge.conflictstyle")) {
339                 if (!value)
340                         die("'%s' is not a boolean", var);
341                 if (!strcmp(value, "diff3"))
342                         git_xmerge_style = XDL_MERGE_DIFF3;
343                 else if (!strcmp(value, "merge"))
344                         git_xmerge_style = 0;
345                 else
346                         die("unknown style '%s' given for '%s'",
347                             value, var);
348                 return 0;
349         }
350         return git_default_config(var, value, cb);
351 }