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"
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
;
18 static int parse_num(char **cp_p
, int *num_p
)
23 while ('0' <= *cp
&& *cp
<= '9')
24 num
= num
* 10 + *cp
++ - '0';
32 int parse_hunk_header(char *line
, int len
,
38 if (parse_num(&cp
, ob
)) {
40 return error("malformed diff output: %s", line
);
44 if (parse_num(&cp
, on
))
49 if (*cp
++ != ' ' || *cp
++ != '+')
51 if (parse_num(&cp
, nb
))
55 if (parse_num(&cp
, nn
))
60 return -!!memcmp(cp
, " @@", 3);
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
)
68 struct xdiff_emit_state
*priv
= priv_
;
70 if (priv
->remainder
.len
)
71 BUG("xdiff emitted hunk in the middle of a line");
73 priv
->hunk_fn(priv
->consume_callback_data
,
74 old_begin
, old_nr
, new_begin
, new_nr
,
79 static void consume_one(void *priv_
, char *s
, unsigned long size
)
81 struct xdiff_emit_state
*priv
= priv_
;
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
);
93 static int xdiff_outf(void *priv_
, mmbuffer_t
*mb
, int nbuf
)
95 struct xdiff_emit_state
*priv
= priv_
;
101 for (i
= 0; i
< nbuf
; i
++) {
102 if (mb
[i
].ptr
[mb
[i
].size
-1] != '\n') {
103 /* Incomplete line */
104 strbuf_add(&priv
->remainder
, mb
[i
].ptr
, mb
[i
].size
);
108 /* we have a complete line */
109 if (!priv
->remainder
.len
) {
110 consume_one(priv
, mb
[i
].ptr
, mb
[i
].size
);
113 strbuf_add(&priv
->remainder
, mb
[i
].ptr
, mb
[i
].size
);
114 consume_one(priv
, priv
->remainder
.buf
, priv
->remainder
.len
);
115 strbuf_reset(&priv
->remainder
);
117 if (priv
->remainder
.len
) {
118 consume_one(priv
, priv
->remainder
.buf
, priv
->remainder
.len
);
119 strbuf_reset(&priv
->remainder
);
125 * Trim down common substring at the end of the buffers,
126 * but end on a complete line.
128 static void trim_common_tail(mmfile_t
*a
, mmfile_t
*b
)
130 const int blk
= 1024;
131 long trimmed
= 0, recovered
= 0;
132 char *ap
= a
->ptr
+ a
->size
;
133 char *bp
= b
->ptr
+ b
->size
;
134 long smaller
= (a
->size
< b
->size
) ? a
->size
: b
->size
;
136 while (blk
+ trimmed
<= smaller
&& !memcmp(ap
- blk
, bp
- blk
, blk
)) {
142 while (recovered
< trimmed
)
143 if (ap
[recovered
++] == '\n')
145 a
->size
-= trimmed
- recovered
;
146 b
->size
-= trimmed
- recovered
;
149 int xdi_diff(mmfile_t
*mf1
, mmfile_t
*mf2
, xpparam_t
const *xpp
, xdemitconf_t
const *xecfg
, xdemitcb_t
*xecb
)
154 if (mf1
->size
> MAX_XDIFF_SIZE
|| mf2
->size
> MAX_XDIFF_SIZE
)
157 if (!xecfg
->ctxlen
&& !(xecfg
->flags
& XDL_EMIT_FUNCCONTEXT
))
158 trim_common_tail(&a
, &b
);
160 return xdl_diff(&a
, &b
, xpp
, xecfg
, xecb
);
163 void discard_hunk_line(void *priv
,
164 long ob
, long on
, long nb
, long nn
,
165 const char *func
, long funclen
)
169 int xdi_diff_outf(mmfile_t
*mf1
, mmfile_t
*mf2
,
170 xdiff_emit_hunk_fn hunk_fn
,
171 xdiff_emit_line_fn line_fn
,
172 void *consume_callback_data
,
173 xpparam_t
const *xpp
, xdemitconf_t
const *xecfg
)
176 struct xdiff_emit_state state
;
179 memset(&state
, 0, sizeof(state
));
180 state
.hunk_fn
= hunk_fn
;
181 state
.line_fn
= line_fn
;
182 state
.consume_callback_data
= consume_callback_data
;
183 memset(&ecb
, 0, sizeof(ecb
));
185 ecb
.out_hunk
= xdiff_out_hunk
;
186 ecb
.out_line
= xdiff_outf
;
188 strbuf_init(&state
.remainder
, 0);
189 ret
= xdi_diff(mf1
, mf2
, xpp
, xecfg
, &ecb
);
190 strbuf_release(&state
.remainder
);
194 int read_mmfile(mmfile_t
*ptr
, const char *filename
)
200 if (stat(filename
, &st
))
201 return error_errno("Could not stat %s", filename
);
202 if ((f
= fopen(filename
, "rb")) == NULL
)
203 return error_errno("Could not open %s", filename
);
204 sz
= xsize_t(st
.st_size
);
205 ptr
->ptr
= xmalloc(sz
? sz
: 1);
206 if (sz
&& fread(ptr
->ptr
, sz
, 1, f
) != 1) {
208 return error("Could not read %s", filename
);
215 void read_mmblob(mmfile_t
*ptr
, const struct object_id
*oid
)
218 enum object_type type
;
220 if (!oidcmp(oid
, &null_oid
)) {
221 ptr
->ptr
= xstrdup("");
226 ptr
->ptr
= read_object_file(oid
, &type
, &size
);
227 if (!ptr
->ptr
|| type
!= OBJ_BLOB
)
228 die("unable to read blob object %s", oid_to_hex(oid
));
232 #define FIRST_FEW_BYTES 8000
233 int buffer_is_binary(const char *ptr
, unsigned long size
)
235 if (FIRST_FEW_BYTES
< size
)
236 size
= FIRST_FEW_BYTES
;
237 return !!memchr(ptr
, 0, size
);
248 static long ff_regexp(const char *line
, long len
,
249 char *buffer
, long buffer_size
, void *priv
)
251 struct ff_regs
*regs
= priv
;
252 regmatch_t pmatch
[2];
256 /* Exclude terminating newline (and cr) from matching */
257 if (len
> 0 && line
[len
-1] == '\n') {
258 if (len
> 1 && line
[len
-2] == '\r')
264 for (i
= 0; i
< regs
->nr
; i
++) {
265 struct ff_reg
*reg
= regs
->array
+ i
;
266 if (!regexec_buf(®
->re
, line
, len
, 2, pmatch
, 0)) {
274 i
= pmatch
[1].rm_so
>= 0 ? 1 : 0;
275 line
+= pmatch
[i
].rm_so
;
276 result
= pmatch
[i
].rm_eo
- pmatch
[i
].rm_so
;
277 if (result
> buffer_size
)
278 result
= buffer_size
;
279 while (result
> 0 && (isspace(line
[result
- 1])))
281 memcpy(buffer
, line
, result
);
285 void xdiff_set_find_func(xdemitconf_t
*xecfg
, const char *value
, int cflags
)
288 struct ff_regs
*regs
;
290 xecfg
->find_func
= ff_regexp
;
291 regs
= xecfg
->find_func_priv
= xmalloc(sizeof(struct ff_regs
));
292 for (i
= 0, regs
->nr
= 1; value
[i
]; i
++)
293 if (value
[i
] == '\n')
295 ALLOC_ARRAY(regs
->array
, regs
->nr
);
296 for (i
= 0; i
< regs
->nr
; i
++) {
297 struct ff_reg
*reg
= regs
->array
+ i
;
298 const char *ep
= strchr(value
, '\n'), *expression
;
301 reg
->negate
= (*value
== '!');
302 if (reg
->negate
&& i
== regs
->nr
- 1)
303 die("Last expression must not be negated: %s", value
);
307 expression
= buffer
= xstrndup(value
, ep
- value
);
310 if (regcomp(®
->re
, expression
, cflags
))
311 die("Invalid regexp to look for hunk header: %s", expression
);
317 void xdiff_clear_find_func(xdemitconf_t
*xecfg
)
319 if (xecfg
->find_func
) {
321 struct ff_regs
*regs
= xecfg
->find_func_priv
;
323 for (i
= 0; i
< regs
->nr
; i
++)
324 regfree(®s
->array
[i
].re
);
327 xecfg
->find_func
= NULL
;
328 xecfg
->find_func_priv
= NULL
;
332 unsigned long xdiff_hash_string(const char *s
, size_t len
, long flags
)
334 return xdl_hash_record(&s
, s
+ len
, flags
);
337 int xdiff_compare_lines(const char *l1
, long s1
,
338 const char *l2
, long s2
, long flags
)
340 return xdl_recmatch(l1
, s1
, l2
, s2
, flags
);
343 int git_xmerge_style
= -1;
345 int git_xmerge_config(const char *var
, const char *value
, void *cb
)
347 if (!strcmp(var
, "merge.conflictstyle")) {
349 die("'%s' is not a boolean", var
);
350 if (!strcmp(value
, "diff3"))
351 git_xmerge_style
= XDL_MERGE_DIFF3
;
352 else if (!strcmp(value
, "merge"))
353 git_xmerge_style
= 0;
355 die("unknown style '%s' given for '%s'",
359 return git_default_config(var
, value
, cb
);