#include "cache.h"
#include "commit.h"
+#include "blob.h"
#include "diff.h"
#include "diffcore.h"
#include "quote.h"
-
-static int uninteresting(struct diff_filepair *p)
-{
- if (diff_unmodified_pair(p))
- return 1;
- return 0;
-}
+#include "xdiff-interface.h"
+#include "log-tree.h"
static struct combine_diff_path *intersect_paths(struct combine_diff_path *curr, int n, int num_parent)
{
for (i = 0; i < q->nr; i++) {
int len;
const char *path;
- if (uninteresting(q->queue[i]))
+ if (diff_unmodified_pair(q->queue[i]))
continue;
path = q->queue[i]->two->path;
len = strlen(path);
const char *path;
int len;
- if (uninteresting(q->queue[i]))
+ if (diff_unmodified_pair(q->queue[i]))
continue;
path = q->queue[i]->two->path;
len = strlen(path);
{
char *blob;
char type[20];
- if (!memcmp(sha1, null_sha1, 20)) {
+ if (is_null_sha1(sha1)) {
/* deleted blob */
*size = 0;
return xcalloc(1, 1);
}
blob = read_sha1_file(sha1, type, size);
- if (strcmp(type, "blob"))
+ if (strcmp(type, blob_type))
die("object '%s' is not a blob!", sha1_to_hex(sha1));
return blob;
}
-#define TMPPATHLEN 50
-#define MAXLINELEN 10240
-
-static void write_to_temp_file(char *tmpfile, void *blob, unsigned long size)
-{
- int fd = git_mkstemp(tmpfile, TMPPATHLEN, ".diff_XXXXXX");
- if (fd < 0)
- die("unable to create temp-file");
- if (write(fd, blob, size) != size)
- die("unable to write temp-file");
- close(fd);
-}
-
-static void write_temp_blob(char *tmpfile, const unsigned char *sha1)
-{
- unsigned long size;
- void *blob;
- blob = grab_blob(sha1, &size);
- write_to_temp_file(tmpfile, blob, size);
- free(blob);
-}
-
-static int parse_num(char **cp_p, unsigned int *num_p)
-{
- char *cp = *cp_p;
- unsigned int num = 0;
- int read_some;
-
- while ('0' <= *cp && *cp <= '9')
- num = num * 10 + *cp++ - '0';
- if (!(read_some = cp - *cp_p))
- return -1;
- *cp_p = cp;
- *num_p = num;
- return 0;
-}
-
-static int parse_hunk_header(char *line, int len,
- unsigned int *ob, unsigned int *on,
- unsigned int *nb, unsigned int *nn)
-{
- char *cp;
- cp = line + 4;
- if (parse_num(&cp, ob)) {
- bad_line:
- return error("malformed diff output: %s", line);
- }
- if (*cp == ',') {
- cp++;
- if (parse_num(&cp, on))
- goto bad_line;
- }
- else
- *on = 1;
- if (*cp++ != ' ' || *cp++ != '+')
- goto bad_line;
- if (parse_num(&cp, nb))
- goto bad_line;
- if (*cp == ',') {
- cp++;
- if (parse_num(&cp, nn))
- goto bad_line;
- }
- else
- *nn = 1;
- return -!!memcmp(cp, " @@", 3);
-}
-
-static void append_lost(struct sline *sline, int n, const char *line)
+static void append_lost(struct sline *sline, int n, const char *line, int len)
{
struct lline *lline;
- int len = strlen(line);
unsigned long this_mask = (1UL<<n);
if (line[len-1] == '\n')
len--;
sline->lost_tail = &lline->next;
}
-static void combine_diff(const unsigned char *parent, const char *ourtmp,
- struct sline *sline, int cnt, int n, int num_parent)
+struct combine_diff_state {
+ struct xdiff_emit_state xm;
+
+ unsigned int lno;
+ int ob, on, nb, nn;
+ unsigned long nmask;
+ int num_parent;
+ int n;
+ struct sline *sline;
+ struct sline *lost_bucket;
+};
+
+static void consume_line(void *state_, char *line, unsigned long len)
+{
+ struct combine_diff_state *state = state_;
+ if (5 < len && !memcmp("@@ -", line, 4)) {
+ if (parse_hunk_header(line, len,
+ &state->ob, &state->on,
+ &state->nb, &state->nn))
+ return;
+ state->lno = state->nb;
+ if (!state->nb)
+ /* @@ -1,2 +0,0 @@ to remove the
+ * first two lines...
+ */
+ state->nb = 1;
+ if (state->nn == 0)
+ /* @@ -X,Y +N,0 @@ removed Y lines
+ * that would have come *after* line N
+ * in the result. Our lost buckets hang
+ * to the line after the removed lines,
+ */
+ state->lost_bucket = &state->sline[state->nb];
+ else
+ state->lost_bucket = &state->sline[state->nb-1];
+ if (!state->sline[state->nb-1].p_lno)
+ state->sline[state->nb-1].p_lno =
+ xcalloc(state->num_parent,
+ sizeof(unsigned long));
+ state->sline[state->nb-1].p_lno[state->n] = state->ob;
+ return;
+ }
+ if (!state->lost_bucket)
+ return; /* not in any hunk yet */
+ switch (line[0]) {
+ case '-':
+ append_lost(state->lost_bucket, state->n, line+1, len-1);
+ break;
+ case '+':
+ state->sline[state->lno-1].flag |= state->nmask;
+ state->lno++;
+ break;
+ }
+}
+
+static void combine_diff(const unsigned char *parent, mmfile_t *result_file,
+ struct sline *sline, unsigned int cnt, int n,
+ int num_parent)
{
- FILE *in;
- char parent_tmp[TMPPATHLEN];
- char cmd[TMPPATHLEN * 2 + 1024];
- char line[MAXLINELEN];
- unsigned int lno, ob, on, nb, nn, p_lno;
+ unsigned int p_lno, lno;
unsigned long nmask = (1UL << n);
- struct sline *lost_bucket = NULL;
+ xpparam_t xpp;
+ xdemitconf_t xecfg;
+ mmfile_t parent_file;
+ xdemitcb_t ecb;
+ struct combine_diff_state state;
+ unsigned long sz;
if (!cnt)
return; /* result deleted */
- write_temp_blob(parent_tmp, parent);
- sprintf(cmd, "diff --unified=0 -La/x -Lb/x '%s' '%s'",
- parent_tmp, ourtmp);
- in = popen(cmd, "r");
- if (!in)
- die("cannot spawn %s", cmd);
-
- lno = 1;
- while (fgets(line, sizeof(line), in) != NULL) {
- int len = strlen(line);
- if (5 < len && !memcmp("@@ -", line, 4)) {
- if (parse_hunk_header(line, len,
- &ob, &on, &nb, &nn))
- break;
- lno = nb;
- if (!nb)
- /* @@ -1,2 +0,0 @@ to remove the
- * first two lines...
- */
- nb = 1;
- if (nn == 0)
- /* @@ -X,Y +N,0 @@ removed Y lines
- * that would have come *after* line N
- * in the result. Our lost buckets hang
- * to the line after the removed lines,
- */
- lost_bucket = &sline[nb];
- else
- lost_bucket = &sline[nb-1];
- if (!sline[nb-1].p_lno)
- sline[nb-1].p_lno =
- xcalloc(num_parent,
- sizeof(unsigned long));
- sline[nb-1].p_lno[n] = ob;
- continue;
- }
- if (!lost_bucket)
- continue; /* not in any hunk yet */
- switch (line[0]) {
- case '-':
- append_lost(lost_bucket, n, line+1);
- break;
- case '+':
- sline[lno-1].flag |= nmask;
- lno++;
- break;
- }
- }
- fclose(in);
- unlink(parent_tmp);
+ parent_file.ptr = grab_blob(parent, &sz);
+ parent_file.size = sz;
+ xpp.flags = XDF_NEED_MINIMAL;
+ xecfg.ctxlen = 0;
+ xecfg.flags = 0;
+ ecb.outf = xdiff_outf;
+ ecb.priv = &state;
+ memset(&state, 0, sizeof(state));
+ state.xm.consume = consume_line;
+ state.nmask = nmask;
+ state.sline = sline;
+ state.lno = 1;
+ state.num_parent = num_parent;
+ state.n = n;
+
+ xdl_diff(&parent_file, result_file, &xpp, &xecfg, &ecb);
+ free(parent_file.ptr);
/* Assign line numbers for this parent.
*
* started by showing sline[lno] (possibly showing the lost
* lines attached to it first).
*/
- for (lno = 0, p_lno = 1; lno < cnt; lno++) {
+ for (lno = 0, p_lno = 1; lno <= cnt; lno++) {
struct lline *ll;
sline[lno].p_lno[n] = p_lno;
p_lno++; /* '-' means parent had it */
ll = ll->next;
}
- if (!(sline[lno].flag & nmask))
+ if (lno < cnt && !(sline[lno].flag & nmask))
p_lno++; /* no '+' means parent had it */
}
sline[lno].p_lno[n] = p_lno; /* trailer */
unsigned long mark,
unsigned long i,
unsigned long cnt,
- int uninteresting)
+ int look_for_uninteresting)
{
/* We have examined up to i-1 and are about to look at i.
* Find next interesting or uninteresting line. Here,
* lines that are not interesting to interesting() function
* that are surrounded by interesting() ones.
*/
- while (i < cnt)
- if (uninteresting
+ while (i <= cnt)
+ if (look_for_uninteresting
? !(sline[i].flag & mark)
: (sline[i].flag & mark))
return i;
else
i++;
- return cnt;
+ return i;
}
static int give_context(struct sline *sline, unsigned long cnt, int num_parent)
unsigned long i;
/* Two groups of interesting lines may have a short gap of
- * unintersting lines. Connect such groups to give them a
+ * uninteresting lines. Connect such groups to give them a
* bit of context.
*
* We first start from what the interesting() function says,
* lines but they are treated as "interesting" in the end.
*/
i = find_next(sline, mark, 0, cnt, 0);
- if (cnt <= i)
+ if (cnt < i)
return 0;
- while (i < cnt) {
+ while (i <= cnt) {
unsigned long j = (context < i) ? (i - context) : 0;
unsigned long k;
* next uninteresting one start?
*/
j = find_next(sline, mark, i, cnt, 1);
- if (cnt <= j)
+ if (cnt < j)
break; /* the rest are all interesting */
/* lookahead context lines */
* the trailing edge a bit.
*/
i = k;
- k = (j + context < cnt) ? j + context : cnt;
+ k = (j + context < cnt+1) ? j + context : cnt+1;
while (j < k)
sline[j++].flag |= mark;
}
unsigned long i;
int has_interesting = 0;
- for (i = 0; i < cnt; i++) {
+ for (i = 0; i <= cnt; i++) {
if (interesting(&sline[i], all_mask))
sline[i].flag |= mark;
else
* parent, mark that uninteresting.
*/
i = 0;
- while (i < cnt) {
+ while (i <= cnt) {
unsigned long j, hunk_begin, hunk_end;
unsigned long same_diff;
- while (i < cnt && !(sline[i].flag & mark))
+ while (i <= cnt && !(sline[i].flag & mark))
i++;
- if (cnt <= i)
+ if (cnt < i)
break; /* No more interesting hunks */
hunk_begin = i;
- for (j = i + 1; j < cnt; j++) {
+ for (j = i + 1; j <= cnt; j++) {
if (!(sline[j].flag & mark)) {
/* Look beyond the end to see if there
* is an interesting line after this
int contin = 0;
la = adjust_hunk_tail(sline, all_mask,
hunk_begin, j);
- la = (la + context < cnt) ?
- (la + context) : cnt;
+ la = (la + context < cnt + 1) ?
+ (la + context) : cnt + 1;
while (j <= --la) {
if (sline[la].flag & mark) {
contin = 1;
return has_interesting;
}
-static void show_parent_lno(struct sline *sline, unsigned long l0, unsigned long l1, unsigned long cnt, int n)
+static void show_parent_lno(struct sline *sline, unsigned long l0, unsigned long l1, int n)
{
l0 = sline[l0].p_lno[n];
l1 = sline[l1].p_lno[n];
printf(" -%lu,%lu", l0, l1-l0);
}
-static void dump_sline(struct sline *sline, unsigned long cnt, int num_parent)
+static void dump_sline(struct sline *sline, unsigned long cnt, int num_parent,
+ int use_color)
{
unsigned long mark = (1UL<<num_parent);
int i;
unsigned long lno = 0;
+ const char *c_frag = diff_get_color(use_color, DIFF_FRAGINFO);
+ const char *c_new = diff_get_color(use_color, DIFF_FILE_NEW);
+ const char *c_old = diff_get_color(use_color, DIFF_FILE_OLD);
+ const char *c_plain = diff_get_color(use_color, DIFF_PLAIN);
+ const char *c_reset = diff_get_color(use_color, DIFF_RESET);
if (!cnt)
return; /* result deleted */
while (1) {
struct sline *sl = &sline[lno];
- int hunk_end;
- while (lno < cnt && !(sline[lno].flag & mark))
+ unsigned long hunk_end;
+ unsigned long rlines;
+ while (lno <= cnt && !(sline[lno].flag & mark))
lno++;
- if (cnt <= lno)
+ if (cnt < lno)
break;
- for (hunk_end = lno + 1; hunk_end < cnt; hunk_end++)
- if (!(sline[hunk_end].flag & mark))
- break;
+ else {
+ for (hunk_end = lno + 1; hunk_end <= cnt; hunk_end++)
+ if (!(sline[hunk_end].flag & mark))
+ break;
+ }
+ rlines = hunk_end - lno;
+ if (cnt < hunk_end)
+ rlines--; /* pointing at the last delete hunk */
+ fputs(c_frag, stdout);
for (i = 0; i <= num_parent; i++) putchar(combine_marker);
for (i = 0; i < num_parent; i++)
- show_parent_lno(sline, lno, hunk_end, cnt, i);
- printf(" +%lu,%lu ", lno+1, hunk_end-lno);
+ show_parent_lno(sline, lno, hunk_end, i);
+ printf(" +%lu,%lu ", lno+1, rlines);
for (i = 0; i <= num_parent; i++) putchar(combine_marker);
- putchar('\n');
+ printf("%s\n", c_reset);
while (lno < hunk_end) {
struct lline *ll;
int j;
sl = &sline[lno++];
ll = sl->lost_head;
while (ll) {
+ fputs(c_old, stdout);
for (j = 0; j < num_parent; j++) {
if (ll->parent_map & (1UL<<j))
putchar('-');
else
putchar(' ');
}
- puts(ll->line);
+ printf("%s%s\n", ll->line, c_reset);
ll = ll->next;
}
+ if (cnt < lno)
+ break;
p_mask = 1;
+ if (!(sl->flag & (mark-1)))
+ fputs(c_plain, stdout);
+ else
+ fputs(c_new, stdout);
for (j = 0; j < num_parent; j++) {
if (p_mask & sl->flag)
putchar('+');
putchar(' ');
p_mask <<= 1;
}
- printf("%.*s\n", sl->len, sl->bol);
+ printf("%.*s%s\n", sl->len, sl->bol, c_reset);
}
}
}
imask = (1UL<<i);
jmask = (1UL<<j);
- for (lno = 0; lno < cnt; lno++) {
+ for (lno = 0; lno <= cnt; lno++) {
struct lline *ll = sline->lost_head;
sline->p_lno[i] = sline->p_lno[j];
while (ll) {
sline->p_lno[i] = sline->p_lno[j];
}
-static int show_patch_diff(struct combine_diff_path *elem, int num_parent,
- int dense, const char *header,
- struct diff_options *opt)
+static void dump_quoted_path(const char *prefix, const char *path,
+ const char *c_meta, const char *c_reset)
{
- unsigned long size, cnt, lno;
- char *result, *cp, *ep;
+ printf("%s%s", c_meta, prefix);
+ if (quote_c_style(path, NULL, NULL, 0))
+ quote_c_style(path, NULL, stdout, 0);
+ else
+ printf("%s", path);
+ printf("%s\n", c_reset);
+}
+
+static void show_patch_diff(struct combine_diff_path *elem, int num_parent,
+ int dense, struct rev_info *rev)
+{
+ struct diff_options *opt = &rev->diffopt;
+ unsigned long result_size, cnt, lno;
+ char *result, *cp;
struct sline *sline; /* survived lines */
int mode_differs = 0;
- int i, show_hunks, shown_header = 0;
- char ourtmp_buf[TMPPATHLEN];
- char *ourtmp = ourtmp_buf;
- int working_tree_file = !memcmp(elem->sha1, null_sha1, 20);
+ int i, show_hunks;
+ int working_tree_file = is_null_sha1(elem->sha1);
int abbrev = opt->full_index ? 40 : DEFAULT_ABBREV;
+ mmfile_t result_file;
+ context = opt->context;
/* Read the result of merge first */
- if (!working_tree_file) {
- result = grab_blob(elem->sha1, &size);
- write_to_temp_file(ourtmp, result, size);
- }
+ if (!working_tree_file)
+ result = grab_blob(elem->sha1, &result_size);
else {
/* Used by diff-tree to read from the working tree */
struct stat st;
int fd;
- ourtmp = elem->path;
- if (0 <= (fd = open(ourtmp, O_RDONLY)) &&
+ if (0 <= (fd = open(elem->path, O_RDONLY)) &&
!fstat(fd, &st)) {
int len = st.st_size;
- int cnt = 0;
+ int sz = 0;
elem->mode = canon_mode(st.st_mode);
- size = len;
+ result_size = len;
result = xmalloc(len + 1);
- while (cnt < len) {
- int done = xread(fd, result+cnt, len-cnt);
+ while (sz < len) {
+ int done = xread(fd, result+sz, len-sz);
if (done == 0)
break;
if (done < 0)
- die("read error '%s'", ourtmp);
- cnt += done;
+ die("read error '%s'", elem->path);
+ sz += done;
}
result[len] = 0;
}
else {
/* deleted file */
- size = 0;
+ result_size = 0;
elem->mode = 0;
- result = xmalloc(1);
- result[0] = 0;
- ourtmp = "/dev/null";
+ result = xcalloc(1, 1);
}
if (0 <= fd)
close(fd);
}
- for (cnt = 0, cp = result; cp - result < size; cp++) {
+ for (cnt = 0, cp = result; cp < result + result_size; cp++) {
if (*cp == '\n')
cnt++;
}
- if (size && result[size-1] != '\n')
+ if (result_size && result[result_size-1] != '\n')
cnt++; /* incomplete line */
- sline = xcalloc(cnt+1, sizeof(*sline));
- ep = result;
+ sline = xcalloc(cnt+2, sizeof(*sline));
sline[0].bol = result;
- for (lno = 0; lno <= cnt; lno++) {
+ for (lno = 0; lno <= cnt + 1; lno++) {
sline[lno].lost_tail = &sline[lno].lost_head;
sline[lno].flag = 0;
}
- for (lno = 0, cp = result; cp - result < size; cp++) {
+ for (lno = 0, cp = result; cp < result + result_size; cp++) {
if (*cp == '\n') {
sline[lno].len = cp - sline[lno].bol;
lno++;
sline[lno].bol = cp + 1;
}
}
- if (size && result[size-1] != '\n')
- sline[cnt-1].len = size - (sline[cnt-1].bol - result);
+ if (result_size && result[result_size-1] != '\n')
+ sline[cnt-1].len = result_size - (sline[cnt-1].bol - result);
- sline[0].p_lno = xcalloc((cnt+1) * num_parent, sizeof(unsigned long));
- for (lno = 0; lno < cnt; lno++)
+ result_file.ptr = result;
+ result_file.size = result_size;
+
+ /* Even p_lno[cnt+1] is valid -- that is for the end line number
+ * for deletion hunk at the end.
+ */
+ sline[0].p_lno = xcalloc((cnt+2) * num_parent, sizeof(unsigned long));
+ for (lno = 0; lno <= cnt; lno++)
sline[lno+1].p_lno = sline[lno].p_lno + num_parent;
for (i = 0; i < num_parent; i++) {
}
}
if (i <= j)
- combine_diff(elem->parent[i].sha1, ourtmp, sline,
+ combine_diff(elem->parent[i].sha1, &result_file, sline,
cnt, i, num_parent);
if (elem->parent[i].mode != elem->mode)
mode_differs = 1;
if (show_hunks || mode_differs || working_tree_file) {
const char *abb;
-
- if (header) {
- shown_header++;
- printf("%s%c", header, opt->line_termination);
- }
- printf("diff --%s ", dense ? "cc" : "combined");
- if (quote_c_style(elem->path, NULL, NULL, 0))
- quote_c_style(elem->path, NULL, stdout, 0);
- else
- printf("%s", elem->path);
- putchar('\n');
- printf("index ");
+ int use_color = opt->color_diff;
+ const char *c_meta = diff_get_color(use_color, DIFF_METAINFO);
+ const char *c_reset = diff_get_color(use_color, DIFF_RESET);
+
+ if (rev->loginfo)
+ show_log(rev, opt->msg_sep);
+ dump_quoted_path(dense ? "diff --cc " : "diff --combined ",
+ elem->path, c_meta, c_reset);
+ printf("%sindex ", c_meta);
for (i = 0; i < num_parent; i++) {
abb = find_unique_abbrev(elem->parent[i].sha1,
abbrev);
printf("%s%s", i ? "," : "", abb);
}
abb = find_unique_abbrev(elem->sha1, abbrev);
- printf("..%s\n", abb);
+ printf("..%s%s\n", abb, c_reset);
if (mode_differs) {
int added = !!elem->mode;
DIFF_STATUS_ADDED)
added = 0;
if (added)
- printf("new file mode %06o", elem->mode);
+ printf("%snew file mode %06o",
+ c_meta, elem->mode);
else {
if (!elem->mode)
- printf("deleted file ");
+ printf("%sdeleted file ", c_meta);
printf("mode ");
for (i = 0; i < num_parent; i++) {
printf("%s%06o", i ? "," : "",
if (elem->mode)
printf("..%06o", elem->mode);
}
- putchar('\n');
+ printf("%s\n", c_reset);
}
- dump_sline(sline, cnt, num_parent);
+ dump_quoted_path("--- a/", elem->path, c_meta, c_reset);
+ dump_quoted_path("+++ b/", elem->path, c_meta, c_reset);
+ dump_sline(sline, cnt, num_parent, opt->color_diff);
}
- if (ourtmp == ourtmp_buf)
- unlink(ourtmp);
free(result);
- for (i = 0; i < cnt; i++) {
- if (sline[i].lost_head) {
- struct lline *ll = sline[i].lost_head;
+ for (lno = 0; lno < cnt; lno++) {
+ if (sline[lno].lost_head) {
+ struct lline *ll = sline[lno].lost_head;
while (ll) {
struct lline *tmp = ll;
ll = ll->next;
}
free(sline[0].p_lno);
free(sline);
- return shown_header;
}
#define COLONS "::::::::::::::::::::::::::::::::"
-static void show_raw_diff(struct combine_diff_path *p, int num_parent, const char *header, struct diff_options *opt)
+static void show_raw_diff(struct combine_diff_path *p, int num_parent, struct rev_info *rev)
{
- int i, offset, mod_type = 'A';
+ struct diff_options *opt = &rev->diffopt;
+ int i, offset;
const char *prefix;
int line_termination, inter_name_termination;
if (!line_termination)
inter_name_termination = 0;
- if (header)
- printf("%s%c", header, line_termination);
+ if (rev->loginfo)
+ show_log(rev, opt->msg_sep);
- for (i = 0; i < num_parent; i++) {
- if (p->parent[i].mode)
- mod_type = 'M';
- }
- if (!p->mode)
- mod_type = 'D';
-
- if (opt->output_format == DIFF_FORMAT_RAW) {
+ if (opt->output_format & DIFF_FORMAT_RAW) {
offset = strlen(COLONS) - num_parent;
if (offset < 0)
offset = 0;
printf(" %s ", diff_unique_abbrev(p->sha1, opt->abbrev));
}
- if (opt->output_format == DIFF_FORMAT_RAW ||
- opt->output_format == DIFF_FORMAT_NAME_STATUS) {
+ if (opt->output_format & (DIFF_FORMAT_RAW | DIFF_FORMAT_NAME_STATUS)) {
for (i = 0; i < num_parent; i++)
putchar(p->parent[i].status);
putchar(inter_name_termination);
}
}
-int show_combined_diff(struct combine_diff_path *p,
+void show_combined_diff(struct combine_diff_path *p,
int num_parent,
int dense,
- const char *header,
- struct diff_options *opt)
+ struct rev_info *rev)
{
+ struct diff_options *opt = &rev->diffopt;
if (!p->len)
- return 0;
- switch (opt->output_format) {
- case DIFF_FORMAT_RAW:
- case DIFF_FORMAT_NAME_STATUS:
- case DIFF_FORMAT_NAME:
- show_raw_diff(p, num_parent, header, opt);
- return 1;
-
- default:
- case DIFF_FORMAT_PATCH:
- return show_patch_diff(p, num_parent, dense, header, opt);
- }
+ return;
+ if (opt->output_format & (DIFF_FORMAT_RAW |
+ DIFF_FORMAT_NAME |
+ DIFF_FORMAT_NAME_STATUS))
+ show_raw_diff(p, num_parent, rev);
+ else if (opt->output_format & DIFF_FORMAT_PATCH)
+ show_patch_diff(p, num_parent, dense, rev);
}
-const char *diff_tree_combined_merge(const unsigned char *sha1,
- const char *header, int dense,
- struct diff_options *opt)
+void diff_tree_combined(const unsigned char *sha1,
+ const unsigned char parent[][20],
+ int num_parent,
+ int dense,
+ struct rev_info *rev)
{
- struct commit *commit = lookup_commit(sha1);
+ struct diff_options *opt = &rev->diffopt;
struct diff_options diffopts;
- struct commit_list *parents;
struct combine_diff_path *p, *paths = NULL;
- int num_parent, i, num_paths;
+ int i, num_paths, needsep, show_log_first;
diffopts = *opt;
diffopts.output_format = DIFF_FORMAT_NO_OUTPUT;
diffopts.recursive = 1;
- /* count parents */
- for (parents = commit->parents, num_parent = 0;
- parents;
- parents = parents->next, num_parent++)
- ; /* nothing */
-
+ show_log_first = !!rev->loginfo;
+ needsep = 0;
/* find set of paths that everybody touches */
- for (parents = commit->parents, i = 0;
- parents;
- parents = parents->next, i++) {
- struct commit *parent = parents->item;
- diff_tree_sha1(parent->object.sha1, commit->object.sha1, "",
- &diffopts);
+ for (i = 0; i < num_parent; i++) {
+ /* show stat against the first parent even
+ * when doing combined diff.
+ */
+ if (i == 0 && opt->output_format & DIFF_FORMAT_DIFFSTAT)
+ diffopts.output_format = DIFF_FORMAT_DIFFSTAT;
+ else
+ diffopts.output_format = DIFF_FORMAT_NO_OUTPUT;
+ diff_tree_sha1(parent[i], sha1, "", &diffopts);
diffcore_std(&diffopts);
paths = intersect_paths(paths, i, num_parent);
+
+ if (show_log_first && i == 0) {
+ show_log(rev, opt->msg_sep);
+ if (rev->verbose_header && opt->output_format)
+ putchar(opt->line_termination);
+ }
diff_flush(&diffopts);
}
num_paths++;
}
if (num_paths) {
- for (p = paths; p; p = p->next) {
- if (show_combined_diff(p, num_parent, dense,
- header, opt))
- header = NULL;
+ if (opt->output_format & (DIFF_FORMAT_RAW |
+ DIFF_FORMAT_NAME |
+ DIFF_FORMAT_NAME_STATUS)) {
+ for (p = paths; p; p = p->next) {
+ if (p->len)
+ show_raw_diff(p, num_parent, rev);
+ }
+ needsep = 1;
+ }
+ else if (opt->output_format & DIFF_FORMAT_DIFFSTAT)
+ needsep = 1;
+ if (opt->output_format & DIFF_FORMAT_PATCH) {
+ if (needsep)
+ putchar(opt->line_termination);
+ for (p = paths; p; p = p->next) {
+ if (p->len)
+ show_patch_diff(p, num_parent, dense,
+ rev);
+ }
}
}
paths = paths->next;
free(tmp);
}
- return header;
+}
+
+void diff_tree_combined_merge(const unsigned char *sha1,
+ int dense, struct rev_info *rev)
+{
+ int num_parent;
+ const unsigned char (*parent)[20];
+ struct commit *commit = lookup_commit(sha1);
+ struct commit_list *parents;
+
+ /* count parents */
+ for (parents = commit->parents, num_parent = 0;
+ parents;
+ parents = parents->next, num_parent++)
+ ; /* nothing */
+
+ parent = xmalloc(num_parent * sizeof(*parent));
+ for (parents = commit->parents, num_parent = 0;
+ parents;
+ parents = parents->next, num_parent++)
+ memcpy(parent + num_parent, parents->item->object.sha1, 20);
+ diff_tree_combined(sha1, parent, num_parent, dense, rev);
}