combine-diff.con commit s/SHELL/SHELL_PATH/ in Makefile (3654638)
   1#include "cache.h"
   2#include "commit.h"
   3#include "diff.h"
   4#include "diffcore.h"
   5#include "quote.h"
   6
   7static int uninteresting(struct diff_filepair *p)
   8{
   9        if (diff_unmodified_pair(p))
  10                return 1;
  11        return 0;
  12}
  13
  14static struct combine_diff_path *intersect_paths(struct combine_diff_path *curr, int n, int num_parent)
  15{
  16        struct diff_queue_struct *q = &diff_queued_diff;
  17        struct combine_diff_path *p;
  18        int i;
  19
  20        if (!n) {
  21                struct combine_diff_path *list = NULL, **tail = &list;
  22                for (i = 0; i < q->nr; i++) {
  23                        int len;
  24                        const char *path;
  25                        if (uninteresting(q->queue[i]))
  26                                continue;
  27                        path = q->queue[i]->two->path;
  28                        len = strlen(path);
  29                        p = xmalloc(combine_diff_path_size(num_parent, len));
  30                        p->path = (char*) &(p->parent[num_parent]);
  31                        memcpy(p->path, path, len);
  32                        p->path[len] = 0;
  33                        p->len = len;
  34                        p->next = NULL;
  35                        memset(p->parent, 0,
  36                               sizeof(p->parent[0]) * num_parent);
  37
  38                        memcpy(p->sha1, q->queue[i]->two->sha1, 20);
  39                        p->mode = q->queue[i]->two->mode;
  40                        memcpy(p->parent[n].sha1, q->queue[i]->one->sha1, 20);
  41                        p->parent[n].mode = q->queue[i]->one->mode;
  42                        p->parent[n].status = q->queue[i]->status;
  43                        *tail = p;
  44                        tail = &p->next;
  45                }
  46                return list;
  47        }
  48
  49        for (p = curr; p; p = p->next) {
  50                int found = 0;
  51                if (!p->len)
  52                        continue;
  53                for (i = 0; i < q->nr; i++) {
  54                        const char *path;
  55                        int len;
  56
  57                        if (uninteresting(q->queue[i]))
  58                                continue;
  59                        path = q->queue[i]->two->path;
  60                        len = strlen(path);
  61                        if (len == p->len && !memcmp(path, p->path, len)) {
  62                                found = 1;
  63                                memcpy(p->parent[n].sha1,
  64                                       q->queue[i]->one->sha1, 20);
  65                                p->parent[n].mode = q->queue[i]->one->mode;
  66                                p->parent[n].status = q->queue[i]->status;
  67                                break;
  68                        }
  69                }
  70                if (!found)
  71                        p->len = 0;
  72        }
  73        return curr;
  74}
  75
  76/* Lines lost from parent */
  77struct lline {
  78        struct lline *next;
  79        int len;
  80        unsigned long parent_map;
  81        char line[FLEX_ARRAY];
  82};
  83
  84/* Lines surviving in the merge result */
  85struct sline {
  86        struct lline *lost_head, **lost_tail;
  87        char *bol;
  88        int len;
  89        /* bit 0 up to (N-1) are on if the parent has this line (i.e.
  90         * we did not change it).
  91         * bit N is used for "interesting" lines, including context.
  92         */
  93        unsigned long flag;
  94        unsigned long *p_lno;
  95};
  96
  97static char *grab_blob(const unsigned char *sha1, unsigned long *size)
  98{
  99        char *blob;
 100        char type[20];
 101        if (!memcmp(sha1, null_sha1, 20)) {
 102                /* deleted blob */
 103                *size = 0;
 104                return xcalloc(1, 1);
 105        }
 106        blob = read_sha1_file(sha1, type, size);
 107        if (strcmp(type, "blob"))
 108                die("object '%s' is not a blob!", sha1_to_hex(sha1));
 109        return blob;
 110}
 111
 112#define TMPPATHLEN 50
 113#define MAXLINELEN 10240
 114
 115static void write_to_temp_file(char *tmpfile, void *blob, unsigned long size)
 116{
 117        int fd = git_mkstemp(tmpfile, TMPPATHLEN, ".diff_XXXXXX");
 118        if (fd < 0)
 119                die("unable to create temp-file");
 120        if (write(fd, blob, size) != size)
 121                die("unable to write temp-file");
 122        close(fd);
 123}
 124
 125static void write_temp_blob(char *tmpfile, const unsigned char *sha1)
 126{
 127        unsigned long size;
 128        void *blob;
 129        blob = grab_blob(sha1, &size);
 130        write_to_temp_file(tmpfile, blob, size);
 131        free(blob);
 132}
 133
 134static int parse_num(char **cp_p, unsigned int *num_p)
 135{
 136        char *cp = *cp_p;
 137        unsigned int num = 0;
 138        int read_some;
 139
 140        while ('0' <= *cp && *cp <= '9')
 141                num = num * 10 + *cp++ - '0';
 142        if (!(read_some = cp - *cp_p))
 143                return -1;
 144        *cp_p = cp;
 145        *num_p = num;
 146        return 0;
 147}
 148
 149static int parse_hunk_header(char *line, int len,
 150                             unsigned int *ob, unsigned int *on,
 151                             unsigned int *nb, unsigned int *nn)
 152{
 153        char *cp;
 154        cp = line + 4;
 155        if (parse_num(&cp, ob)) {
 156        bad_line:
 157                return error("malformed diff output: %s", line);
 158        }
 159        if (*cp == ',') {
 160                cp++;
 161                if (parse_num(&cp, on))
 162                        goto bad_line;
 163        }
 164        else
 165                *on = 1;
 166        if (*cp++ != ' ' || *cp++ != '+')
 167                goto bad_line;
 168        if (parse_num(&cp, nb))
 169                goto bad_line;
 170        if (*cp == ',') {
 171                cp++;
 172                if (parse_num(&cp, nn))
 173                        goto bad_line;
 174        }
 175        else
 176                *nn = 1;
 177        return -!!memcmp(cp, " @@", 3);
 178}
 179
 180static void append_lost(struct sline *sline, int n, const char *line)
 181{
 182        struct lline *lline;
 183        int len = strlen(line);
 184        unsigned long this_mask = (1UL<<n);
 185        if (line[len-1] == '\n')
 186                len--;
 187
 188        /* Check to see if we can squash things */
 189        if (sline->lost_head) {
 190                struct lline *last_one = NULL;
 191                /* We cannot squash it with earlier one */
 192                for (lline = sline->lost_head;
 193                     lline;
 194                     lline = lline->next)
 195                        if (lline->parent_map & this_mask)
 196                                last_one = lline;
 197                lline = last_one ? last_one->next : sline->lost_head;
 198                while (lline) {
 199                        if (lline->len == len &&
 200                            !memcmp(lline->line, line, len)) {
 201                                lline->parent_map |= this_mask;
 202                                return;
 203                        }
 204                        lline = lline->next;
 205                }
 206        }
 207
 208        lline = xmalloc(sizeof(*lline) + len + 1);
 209        lline->len = len;
 210        lline->next = NULL;
 211        lline->parent_map = this_mask;
 212        memcpy(lline->line, line, len);
 213        lline->line[len] = 0;
 214        *sline->lost_tail = lline;
 215        sline->lost_tail = &lline->next;
 216}
 217
 218static void combine_diff(const unsigned char *parent, const char *ourtmp,
 219                         struct sline *sline, int cnt, int n, int num_parent)
 220{
 221        FILE *in;
 222        char parent_tmp[TMPPATHLEN];
 223        char cmd[TMPPATHLEN * 2 + 1024];
 224        char line[MAXLINELEN];
 225        unsigned int lno, ob, on, nb, nn, p_lno;
 226        unsigned long nmask = (1UL << n);
 227        struct sline *lost_bucket = NULL;
 228
 229        if (!cnt)
 230                return; /* result deleted */
 231
 232        write_temp_blob(parent_tmp, parent);
 233        sprintf(cmd, "diff --unified=0 -La/x -Lb/x '%s' '%s'",
 234                parent_tmp, ourtmp);
 235        in = popen(cmd, "r");
 236        if (!in)
 237                die("cannot spawn %s", cmd);
 238
 239        lno = 1;
 240        while (fgets(line, sizeof(line), in) != NULL) {
 241                int len = strlen(line);
 242                if (5 < len && !memcmp("@@ -", line, 4)) {
 243                        if (parse_hunk_header(line, len,
 244                                              &ob, &on, &nb, &nn))
 245                                break;
 246                        lno = nb;
 247                        if (!nb)
 248                                /* @@ -1,2 +0,0 @@ to remove the
 249                                 * first two lines...
 250                                 */
 251                                nb = 1;
 252                        if (nn == 0)
 253                                /* @@ -X,Y +N,0 @@ removed Y lines
 254                                 * that would have come *after* line N
 255                                 * in the result.  Our lost buckets hang
 256                                 * to the line after the removed lines,
 257                                 */
 258                                lost_bucket = &sline[nb];
 259                        else
 260                                lost_bucket = &sline[nb-1];
 261                        if (!sline[nb-1].p_lno)
 262                                sline[nb-1].p_lno =
 263                                        xcalloc(num_parent,
 264                                                sizeof(unsigned long));
 265                        sline[nb-1].p_lno[n] = ob;
 266                        continue;
 267                }
 268                if (!lost_bucket)
 269                        continue; /* not in any hunk yet */
 270                switch (line[0]) {
 271                case '-':
 272                        append_lost(lost_bucket, n, line+1);
 273                        break;
 274                case '+':
 275                        sline[lno-1].flag |= nmask;
 276                        lno++;
 277                        break;
 278                }
 279        }
 280        fclose(in);
 281        unlink(parent_tmp);
 282
 283        /* Assign line numbers for this parent.
 284         *
 285         * sline[lno].p_lno[n] records the first line number
 286         * (counting from 1) for parent N if the final hunk display
 287         * started by showing sline[lno] (possibly showing the lost
 288         * lines attached to it first).
 289         */
 290        for (lno = 0,  p_lno = 1; lno < cnt; lno++) {
 291                struct lline *ll;
 292                sline[lno].p_lno[n] = p_lno;
 293
 294                /* How many lines would this sline advance the p_lno? */
 295                ll = sline[lno].lost_head;
 296                while (ll) {
 297                        if (ll->parent_map & nmask)
 298                                p_lno++; /* '-' means parent had it */
 299                        ll = ll->next;
 300                }
 301                if (!(sline[lno].flag & nmask))
 302                        p_lno++; /* no '+' means parent had it */
 303        }
 304        sline[lno].p_lno[n] = p_lno; /* trailer */
 305}
 306
 307static unsigned long context = 3;
 308static char combine_marker = '@';
 309
 310static int interesting(struct sline *sline, unsigned long all_mask)
 311{
 312        /* If some parents lost lines here, or if we have added to
 313         * some parent, it is interesting.
 314         */
 315        return ((sline->flag & all_mask) || sline->lost_head);
 316}
 317
 318static unsigned long adjust_hunk_tail(struct sline *sline,
 319                                      unsigned long all_mask,
 320                                      unsigned long hunk_begin,
 321                                      unsigned long i)
 322{
 323        /* i points at the first uninteresting line.  If the last line
 324         * of the hunk was interesting only because it has some
 325         * deletion, then it is not all that interesting for the
 326         * purpose of giving trailing context lines.  This is because
 327         * we output '-' line and then unmodified sline[i-1] itself in
 328         * that case which gives us one extra context line.
 329         */
 330        if ((hunk_begin + 1 <= i) && !(sline[i-1].flag & all_mask))
 331                i--;
 332        return i;
 333}
 334
 335static unsigned long find_next(struct sline *sline,
 336                               unsigned long mark,
 337                               unsigned long i,
 338                               unsigned long cnt,
 339                               int uninteresting)
 340{
 341        /* We have examined up to i-1 and are about to look at i.
 342         * Find next interesting or uninteresting line.  Here,
 343         * "interesting" does not mean interesting(), but marked by
 344         * the give_context() function below (i.e. it includes context
 345         * lines that are not interesting to interesting() function
 346         * that are surrounded by interesting() ones.
 347         */
 348        while (i < cnt)
 349                if (uninteresting
 350                    ? !(sline[i].flag & mark)
 351                    : (sline[i].flag & mark))
 352                        return i;
 353                else
 354                        i++;
 355        return cnt;
 356}
 357
 358static int give_context(struct sline *sline, unsigned long cnt, int num_parent)
 359{
 360        unsigned long all_mask = (1UL<<num_parent) - 1;
 361        unsigned long mark = (1UL<<num_parent);
 362        unsigned long i;
 363
 364        /* Two groups of interesting lines may have a short gap of
 365         * unintersting lines.  Connect such groups to give them a
 366         * bit of context.
 367         *
 368         * We first start from what the interesting() function says,
 369         * and mark them with "mark", and paint context lines with the
 370         * mark.  So interesting() would still say false for such context
 371         * lines but they are treated as "interesting" in the end.
 372         */
 373        i = find_next(sline, mark, 0, cnt, 0);
 374        if (cnt <= i)
 375                return 0;
 376
 377        while (i < cnt) {
 378                unsigned long j = (context < i) ? (i - context) : 0;
 379                unsigned long k;
 380
 381                /* Paint a few lines before the first interesting line. */
 382                while (j < i)
 383                        sline[j++].flag |= mark;
 384
 385        again:
 386                /* we know up to i is to be included.  where does the
 387                 * next uninteresting one start?
 388                 */
 389                j = find_next(sline, mark, i, cnt, 1);
 390                if (cnt <= j)
 391                        break; /* the rest are all interesting */
 392
 393                /* lookahead context lines */
 394                k = find_next(sline, mark, j, cnt, 0);
 395                j = adjust_hunk_tail(sline, all_mask, i, j);
 396
 397                if (k < j + context) {
 398                        /* k is interesting and [j,k) are not, but
 399                         * paint them interesting because the gap is small.
 400                         */
 401                        while (j < k)
 402                                sline[j++].flag |= mark;
 403                        i = k;
 404                        goto again;
 405                }
 406
 407                /* j is the first uninteresting line and there is
 408                 * no overlap beyond it within context lines.  Paint
 409                 * the trailing edge a bit.
 410                 */
 411                i = k;
 412                k = (j + context < cnt) ? j + context : cnt;
 413                while (j < k)
 414                        sline[j++].flag |= mark;
 415        }
 416        return 1;
 417}
 418
 419static int make_hunks(struct sline *sline, unsigned long cnt,
 420                       int num_parent, int dense)
 421{
 422        unsigned long all_mask = (1UL<<num_parent) - 1;
 423        unsigned long mark = (1UL<<num_parent);
 424        unsigned long i;
 425        int has_interesting = 0;
 426
 427        for (i = 0; i < cnt; i++) {
 428                if (interesting(&sline[i], all_mask))
 429                        sline[i].flag |= mark;
 430                else
 431                        sline[i].flag &= ~mark;
 432        }
 433        if (!dense)
 434                return give_context(sline, cnt, num_parent);
 435
 436        /* Look at each hunk, and if we have changes from only one
 437         * parent, or the changes are the same from all but one
 438         * parent, mark that uninteresting.
 439         */
 440        i = 0;
 441        while (i < cnt) {
 442                unsigned long j, hunk_begin, hunk_end;
 443                unsigned long same_diff;
 444                while (i < cnt && !(sline[i].flag & mark))
 445                        i++;
 446                if (cnt <= i)
 447                        break; /* No more interesting hunks */
 448                hunk_begin = i;
 449                for (j = i + 1; j < cnt; j++) {
 450                        if (!(sline[j].flag & mark)) {
 451                                /* Look beyond the end to see if there
 452                                 * is an interesting line after this
 453                                 * hunk within context span.
 454                                 */
 455                                unsigned long la; /* lookahead */
 456                                int contin = 0;
 457                                la = adjust_hunk_tail(sline, all_mask,
 458                                                     hunk_begin, j);
 459                                la = (la + context < cnt) ?
 460                                        (la + context) : cnt;
 461                                while (j <= --la) {
 462                                        if (sline[la].flag & mark) {
 463                                                contin = 1;
 464                                                break;
 465                                        }
 466                                }
 467                                if (!contin)
 468                                        break;
 469                                j = la;
 470                        }
 471                }
 472                hunk_end = j;
 473
 474                /* [i..hunk_end) are interesting.  Now is it really
 475                 * interesting?  We check if there are only two versions
 476                 * and the result matches one of them.  That is, we look
 477                 * at:
 478                 *   (+) line, which records lines added to which parents;
 479                 *       this line appears in the result.
 480                 *   (-) line, which records from what parents the line
 481                 *       was removed; this line does not appear in the result.
 482                 * then check the set of parents the result has difference
 483                 * from, from all lines.  If there are lines that has
 484                 * different set of parents that the result has differences
 485                 * from, that means we have more than two versions.
 486                 *
 487                 * Even when we have only two versions, if the result does
 488                 * not match any of the parents, the it should be considered
 489                 * interesting.  In such a case, we would have all '+' line.
 490                 * After passing the above "two versions" test, that would
 491                 * appear as "the same set of parents" to be "all parents".
 492                 */
 493                same_diff = 0;
 494                has_interesting = 0;
 495                for (j = i; j < hunk_end && !has_interesting; j++) {
 496                        unsigned long this_diff = sline[j].flag & all_mask;
 497                        struct lline *ll = sline[j].lost_head;
 498                        if (this_diff) {
 499                                /* This has some changes.  Is it the
 500                                 * same as others?
 501                                 */
 502                                if (!same_diff)
 503                                        same_diff = this_diff;
 504                                else if (same_diff != this_diff) {
 505                                        has_interesting = 1;
 506                                        break;
 507                                }
 508                        }
 509                        while (ll && !has_interesting) {
 510                                /* Lost this line from these parents;
 511                                 * who are they?  Are they the same?
 512                                 */
 513                                this_diff = ll->parent_map;
 514                                if (!same_diff)
 515                                        same_diff = this_diff;
 516                                else if (same_diff != this_diff) {
 517                                        has_interesting = 1;
 518                                }
 519                                ll = ll->next;
 520                        }
 521                }
 522
 523                if (!has_interesting && same_diff != all_mask) {
 524                        /* This hunk is not that interesting after all */
 525                        for (j = hunk_begin; j < hunk_end; j++)
 526                                sline[j].flag &= ~mark;
 527                }
 528                i = hunk_end;
 529        }
 530
 531        has_interesting = give_context(sline, cnt, num_parent);
 532        return has_interesting;
 533}
 534
 535static void show_parent_lno(struct sline *sline, unsigned long l0, unsigned long l1, unsigned long cnt, int n)
 536{
 537        l0 = sline[l0].p_lno[n];
 538        l1 = sline[l1].p_lno[n];
 539        printf(" -%lu,%lu", l0, l1-l0);
 540}
 541
 542static void dump_sline(struct sline *sline, unsigned long cnt, int num_parent)
 543{
 544        unsigned long mark = (1UL<<num_parent);
 545        int i;
 546        unsigned long lno = 0;
 547
 548        if (!cnt)
 549                return; /* result deleted */
 550
 551        while (1) {
 552                struct sline *sl = &sline[lno];
 553                int hunk_end;
 554                while (lno < cnt && !(sline[lno].flag & mark))
 555                        lno++;
 556                if (cnt <= lno)
 557                        break;
 558                for (hunk_end = lno + 1; hunk_end < cnt; hunk_end++)
 559                        if (!(sline[hunk_end].flag & mark))
 560                                break;
 561                for (i = 0; i <= num_parent; i++) putchar(combine_marker);
 562                for (i = 0; i < num_parent; i++)
 563                        show_parent_lno(sline, lno, hunk_end, cnt, i);
 564                printf(" +%lu,%lu ", lno+1, hunk_end-lno);
 565                for (i = 0; i <= num_parent; i++) putchar(combine_marker);
 566                putchar('\n');
 567                while (lno < hunk_end) {
 568                        struct lline *ll;
 569                        int j;
 570                        unsigned long p_mask;
 571                        sl = &sline[lno++];
 572                        ll = sl->lost_head;
 573                        while (ll) {
 574                                for (j = 0; j < num_parent; j++) {
 575                                        if (ll->parent_map & (1UL<<j))
 576                                                putchar('-');
 577                                        else
 578                                                putchar(' ');
 579                                }
 580                                puts(ll->line);
 581                                ll = ll->next;
 582                        }
 583                        p_mask = 1;
 584                        for (j = 0; j < num_parent; j++) {
 585                                if (p_mask & sl->flag)
 586                                        putchar('+');
 587                                else
 588                                        putchar(' ');
 589                                p_mask <<= 1;
 590                        }
 591                        printf("%.*s\n", sl->len, sl->bol);
 592                }
 593        }
 594}
 595
 596static void reuse_combine_diff(struct sline *sline, unsigned long cnt,
 597                               int i, int j)
 598{
 599        /* We have already examined parent j and we know parent i
 600         * and parent j are the same, so reuse the combined result
 601         * of parent j for parent i.
 602         */
 603        unsigned long lno, imask, jmask;
 604        imask = (1UL<<i);
 605        jmask = (1UL<<j);
 606
 607        for (lno = 0; lno < cnt; lno++) {
 608                struct lline *ll = sline->lost_head;
 609                sline->p_lno[i] = sline->p_lno[j];
 610                while (ll) {
 611                        if (ll->parent_map & jmask)
 612                                ll->parent_map |= imask;
 613                        ll = ll->next;
 614                }
 615                if (sline->flag & jmask)
 616                        sline->flag |= imask;
 617                sline++;
 618        }
 619        /* the overall size of the file (sline[cnt]) */
 620        sline->p_lno[i] = sline->p_lno[j];
 621}
 622
 623static int show_patch_diff(struct combine_diff_path *elem, int num_parent,
 624                           int dense, const char *header)
 625{
 626        unsigned long size, cnt, lno;
 627        char *result, *cp, *ep;
 628        struct sline *sline; /* survived lines */
 629        int mode_differs = 0;
 630        int i, show_hunks, shown_header = 0;
 631        char ourtmp_buf[TMPPATHLEN];
 632        char *ourtmp = ourtmp_buf;
 633
 634        /* Read the result of merge first */
 635        if (memcmp(elem->sha1, null_sha1, 20)) {
 636                result = grab_blob(elem->sha1, &size);
 637                write_to_temp_file(ourtmp, result, size);
 638        }
 639        else {
 640                /* Used by diff-tree to read from the working tree */
 641                struct stat st;
 642                int fd;
 643                ourtmp = elem->path;
 644                if (0 <= (fd = open(ourtmp, O_RDONLY)) &&
 645                    !fstat(fd, &st)) {
 646                        int len = st.st_size;
 647                        int cnt = 0;
 648
 649                        size = len;
 650                        result = xmalloc(len + 1);
 651                        while (cnt < len) {
 652                                int done = xread(fd, result+cnt, len-cnt);
 653                                if (done == 0)
 654                                        break;
 655                                if (done < 0)
 656                                        die("read error '%s'", ourtmp);
 657                                cnt += done;
 658                        }
 659                        result[len] = 0;
 660                }
 661                else {
 662                        /* deleted file */
 663                        size = 0;
 664                        result = xmalloc(1);
 665                        result[0] = 0;
 666                        ourtmp = "/dev/null";
 667                }
 668                if (0 <= fd)
 669                        close(fd);
 670        }
 671
 672        for (cnt = 0, cp = result; cp - result < size; cp++) {
 673                if (*cp == '\n')
 674                        cnt++;
 675        }
 676        if (size && result[size-1] != '\n')
 677                cnt++; /* incomplete line */
 678
 679        sline = xcalloc(cnt+1, sizeof(*sline));
 680        ep = result;
 681        sline[0].bol = result;
 682        for (lno = 0; lno <= cnt; lno++) {
 683                sline[lno].lost_tail = &sline[lno].lost_head;
 684                sline[lno].flag = 0;
 685        }
 686        for (lno = 0, cp = result; cp - result < size; cp++) {
 687                if (*cp == '\n') {
 688                        sline[lno].len = cp - sline[lno].bol;
 689                        lno++;
 690                        if (lno < cnt)
 691                                sline[lno].bol = cp + 1;
 692                }
 693        }
 694        if (size && result[size-1] != '\n')
 695                sline[cnt-1].len = size - (sline[cnt-1].bol - result);
 696
 697        sline[0].p_lno = xcalloc((cnt+1) * num_parent, sizeof(unsigned long));
 698        for (lno = 0; lno < cnt; lno++)
 699                sline[lno+1].p_lno = sline[lno].p_lno + num_parent;
 700
 701        for (i = 0; i < num_parent; i++) {
 702                int j;
 703                for (j = 0; j < i; j++) {
 704                        if (!memcmp(elem->parent[i].sha1,
 705                                    elem->parent[j].sha1, 20)) {
 706                                reuse_combine_diff(sline, cnt, i, j);
 707                                break;
 708                        }
 709                }
 710                if (i <= j)
 711                        combine_diff(elem->parent[i].sha1, ourtmp, sline,
 712                                     cnt, i, num_parent);
 713                if (elem->parent[i].mode != elem->mode)
 714                        mode_differs = 1;
 715        }
 716
 717        show_hunks = make_hunks(sline, cnt, num_parent, dense);
 718
 719        if (show_hunks || mode_differs) {
 720                const char *abb;
 721
 722                if (header) {
 723                        shown_header++;
 724                        puts(header);
 725                }
 726                printf("diff --%s ", dense ? "cc" : "combined");
 727                if (quote_c_style(elem->path, NULL, NULL, 0))
 728                        quote_c_style(elem->path, NULL, stdout, 0);
 729                else
 730                        printf("%s", elem->path);
 731                putchar('\n');
 732                printf("index ");
 733                for (i = 0; i < num_parent; i++) {
 734                        if (elem->parent[i].mode != elem->mode)
 735                                mode_differs = 1;
 736                        abb = find_unique_abbrev(elem->parent[i].sha1,
 737                                                 DEFAULT_ABBREV);
 738                        printf("%s%s", i ? "," : "", abb);
 739                }
 740                abb = find_unique_abbrev(elem->sha1, DEFAULT_ABBREV);
 741                printf("..%s\n", abb);
 742
 743                if (mode_differs) {
 744                        int added = !!elem->mode;
 745                        for (i = 0; added && i < num_parent; i++)
 746                                if (elem->parent[i].status !=
 747                                    DIFF_STATUS_ADDED)
 748                                        added = 0;
 749                        if (added)
 750                                printf("new file mode %06o", elem->mode);
 751                        else {
 752                                if (!elem->mode)
 753                                        printf("deleted file ");
 754                                printf("mode ");
 755                                for (i = 0; i < num_parent; i++) {
 756                                        printf("%s%06o", i ? "," : "",
 757                                               elem->parent[i].mode);
 758                                }
 759                                if (elem->mode)
 760                                        printf("..%06o", elem->mode);
 761                        }
 762                        putchar('\n');
 763                }
 764                dump_sline(sline, cnt, num_parent);
 765        }
 766        if (ourtmp == ourtmp_buf)
 767                unlink(ourtmp);
 768        free(result);
 769
 770        for (i = 0; i < cnt; i++) {
 771                if (sline[i].lost_head) {
 772                        struct lline *ll = sline[i].lost_head;
 773                        while (ll) {
 774                                struct lline *tmp = ll;
 775                                ll = ll->next;
 776                                free(tmp);
 777                        }
 778                }
 779        }
 780        free(sline[0].p_lno);
 781        free(sline);
 782        return shown_header;
 783}
 784
 785#define COLONS "::::::::::::::::::::::::::::::::"
 786
 787static void show_raw_diff(struct combine_diff_path *p, int num_parent, const char *header, struct diff_options *opt)
 788{
 789        int i, offset, mod_type = 'A';
 790        const char *prefix;
 791        int line_termination, inter_name_termination;
 792
 793        line_termination = opt->line_termination;
 794        inter_name_termination = '\t';
 795        if (!line_termination)
 796                inter_name_termination = 0;
 797
 798        if (header)
 799                puts(header);
 800
 801        for (i = 0; i < num_parent; i++) {
 802                if (p->parent[i].mode)
 803                        mod_type = 'M';
 804        }
 805        if (!p->mode)
 806                mod_type = 'D';
 807
 808        if (opt->output_format == DIFF_FORMAT_RAW) {
 809                offset = strlen(COLONS) - num_parent;
 810                if (offset < 0)
 811                        offset = 0;
 812                prefix = COLONS + offset;
 813
 814                /* Show the modes */
 815                for (i = 0; i < num_parent; i++) {
 816                        printf("%s%06o", prefix, p->parent[i].mode);
 817                        prefix = " ";
 818                }
 819                printf("%s%06o", prefix, p->mode);
 820
 821                /* Show sha1's */
 822                for (i = 0; i < num_parent; i++)
 823                        printf(" %s", diff_unique_abbrev(p->parent[i].sha1,
 824                                                         opt->abbrev));
 825                printf(" %s ", diff_unique_abbrev(p->sha1, opt->abbrev));
 826        }
 827
 828        if (opt->output_format == DIFF_FORMAT_RAW ||
 829            opt->output_format == DIFF_FORMAT_NAME_STATUS) {
 830                for (i = 0; i < num_parent; i++)
 831                        putchar(p->parent[i].status);
 832                putchar(inter_name_termination);
 833        }
 834
 835        if (line_termination) {
 836                if (quote_c_style(p->path, NULL, NULL, 0))
 837                        quote_c_style(p->path, NULL, stdout, 0);
 838                else
 839                        printf("%s", p->path);
 840                putchar(line_termination);
 841        }
 842        else {
 843                printf("%s%c", p->path, line_termination);
 844        }
 845}
 846
 847int show_combined_diff(struct combine_diff_path *p,
 848                       int num_parent,
 849                       int dense,
 850                       const char *header,
 851                       struct diff_options *opt)
 852{
 853        if (!p->len)
 854                return 0;
 855        switch (opt->output_format) {
 856        case DIFF_FORMAT_RAW:
 857        case DIFF_FORMAT_NAME_STATUS:
 858        case DIFF_FORMAT_NAME:
 859                show_raw_diff(p, num_parent, header, opt);
 860                return 1;
 861
 862        default:
 863        case DIFF_FORMAT_PATCH:
 864                return show_patch_diff(p, num_parent, dense, header);
 865        }
 866}
 867
 868const char *diff_tree_combined_merge(const unsigned char *sha1,
 869                             const char *header, int dense,
 870                             struct diff_options *opt)
 871{
 872        struct commit *commit = lookup_commit(sha1);
 873        struct diff_options diffopts;
 874        struct commit_list *parents;
 875        struct combine_diff_path *p, *paths = NULL;
 876        int num_parent, i, num_paths;
 877
 878        diffopts = *opt;
 879        diffopts.output_format = DIFF_FORMAT_NO_OUTPUT;
 880        diffopts.recursive = 1;
 881
 882        /* count parents */
 883        for (parents = commit->parents, num_parent = 0;
 884             parents;
 885             parents = parents->next, num_parent++)
 886                ; /* nothing */
 887
 888        /* find set of paths that everybody touches */
 889        for (parents = commit->parents, i = 0;
 890             parents;
 891             parents = parents->next, i++) {
 892                struct commit *parent = parents->item;
 893                diff_tree_sha1(parent->object.sha1, commit->object.sha1, "",
 894                               &diffopts);
 895                diffcore_std(&diffopts);
 896                paths = intersect_paths(paths, i, num_parent);
 897                diff_flush(&diffopts);
 898        }
 899
 900        /* find out surviving paths */
 901        for (num_paths = 0, p = paths; p; p = p->next) {
 902                if (p->len)
 903                        num_paths++;
 904        }
 905        if (num_paths) {
 906                for (p = paths; p; p = p->next) {
 907                        if (show_combined_diff(p, num_parent, dense,
 908                                               header, opt))
 909                                header = NULL;
 910                }
 911        }
 912
 913        /* Clean things up */
 914        while (paths) {
 915                struct combine_diff_path *tmp = paths;
 916                paths = paths->next;
 917                free(tmp);
 918        }
 919        return header;
 920}