7 static int uninteresting(struct diff_filepair
*p
)
9 if (diff_unmodified_pair(p
))
11 if (!S_ISREG(p
->one
->mode
) || !S_ISREG(p
->two
->mode
))
16 static struct combine_diff_path
*intersect_paths(struct combine_diff_path
*curr
, int n
, int num_parent
)
18 struct diff_queue_struct
*q
= &diff_queued_diff
;
19 struct combine_diff_path
*p
;
23 struct combine_diff_path
*list
= NULL
, **tail
= &list
;
24 for (i
= 0; i
< q
->nr
; i
++) {
27 if (uninteresting(q
->queue
[i
]))
29 path
= q
->queue
[i
]->two
->path
;
32 p
= xmalloc(sizeof(*p
) + len
+ 1 + num_parent
* 20);
33 p
->path
= (char*) &(p
->parent_sha1
[num_parent
][0]);
34 memcpy(p
->path
, path
, len
);
38 memcpy(p
->sha1
, q
->queue
[i
]->two
->sha1
, 20);
39 memcpy(p
->parent_sha1
[n
], q
->queue
[i
]->one
->sha1
, 20);
46 for (p
= curr
; p
; p
= p
->next
) {
50 for (i
= 0; i
< q
->nr
; i
++) {
54 if (uninteresting(q
->queue
[i
]))
56 path
= q
->queue
[i
]->two
->path
;
58 if (len
== p
->len
&& !memcmp(path
, p
->path
, len
)) {
60 memcpy(p
->parent_sha1
[n
],
61 q
->queue
[i
]->one
->sha1
, 20);
74 unsigned long parent_map
;
75 char line
[FLEX_ARRAY
];
79 struct lline
*lost_head
, **lost_tail
;
85 static char *grab_blob(const unsigned char *sha1
, unsigned long *size
)
89 if (!memcmp(sha1
, null_sha1
, 20)) {
94 blob
= read_sha1_file(sha1
, type
, size
);
95 if (strcmp(type
, "blob"))
96 die("object '%s' is not a blob!", sha1_to_hex(sha1
));
100 #define TMPPATHLEN 50
101 #define MAXLINELEN 10240
103 static void write_to_temp_file(char *tmpfile
, void *blob
, unsigned long size
)
105 int fd
= git_mkstemp(tmpfile
, TMPPATHLEN
, ".diff_XXXXXX");
107 die("unable to create temp-file");
108 if (write(fd
, blob
, size
) != size
)
109 die("unable to write temp-file");
113 static void write_temp_blob(char *tmpfile
, const unsigned char *sha1
)
117 blob
= grab_blob(sha1
, &size
);
118 write_to_temp_file(tmpfile
, blob
, size
);
122 static int parse_num(char **cp_p
, unsigned int *num_p
)
125 unsigned int num
= 0;
128 while ('0' <= *cp
&& *cp
<= '9')
129 num
= num
* 10 + *cp
++ - '0';
130 if (!(read_some
= cp
- *cp_p
))
137 static int parse_hunk_header(char *line
, int len
,
138 unsigned int *ob
, unsigned int *on
,
139 unsigned int *nb
, unsigned int *nn
)
143 if (parse_num(&cp
, ob
)) {
145 return error("malformed diff output: %s", line
);
149 if (parse_num(&cp
, on
))
154 if (*cp
++ != ' ' || *cp
++ != '+')
156 if (parse_num(&cp
, nb
))
160 if (parse_num(&cp
, nn
))
165 return -!!memcmp(cp
, " @@", 3);
168 static void append_lost(struct sline
*sline
, int n
, const char *line
)
171 int len
= strlen(line
);
172 unsigned long this_mask
= (1UL<<n
);
173 if (line
[len
-1] == '\n')
176 /* Check to see if we can squash things */
177 if (sline
->lost_head
) {
178 struct lline
*last_one
= NULL
;
179 /* We cannot squash it with earlier one */
180 for (lline
= sline
->lost_head
;
183 if (lline
->parent_map
& this_mask
)
185 lline
= last_one
? last_one
->next
: sline
->lost_head
;
187 if (lline
->len
== len
&&
188 !memcmp(lline
->line
, line
, len
)) {
189 lline
->parent_map
|= this_mask
;
196 lline
= xmalloc(sizeof(*lline
) + len
+ 1);
199 lline
->parent_map
= this_mask
;
200 memcpy(lline
->line
, line
, len
);
201 lline
->line
[len
] = 0;
202 *sline
->lost_tail
= lline
;
203 sline
->lost_tail
= &lline
->next
;
206 static void combine_diff(const unsigned char *parent
, const char *ourtmp
,
207 struct sline
*sline
, int cnt
, int n
)
210 char parent_tmp
[TMPPATHLEN
];
211 char cmd
[TMPPATHLEN
* 2 + 1024];
212 char line
[MAXLINELEN
];
213 unsigned int lno
, ob
, on
, nb
, nn
;
214 unsigned long pmask
= ~(1UL << n
);
215 struct sline
*lost_bucket
= NULL
;
217 write_temp_blob(parent_tmp
, parent
);
218 sprintf(cmd
, "diff --unified=0 -La/x -Lb/x '%s' '%s'",
220 in
= popen(cmd
, "r");
225 while (fgets(line
, sizeof(line
), in
) != NULL
) {
226 int len
= strlen(line
);
227 if (5 < len
&& !memcmp("@@ -", line
, 4)) {
228 if (parse_hunk_header(line
, len
,
233 /* @@ -1,2 +0,0 @@ to remove the
238 lost_bucket
= &sline
[nb
-1]; /* sline is 0 based */
245 append_lost(lost_bucket
, n
, line
+1);
248 sline
[lno
-1].flag
&= pmask
;
257 static unsigned long context
= 3;
258 static char combine_marker
= '@';
260 static int interesting(struct sline
*sline
, unsigned long all_mask
)
262 return ((sline
->flag
& all_mask
) != all_mask
|| sline
->lost_head
);
265 static unsigned long adjust_hunk_tail(struct sline
*sline
,
266 unsigned long all_mask
,
267 unsigned long hunk_begin
,
270 /* i points at the first uninteresting line.
271 * If the last line of the hunk was interesting
272 * only because it has some deletion, then
273 * it is not all that interesting for the
274 * purpose of giving trailing context lines.
276 if ((hunk_begin
+ 1 <= i
) &&
277 ((sline
[i
-1].flag
& all_mask
) == all_mask
))
282 static unsigned long next_interesting(struct sline
*sline
,
290 !(sline
[i
].flag
& mark
) :
291 (sline
[i
].flag
& mark
))
298 static int give_context(struct sline
*sline
, unsigned long cnt
, int num_parent
)
300 unsigned long all_mask
= (1UL<<num_parent
) - 1;
301 unsigned long mark
= (1UL<<num_parent
);
304 i
= next_interesting(sline
, mark
, 0, cnt
, 0);
309 unsigned long j
= (context
< i
) ? (i
- context
) : 0;
312 sline
[j
++].flag
|= mark
;
315 j
= next_interesting(sline
, mark
, i
, cnt
, 1);
317 break; /* the rest are all interesting */
319 /* lookahead context lines */
320 k
= next_interesting(sline
, mark
, j
, cnt
, 0);
321 j
= adjust_hunk_tail(sline
, all_mask
, i
, j
);
323 if (k
< j
+ context
) {
324 /* k is interesting and [j,k) are not, but
325 * paint them interesting because the gap is small.
328 sline
[j
++].flag
|= mark
;
333 /* j is the first uninteresting line and there is
334 * no overlap beyond it within context lines.
337 k
= (j
+ context
< cnt
) ? j
+ context
: cnt
;
339 sline
[j
++].flag
|= mark
;
344 static int make_hunks(struct sline
*sline
, unsigned long cnt
,
345 int num_parent
, int dense
)
347 unsigned long all_mask
= (1UL<<num_parent
) - 1;
348 unsigned long mark
= (1UL<<num_parent
);
350 int has_interesting
= 0;
352 for (i
= 0; i
< cnt
; i
++) {
353 if (interesting(&sline
[i
], all_mask
))
354 sline
[i
].flag
|= mark
;
356 sline
[i
].flag
&= ~mark
;
359 return give_context(sline
, cnt
, num_parent
);
361 /* Look at each hunk, and if we have changes from only one
362 * parent, or the changes are the same from all but one
363 * parent, mark that uninteresting.
367 unsigned long j
, hunk_begin
, hunk_end
;
368 unsigned long same_diff
;
369 while (i
< cnt
&& !(sline
[i
].flag
& mark
))
372 break; /* No more interesting hunks */
374 for (j
= i
+ 1; j
< cnt
; j
++) {
375 if (!(sline
[j
].flag
& mark
)) {
376 /* Look beyond the end to see if there
377 * is an interesting line after this
378 * hunk within context span.
380 unsigned long la
; /* lookahead */
382 la
= adjust_hunk_tail(sline
, all_mask
,
384 la
= (la
+ context
< cnt
) ?
385 (la
+ context
) : cnt
;
387 if (sline
[la
].flag
& mark
) {
399 /* [i..hunk_end) are interesting. Now is it really
404 for (j
= i
; j
< hunk_end
&& !has_interesting
; j
++) {
405 unsigned long this_diff
= ~sline
[j
].flag
& all_mask
;
406 struct lline
*ll
= sline
[j
].lost_head
;
408 /* This has some changes. Is it the
412 same_diff
= this_diff
;
413 else if (same_diff
!= this_diff
) {
418 while (ll
&& !has_interesting
) {
419 /* Lost this line from these parents;
420 * who are they? Are they the same?
422 this_diff
= ll
->parent_map
;
424 same_diff
= this_diff
;
425 else if (same_diff
!= this_diff
) {
432 if (!has_interesting
) {
433 /* This hunk is not that interesting after all */
434 for (j
= hunk_begin
; j
< hunk_end
; j
++)
435 sline
[j
].flag
&= ~mark
;
440 has_interesting
= give_context(sline
, cnt
, num_parent
);
441 return has_interesting
;
444 static void dump_sline(struct sline
*sline
, int cnt
, int num_parent
)
446 unsigned long mark
= (1UL<<num_parent
);
451 struct sline
*sl
= &sline
[lno
];
453 while (lno
< cnt
&& !(sline
[lno
].flag
& mark
))
457 for (hunk_end
= lno
+ 1; hunk_end
< cnt
; hunk_end
++)
458 if (!(sline
[hunk_end
].flag
& mark
))
460 for (i
= 0; i
<= num_parent
; i
++) putchar(combine_marker
);
461 printf(" +%d,%d ", lno
+1, hunk_end
-lno
);
462 for (i
= 0; i
<= num_parent
; i
++) putchar(combine_marker
);
464 while (lno
< hunk_end
) {
470 for (j
= 0; j
< num_parent
; j
++) {
471 if (ll
->parent_map
& (1UL<<j
))
479 for (j
= 0; j
< num_parent
; j
++) {
480 if ((1UL<<j
) & sl
->flag
)
485 printf("%.*s\n", sl
->len
, sl
->bol
);
490 static void reuse_combine_diff(struct sline
*sline
, unsigned long cnt
,
493 /* We have already examined parent j and we know parent i
494 * and parent j are the same, so reuse the combined result
495 * of parent j for parent i.
497 unsigned long lno
, imask
, jmask
;
501 for (lno
= 0; lno
< cnt
; lno
++) {
502 struct lline
*ll
= sline
->lost_head
;
504 if (ll
->parent_map
& jmask
)
505 ll
->parent_map
|= imask
;
508 if (!(sline
->flag
& jmask
))
509 sline
->flag
&= ~imask
;
514 int show_combined_diff(struct combine_diff_path
*elem
, int num_parent
,
515 int dense
, const char *header
, int show_empty
)
517 unsigned long size
, cnt
, lno
;
518 char *result
, *cp
, *ep
;
519 struct sline
*sline
; /* survived lines */
520 int i
, show_hunks
, shown_header
= 0;
521 char ourtmp_buf
[TMPPATHLEN
];
522 char *ourtmp
= ourtmp_buf
;
524 /* Read the result of merge first */
525 if (memcmp(elem
->sha1
, null_sha1
, 20)) {
526 result
= grab_blob(elem
->sha1
, &size
);
527 write_to_temp_file(ourtmp
, result
, size
);
533 if (0 <= (fd
= open(ourtmp
, O_RDONLY
)) &&
535 int len
= st
.st_size
;
539 result
= xmalloc(len
+ 1);
541 int done
= xread(fd
, result
+cnt
, len
-cnt
);
545 die("read error '%s'", ourtmp
);
555 ourtmp
= "/dev/null";
561 for (cnt
= 0, cp
= result
; cp
- result
< size
; cp
++) {
565 if (result
[size
-1] != '\n')
566 cnt
++; /* incomplete line */
568 sline
= xcalloc(cnt
, sizeof(*sline
));
570 sline
[0].bol
= result
;
571 for (lno
= 0, cp
= result
; cp
- result
< size
; cp
++) {
573 sline
[lno
].lost_tail
= &sline
[lno
].lost_head
;
574 sline
[lno
].len
= cp
- sline
[lno
].bol
;
575 sline
[lno
].flag
= (1UL<<num_parent
) - 1;
578 sline
[lno
].bol
= cp
+ 1;
581 if (result
[size
-1] != '\n') {
582 sline
[cnt
-1].lost_tail
= &sline
[cnt
-1].lost_head
;
583 sline
[cnt
-1].len
= size
- (sline
[cnt
-1].bol
- result
);
584 sline
[cnt
-1].flag
= (1UL<<num_parent
) - 1;
587 for (i
= 0; i
< num_parent
; i
++) {
589 for (j
= 0; j
< i
; j
++) {
590 if (!memcmp(elem
->parent_sha1
[i
],
591 elem
->parent_sha1
[j
], 20)) {
592 reuse_combine_diff(sline
, cnt
, i
, j
);
597 combine_diff(elem
->parent_sha1
[i
], ourtmp
, sline
,
601 show_hunks
= make_hunks(sline
, cnt
, num_parent
, dense
);
603 if (header
&& (show_hunks
|| show_empty
)) {
608 printf("diff --%s ", dense
? "cc" : "combined");
609 if (quote_c_style(elem
->path
, NULL
, NULL
, 0))
610 quote_c_style(elem
->path
, NULL
, stdout
, 0);
612 printf("%s", elem
->path
);
614 dump_sline(sline
, cnt
, num_parent
);
616 if (ourtmp
== ourtmp_buf
)
620 for (i
= 0; i
< cnt
; i
++) {
621 if (sline
[i
].lost_head
) {
622 struct lline
*ll
= sline
[i
].lost_head
;
624 struct lline
*tmp
= ll
;
634 int diff_tree_combined_merge(const unsigned char *sha1
,
636 int show_empty_merge
, int dense
)
638 struct commit
*commit
= lookup_commit(sha1
);
639 struct diff_options diffopts
;
640 struct commit_list
*parents
;
641 struct combine_diff_path
*p
, *paths
= NULL
;
642 int num_parent
, i
, num_paths
;
644 diff_setup(&diffopts
);
645 diffopts
.output_format
= DIFF_FORMAT_NO_OUTPUT
;
646 diffopts
.recursive
= 1;
649 for (parents
= commit
->parents
, num_parent
= 0;
651 parents
= parents
->next
, num_parent
++)
654 /* find set of paths that everybody touches */
655 for (parents
= commit
->parents
, i
= 0;
657 parents
= parents
->next
, i
++) {
658 struct commit
*parent
= parents
->item
;
659 diff_tree_sha1(parent
->object
.sha1
, commit
->object
.sha1
, "",
661 paths
= intersect_paths(paths
, i
, num_parent
);
662 diff_flush(&diffopts
);
665 /* find out surviving paths */
666 for (num_paths
= 0, p
= paths
; p
; p
= p
->next
) {
670 if (num_paths
|| show_empty_merge
) {
671 for (p
= paths
; p
; p
= p
->next
) {
674 if (show_combined_diff(p
, num_parent
, dense
, header
,
680 /* Clean things up */
682 struct combine_diff_path
*tmp
= paths
;