count-delta.c: Match the delta data semantics change in version 3.

[git.git] / combine-diff.c

diff --git a/combine-diff.c b/combine-diff.c
index 50db39b..6a9f368 100644 (file)
--- a/combine-diff.c
+++ b/combine-diff.c
@@ -8,8 +8,6 @@ static int uninteresting(struct diff_filepair *p)
 {
        if (diff_unmodified_pair(p))
                return 1;
-       if (!S_ISREG(p->one->mode) || !S_ISREG(p->two->mode))
-               return 1;
        return 0;
 }
 
@@ -28,15 +26,19 @@ static struct combine_diff_path *intersect_paths(struct combine_diff_path *curr,
                                continue;
                        path = q->queue[i]->two->path;
                        len = strlen(path);
-
-                       p = xmalloc(sizeof(*p) + len + 1 + num_parent * 20);
-                       p->path = (char*) &(p->parent_sha1[num_parent][0]);
+                       p = xmalloc(combine_diff_path_size(num_parent, len));
+                       p->path = (char*) &(p->parent[num_parent]);
                        memcpy(p->path, path, len);
                        p->path[len] = 0;
                        p->len = len;
                        p->next = NULL;
+                       memset(p->parent, 0,
+                              sizeof(p->parent[0]) * num_parent);
+
                        memcpy(p->sha1, q->queue[i]->two->sha1, 20);
-                       memcpy(p->parent_sha1[n], q->queue[i]->one->sha1, 20);
+                       p->mode = q->queue[i]->two->mode;
+                       memcpy(p->parent[n].sha1, q->queue[i]->one->sha1, 20);
+                       p->parent[n].mode = q->queue[i]->one->mode;
                        *tail = p;
                        tail = &p->next;
                }
@@ -57,8 +59,9 @@ static struct combine_diff_path *intersect_paths(struct combine_diff_path *curr,
                        len = strlen(path);
                        if (len == p->len && !memcmp(path, p->path, len)) {
                                found = 1;
-                               memcpy(p->parent_sha1[n],
+                               memcpy(p->parent[n].sha1,
                                       q->queue[i]->one->sha1, 20);
+                               p->parent[n].mode = q->queue[i]->one->mode;
                                break;
                        }
                }
@@ -221,6 +224,9 @@ static void combine_diff(const unsigned char *parent, const char *ourtmp,
        unsigned long nmask = (1UL << n);
        struct sline *lost_bucket = NULL;
 
+       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);
@@ -537,6 +543,9 @@ static void dump_sline(struct sline *sline, unsigned long cnt, int num_parent)
        int i;
        unsigned long lno = 0;
 
+       if (!cnt)
+               return; /* result deleted */
+
        while (1) {
                struct sline *sl = &sline[lno];
                int hunk_end;
@@ -605,6 +614,8 @@ static void reuse_combine_diff(struct sline *sline, unsigned long cnt,
                        sline->flag |= imask;
                sline++;
        }
+       /* the overall size of the file (sline[cnt]) */
+       sline->p_lno[i] = sline->p_lno[j];
 }
 
 int show_combined_diff(struct combine_diff_path *elem, int num_parent,
@@ -613,6 +624,7 @@ int show_combined_diff(struct combine_diff_path *elem, int num_parent,
        unsigned long size, cnt, lno;
        char *result, *cp, *ep;
        struct sline *sline; /* survived lines */
+       int mode_differs = 0;
        int i, show_hunks, shown_header = 0;
        char ourtmp_buf[TMPPATHLEN];
        char *ourtmp = ourtmp_buf;
@@ -659,27 +671,26 @@ int show_combined_diff(struct combine_diff_path *elem, int num_parent,
                if (*cp == '\n')
                        cnt++;
        }
-       if (result[size-1] != '\n')
+       if (size && result[size-1] != '\n')
                cnt++; /* incomplete line */
 
        sline = xcalloc(cnt+1, sizeof(*sline));
        ep = result;
        sline[0].bol = result;
+       for (lno = 0; lno <= cnt; lno++) {
+               sline[lno].lost_tail = &sline[lno].lost_head;
+               sline[lno].flag = 0;
+       }
        for (lno = 0, cp = result; cp - result < size; cp++) {
                if (*cp == '\n') {
-                       sline[lno].lost_tail = &sline[lno].lost_head;
                        sline[lno].len = cp - sline[lno].bol;
-                       sline[lno].flag = 0;
                        lno++;
                        if (lno < cnt)
                                sline[lno].bol = cp + 1;
                }
        }
-       if (result[size-1] != '\n') {
-               sline[cnt-1].lost_tail = &sline[cnt-1].lost_head;
+       if (size && result[size-1] != '\n')
                sline[cnt-1].len = size - (sline[cnt-1].bol - result);
-               sline[cnt-1].flag = 0;
-       }
 
        sline[0].p_lno = xcalloc((cnt+1) * num_parent, sizeof(unsigned long));
        for (lno = 0; lno < cnt; lno++)
@@ -688,20 +699,22 @@ int show_combined_diff(struct combine_diff_path *elem, int num_parent,
        for (i = 0; i < num_parent; i++) {
                int j;
                for (j = 0; j < i; j++) {
-                       if (!memcmp(elem->parent_sha1[i],
-                                   elem->parent_sha1[j], 20)) {
+                       if (!memcmp(elem->parent[i].sha1,
+                                   elem->parent[j].sha1, 20)) {
                                reuse_combine_diff(sline, cnt, i, j);
                                break;
                        }
                }
                if (i <= j)
-                       combine_diff(elem->parent_sha1[i], ourtmp, sline,
+                       combine_diff(elem->parent[i].sha1, ourtmp, sline,
                                     cnt, i, num_parent);
+               if (elem->parent[i].mode != elem->mode)
+                       mode_differs = 1;
        }
 
        show_hunks = make_hunks(sline, cnt, num_parent, dense);
 
-       if (show_hunks) {
+       if (show_hunks || mode_differs) {
                const char *abb;
                char null_abb[DEFAULT_ABBREV + 1];
 
@@ -719,8 +732,10 @@ int show_combined_diff(struct combine_diff_path *elem, int num_parent,
                putchar('\n');
                printf("index ");
                for (i = 0; i < num_parent; i++) {
-                       if (memcmp(elem->parent_sha1[i], null_sha1, 20))
-                               abb = find_unique_abbrev(elem->parent_sha1[i],
+                       if (elem->parent[i].mode != elem->mode)
+                               mode_differs = 1;
+                       if (memcmp(elem->parent[i].sha1, null_sha1, 20))
+                               abb = find_unique_abbrev(elem->parent[i].sha1,
                                                         DEFAULT_ABBREV);
                        else
                                abb = null_abb;
@@ -731,6 +746,15 @@ int show_combined_diff(struct combine_diff_path *elem, int num_parent,
                else
                        abb = null_abb;
                printf("..%s\n", abb);
+
+               if (mode_differs) {
+                       printf("mode ");
+                       for (i = 0; i < num_parent; i++) {
+                               printf("%s%06o", i ? "," : "",
+                                      elem->parent[i].mode);
+                       }
+                       printf("..%06o\n", elem->mode);
+               }
                dump_sline(sline, cnt, num_parent);
        }
        if (ourtmp == ourtmp_buf)