combine-diff.con commit blame: show "previous" information in --porcelain/--incremental format (96e1170)
   1#include "cache.h"
   2#include "commit.h"
   3#include "blob.h"
   4#include "diff.h"
   5#include "diffcore.h"
   6#include "quote.h"
   7#include "xdiff-interface.h"
   8#include "log-tree.h"
   9
  10static struct combine_diff_path *intersect_paths(struct combine_diff_path *curr, int n, int num_parent)
  11{
  12        struct diff_queue_struct *q = &diff_queued_diff;
  13        struct combine_diff_path *p;
  14        int i;
  15
  16        if (!n) {
  17                struct combine_diff_path *list = NULL, **tail = &list;
  18                for (i = 0; i < q->nr; i++) {
  19                        int len;
  20                        const char *path;
  21                        if (diff_unmodified_pair(q->queue[i]))
  22                                continue;
  23                        path = q->queue[i]->two->path;
  24                        len = strlen(path);
  25                        p = xmalloc(combine_diff_path_size(num_parent, len));
  26                        p->path = (char*) &(p->parent[num_parent]);
  27                        memcpy(p->path, path, len);
  28                        p->path[len] = 0;
  29                        p->len = len;
  30                        p->next = NULL;
  31                        memset(p->parent, 0,
  32                               sizeof(p->parent[0]) * num_parent);
  33
  34                        hashcpy(p->sha1, q->queue[i]->two->sha1);
  35                        p->mode = q->queue[i]->two->mode;
  36                        hashcpy(p->parent[n].sha1, q->queue[i]->one->sha1);
  37                        p->parent[n].mode = q->queue[i]->one->mode;
  38                        p->parent[n].status = q->queue[i]->status;
  39                        *tail = p;
  40                        tail = &p->next;
  41                }
  42                return list;
  43        }
  44
  45        for (p = curr; p; p = p->next) {
  46                int found = 0;
  47                if (!p->len)
  48                        continue;
  49                for (i = 0; i < q->nr; i++) {
  50                        const char *path;
  51                        int len;
  52
  53                        if (diff_unmodified_pair(q->queue[i]))
  54                                continue;
  55                        path = q->queue[i]->two->path;
  56                        len = strlen(path);
  57                        if (len == p->len && !memcmp(path, p->path, len)) {
  58                                found = 1;
  59                                hashcpy(p->parent[n].sha1, q->queue[i]->one->sha1);
  60                                p->parent[n].mode = q->queue[i]->one->mode;
  61                                p->parent[n].status = q->queue[i]->status;
  62                                break;
  63                        }
  64                }
  65                if (!found)
  66                        p->len = 0;
  67        }
  68        return curr;
  69}
  70
  71/* Lines lost from parent */
  72struct lline {
  73        struct lline *next;
  74        int len;
  75        unsigned long parent_map;
  76        char line[FLEX_ARRAY];
  77};
  78
  79/* Lines surviving in the merge result */
  80struct sline {
  81        struct lline *lost_head, **lost_tail;
  82        char *bol;
  83        int len;
  84        /* bit 0 up to (N-1) are on if the parent has this line (i.e.
  85         * we did not change it).
  86         * bit N is used for "interesting" lines, including context.
  87         * bit (N+1) is used for "do not show deletion before this".
  88         */
  89        unsigned long flag;
  90        unsigned long *p_lno;
  91};
  92
  93static char *grab_blob(const unsigned char *sha1, unsigned long *size)
  94{
  95        char *blob;
  96        enum object_type type;
  97        if (is_null_sha1(sha1)) {
  98                /* deleted blob */
  99                *size = 0;
 100                return xcalloc(1, 1);
 101        }
 102        blob = read_sha1_file(sha1, &type, size);
 103        if (type != OBJ_BLOB)
 104                die("object '%s' is not a blob!", sha1_to_hex(sha1));
 105        return blob;
 106}
 107
 108static void append_lost(struct sline *sline, int n, const char *line, int len)
 109{
 110        struct lline *lline;
 111        unsigned long this_mask = (1UL<<n);
 112        if (line[len-1] == '\n')
 113                len--;
 114
 115        /* Check to see if we can squash things */
 116        if (sline->lost_head) {
 117                struct lline *last_one = NULL;
 118                /* We cannot squash it with earlier one */
 119                for (lline = sline->lost_head;
 120                     lline;
 121                     lline = lline->next)
 122                        if (lline->parent_map & this_mask)
 123                                last_one = lline;
 124                lline = last_one ? last_one->next : sline->lost_head;
 125                while (lline) {
 126                        if (lline->len == len &&
 127                            !memcmp(lline->line, line, len)) {
 128                                lline->parent_map |= this_mask;
 129                                return;
 130                        }
 131                        lline = lline->next;
 132                }
 133        }
 134
 135        lline = xmalloc(sizeof(*lline) + len + 1);
 136        lline->len = len;
 137        lline->next = NULL;
 138        lline->parent_map = this_mask;
 139        memcpy(lline->line, line, len);
 140        lline->line[len] = 0;
 141        *sline->lost_tail = lline;
 142        sline->lost_tail = &lline->next;
 143}
 144
 145struct combine_diff_state {
 146        unsigned int lno;
 147        int ob, on, nb, nn;
 148        unsigned long nmask;
 149        int num_parent;
 150        int n;
 151        struct sline *sline;
 152        struct sline *lost_bucket;
 153};
 154
 155static void consume_line(void *state_, char *line, unsigned long len)
 156{
 157        struct combine_diff_state *state = state_;
 158        if (5 < len && !memcmp("@@ -", line, 4)) {
 159                if (parse_hunk_header(line, len,
 160                                      &state->ob, &state->on,
 161                                      &state->nb, &state->nn))
 162                        return;
 163                state->lno = state->nb;
 164                if (!state->nb)
 165                        /* @@ -1,2 +0,0 @@ to remove the
 166                         * first two lines...
 167                         */
 168                        state->nb = 1;
 169                if (state->nn == 0)
 170                        /* @@ -X,Y +N,0 @@ removed Y lines
 171                         * that would have come *after* line N
 172                         * in the result.  Our lost buckets hang
 173                         * to the line after the removed lines,
 174                         */
 175                        state->lost_bucket = &state->sline[state->nb];
 176                else
 177                        state->lost_bucket = &state->sline[state->nb-1];
 178                if (!state->sline[state->nb-1].p_lno)
 179                        state->sline[state->nb-1].p_lno =
 180                                xcalloc(state->num_parent,
 181                                        sizeof(unsigned long));
 182                state->sline[state->nb-1].p_lno[state->n] = state->ob;
 183                return;
 184        }
 185        if (!state->lost_bucket)
 186                return; /* not in any hunk yet */
 187        switch (line[0]) {
 188        case '-':
 189                append_lost(state->lost_bucket, state->n, line+1, len-1);
 190                break;
 191        case '+':
 192                state->sline[state->lno-1].flag |= state->nmask;
 193                state->lno++;
 194                break;
 195        }
 196}
 197
 198static void combine_diff(const unsigned char *parent, mmfile_t *result_file,
 199                         struct sline *sline, unsigned int cnt, int n,
 200                         int num_parent)
 201{
 202        unsigned int p_lno, lno;
 203        unsigned long nmask = (1UL << n);
 204        xpparam_t xpp;
 205        xdemitconf_t xecfg;
 206        mmfile_t parent_file;
 207        xdemitcb_t ecb;
 208        struct combine_diff_state state;
 209        unsigned long sz;
 210
 211        if (!cnt)
 212                return; /* result deleted */
 213
 214        parent_file.ptr = grab_blob(parent, &sz);
 215        parent_file.size = sz;
 216        xpp.flags = XDF_NEED_MINIMAL;
 217        memset(&xecfg, 0, sizeof(xecfg));
 218        memset(&state, 0, sizeof(state));
 219        state.nmask = nmask;
 220        state.sline = sline;
 221        state.lno = 1;
 222        state.num_parent = num_parent;
 223        state.n = n;
 224
 225        xdi_diff_outf(&parent_file, result_file, consume_line, &state,
 226                      &xpp, &xecfg, &ecb);
 227        free(parent_file.ptr);
 228
 229        /* Assign line numbers for this parent.
 230         *
 231         * sline[lno].p_lno[n] records the first line number
 232         * (counting from 1) for parent N if the final hunk display
 233         * started by showing sline[lno] (possibly showing the lost
 234         * lines attached to it first).
 235         */
 236        for (lno = 0,  p_lno = 1; lno <= cnt; lno++) {
 237                struct lline *ll;
 238                sline[lno].p_lno[n] = p_lno;
 239
 240                /* How many lines would this sline advance the p_lno? */
 241                ll = sline[lno].lost_head;
 242                while (ll) {
 243                        if (ll->parent_map & nmask)
 244                                p_lno++; /* '-' means parent had it */
 245                        ll = ll->next;
 246                }
 247                if (lno < cnt && !(sline[lno].flag & nmask))
 248                        p_lno++; /* no '+' means parent had it */
 249        }
 250        sline[lno].p_lno[n] = p_lno; /* trailer */
 251}
 252
 253static unsigned long context = 3;
 254static char combine_marker = '@';
 255
 256static int interesting(struct sline *sline, unsigned long all_mask)
 257{
 258        /* If some parents lost lines here, or if we have added to
 259         * some parent, it is interesting.
 260         */
 261        return ((sline->flag & all_mask) || sline->lost_head);
 262}
 263
 264static unsigned long adjust_hunk_tail(struct sline *sline,
 265                                      unsigned long all_mask,
 266                                      unsigned long hunk_begin,
 267                                      unsigned long i)
 268{
 269        /* i points at the first uninteresting line.  If the last line
 270         * of the hunk was interesting only because it has some
 271         * deletion, then it is not all that interesting for the
 272         * purpose of giving trailing context lines.  This is because
 273         * we output '-' line and then unmodified sline[i-1] itself in
 274         * that case which gives us one extra context line.
 275         */
 276        if ((hunk_begin + 1 <= i) && !(sline[i-1].flag & all_mask))
 277                i--;
 278        return i;
 279}
 280
 281static unsigned long find_next(struct sline *sline,
 282                               unsigned long mark,
 283                               unsigned long i,
 284                               unsigned long cnt,
 285                               int look_for_uninteresting)
 286{
 287        /* We have examined up to i-1 and are about to look at i.
 288         * Find next interesting or uninteresting line.  Here,
 289         * "interesting" does not mean interesting(), but marked by
 290         * the give_context() function below (i.e. it includes context
 291         * lines that are not interesting to interesting() function
 292         * that are surrounded by interesting() ones.
 293         */
 294        while (i <= cnt)
 295                if (look_for_uninteresting
 296                    ? !(sline[i].flag & mark)
 297                    : (sline[i].flag & mark))
 298                        return i;
 299                else
 300                        i++;
 301        return i;
 302}
 303
 304static int give_context(struct sline *sline, unsigned long cnt, int num_parent)
 305{
 306        unsigned long all_mask = (1UL<<num_parent) - 1;
 307        unsigned long mark = (1UL<<num_parent);
 308        unsigned long no_pre_delete = (2UL<<num_parent);
 309        unsigned long i;
 310
 311        /* Two groups of interesting lines may have a short gap of
 312         * uninteresting lines.  Connect such groups to give them a
 313         * bit of context.
 314         *
 315         * We first start from what the interesting() function says,
 316         * and mark them with "mark", and paint context lines with the
 317         * mark.  So interesting() would still say false for such context
 318         * lines but they are treated as "interesting" in the end.
 319         */
 320        i = find_next(sline, mark, 0, cnt, 0);
 321        if (cnt < i)
 322                return 0;
 323
 324        while (i <= cnt) {
 325                unsigned long j = (context < i) ? (i - context) : 0;
 326                unsigned long k;
 327
 328                /* Paint a few lines before the first interesting line. */
 329                while (j < i)
 330                        sline[j++].flag |= mark | no_pre_delete;
 331
 332        again:
 333                /* we know up to i is to be included.  where does the
 334                 * next uninteresting one start?
 335                 */
 336                j = find_next(sline, mark, i, cnt, 1);
 337                if (cnt < j)
 338                        break; /* the rest are all interesting */
 339
 340                /* lookahead context lines */
 341                k = find_next(sline, mark, j, cnt, 0);
 342                j = adjust_hunk_tail(sline, all_mask, i, j);
 343
 344                if (k < j + context) {
 345                        /* k is interesting and [j,k) are not, but
 346                         * paint them interesting because the gap is small.
 347                         */
 348                        while (j < k)
 349                                sline[j++].flag |= mark;
 350                        i = k;
 351                        goto again;
 352                }
 353
 354                /* j is the first uninteresting line and there is
 355                 * no overlap beyond it within context lines.  Paint
 356                 * the trailing edge a bit.
 357                 */
 358                i = k;
 359                k = (j + context < cnt+1) ? j + context : cnt+1;
 360                while (j < k)
 361                        sline[j++].flag |= mark;
 362        }
 363        return 1;
 364}
 365
 366static int make_hunks(struct sline *sline, unsigned long cnt,
 367                       int num_parent, int dense)
 368{
 369        unsigned long all_mask = (1UL<<num_parent) - 1;
 370        unsigned long mark = (1UL<<num_parent);
 371        unsigned long i;
 372        int has_interesting = 0;
 373
 374        for (i = 0; i <= cnt; i++) {
 375                if (interesting(&sline[i], all_mask))
 376                        sline[i].flag |= mark;
 377                else
 378                        sline[i].flag &= ~mark;
 379        }
 380        if (!dense)
 381                return give_context(sline, cnt, num_parent);
 382
 383        /* Look at each hunk, and if we have changes from only one
 384         * parent, or the changes are the same from all but one
 385         * parent, mark that uninteresting.
 386         */
 387        i = 0;
 388        while (i <= cnt) {
 389                unsigned long j, hunk_begin, hunk_end;
 390                unsigned long same_diff;
 391                while (i <= cnt && !(sline[i].flag & mark))
 392                        i++;
 393                if (cnt < i)
 394                        break; /* No more interesting hunks */
 395                hunk_begin = i;
 396                for (j = i + 1; j <= cnt; j++) {
 397                        if (!(sline[j].flag & mark)) {
 398                                /* Look beyond the end to see if there
 399                                 * is an interesting line after this
 400                                 * hunk within context span.
 401                                 */
 402                                unsigned long la; /* lookahead */
 403                                int contin = 0;
 404                                la = adjust_hunk_tail(sline, all_mask,
 405                                                     hunk_begin, j);
 406                                la = (la + context < cnt + 1) ?
 407                                        (la + context) : cnt + 1;
 408                                while (j <= --la) {
 409                                        if (sline[la].flag & mark) {
 410                                                contin = 1;
 411                                                break;
 412                                        }
 413                                }
 414                                if (!contin)
 415                                        break;
 416                                j = la;
 417                        }
 418                }
 419                hunk_end = j;
 420
 421                /* [i..hunk_end) are interesting.  Now is it really
 422                 * interesting?  We check if there are only two versions
 423                 * and the result matches one of them.  That is, we look
 424                 * at:
 425                 *   (+) line, which records lines added to which parents;
 426                 *       this line appears in the result.
 427                 *   (-) line, which records from what parents the line
 428                 *       was removed; this line does not appear in the result.
 429                 * then check the set of parents the result has difference
 430                 * from, from all lines.  If there are lines that has
 431                 * different set of parents that the result has differences
 432                 * from, that means we have more than two versions.
 433                 *
 434                 * Even when we have only two versions, if the result does
 435                 * not match any of the parents, the it should be considered
 436                 * interesting.  In such a case, we would have all '+' line.
 437                 * After passing the above "two versions" test, that would
 438                 * appear as "the same set of parents" to be "all parents".
 439                 */
 440                same_diff = 0;
 441                has_interesting = 0;
 442                for (j = i; j < hunk_end && !has_interesting; j++) {
 443                        unsigned long this_diff = sline[j].flag & all_mask;
 444                        struct lline *ll = sline[j].lost_head;
 445                        if (this_diff) {
 446                                /* This has some changes.  Is it the
 447                                 * same as others?
 448                                 */
 449                                if (!same_diff)
 450                                        same_diff = this_diff;
 451                                else if (same_diff != this_diff) {
 452                                        has_interesting = 1;
 453                                        break;
 454                                }
 455                        }
 456                        while (ll && !has_interesting) {
 457                                /* Lost this line from these parents;
 458                                 * who are they?  Are they the same?
 459                                 */
 460                                this_diff = ll->parent_map;
 461                                if (!same_diff)
 462                                        same_diff = this_diff;
 463                                else if (same_diff != this_diff) {
 464                                        has_interesting = 1;
 465                                }
 466                                ll = ll->next;
 467                        }
 468                }
 469
 470                if (!has_interesting && same_diff != all_mask) {
 471                        /* This hunk is not that interesting after all */
 472                        for (j = hunk_begin; j < hunk_end; j++)
 473                                sline[j].flag &= ~mark;
 474                }
 475                i = hunk_end;
 476        }
 477
 478        has_interesting = give_context(sline, cnt, num_parent);
 479        return has_interesting;
 480}
 481
 482static void show_parent_lno(struct sline *sline, unsigned long l0, unsigned long l1, int n, unsigned long null_context)
 483{
 484        l0 = sline[l0].p_lno[n];
 485        l1 = sline[l1].p_lno[n];
 486        printf(" -%lu,%lu", l0, l1-l0-null_context);
 487}
 488
 489static int hunk_comment_line(const char *bol)
 490{
 491        int ch;
 492
 493        if (!bol)
 494                return 0;
 495        ch = *bol & 0xff;
 496        return (isalpha(ch) || ch == '_' || ch == '$');
 497}
 498
 499static void show_line_to_eol(const char *line, int len, const char *reset)
 500{
 501        int saw_cr_at_eol = 0;
 502        if (len < 0)
 503                len = strlen(line);
 504        saw_cr_at_eol = (len && line[len-1] == '\r');
 505
 506        printf("%.*s%s%s\n", len - saw_cr_at_eol, line,
 507               reset,
 508               saw_cr_at_eol ? "\r" : "");
 509}
 510
 511static void dump_sline(struct sline *sline, unsigned long cnt, int num_parent,
 512                       int use_color)
 513{
 514        unsigned long mark = (1UL<<num_parent);
 515        unsigned long no_pre_delete = (2UL<<num_parent);
 516        int i;
 517        unsigned long lno = 0;
 518        const char *c_frag = diff_get_color(use_color, DIFF_FRAGINFO);
 519        const char *c_new = diff_get_color(use_color, DIFF_FILE_NEW);
 520        const char *c_old = diff_get_color(use_color, DIFF_FILE_OLD);
 521        const char *c_plain = diff_get_color(use_color, DIFF_PLAIN);
 522        const char *c_reset = diff_get_color(use_color, DIFF_RESET);
 523
 524        if (!cnt)
 525                return; /* result deleted */
 526
 527        while (1) {
 528                struct sline *sl = &sline[lno];
 529                unsigned long hunk_end;
 530                unsigned long rlines;
 531                const char *hunk_comment = NULL;
 532                unsigned long null_context = 0;
 533
 534                while (lno <= cnt && !(sline[lno].flag & mark)) {
 535                        if (hunk_comment_line(sline[lno].bol))
 536                                hunk_comment = sline[lno].bol;
 537                        lno++;
 538                }
 539                if (cnt < lno)
 540                        break;
 541                else {
 542                        for (hunk_end = lno + 1; hunk_end <= cnt; hunk_end++)
 543                                if (!(sline[hunk_end].flag & mark))
 544                                        break;
 545                }
 546                rlines = hunk_end - lno;
 547                if (cnt < hunk_end)
 548                        rlines--; /* pointing at the last delete hunk */
 549
 550                if (!context) {
 551                        /*
 552                         * Even when running with --unified=0, all
 553                         * lines in the hunk needs to be processed in
 554                         * the loop below in order to show the
 555                         * deletion recorded in lost_head.  However,
 556                         * we do not want to show the resulting line
 557                         * with all blank context markers in such a
 558                         * case.  Compensate.
 559                         */
 560                        unsigned long j;
 561                        for (j = lno; j < hunk_end; j++)
 562                                if (!(sline[j].flag & (mark-1)))
 563                                        null_context++;
 564                        rlines -= null_context;
 565                }
 566
 567                fputs(c_frag, stdout);
 568                for (i = 0; i <= num_parent; i++) putchar(combine_marker);
 569                for (i = 0; i < num_parent; i++)
 570                        show_parent_lno(sline, lno, hunk_end, i, null_context);
 571                printf(" +%lu,%lu ", lno+1, rlines);
 572                for (i = 0; i <= num_parent; i++) putchar(combine_marker);
 573
 574                if (hunk_comment) {
 575                        int comment_end = 0;
 576                        for (i = 0; i < 40; i++) {
 577                                int ch = hunk_comment[i] & 0xff;
 578                                if (!ch || ch == '\n')
 579                                        break;
 580                                if (!isspace(ch))
 581                                    comment_end = i;
 582                        }
 583                        if (comment_end)
 584                                putchar(' ');
 585                        for (i = 0; i < comment_end; i++)
 586                                putchar(hunk_comment[i]);
 587                }
 588
 589                printf("%s\n", c_reset);
 590                while (lno < hunk_end) {
 591                        struct lline *ll;
 592                        int j;
 593                        unsigned long p_mask;
 594                        sl = &sline[lno++];
 595                        ll = (sl->flag & no_pre_delete) ? NULL : sl->lost_head;
 596                        while (ll) {
 597                                fputs(c_old, stdout);
 598                                for (j = 0; j < num_parent; j++) {
 599                                        if (ll->parent_map & (1UL<<j))
 600                                                putchar('-');
 601                                        else
 602                                                putchar(' ');
 603                                }
 604                                show_line_to_eol(ll->line, -1, c_reset);
 605                                ll = ll->next;
 606                        }
 607                        if (cnt < lno)
 608                                break;
 609                        p_mask = 1;
 610                        if (!(sl->flag & (mark-1))) {
 611                                /*
 612                                 * This sline was here to hang the
 613                                 * lost lines in front of it.
 614                                 */
 615                                if (!context)
 616                                        continue;
 617                                fputs(c_plain, stdout);
 618                        }
 619                        else
 620                                fputs(c_new, stdout);
 621                        for (j = 0; j < num_parent; j++) {
 622                                if (p_mask & sl->flag)
 623                                        putchar('+');
 624                                else
 625                                        putchar(' ');
 626                                p_mask <<= 1;
 627                        }
 628                        show_line_to_eol(sl->bol, sl->len, c_reset);
 629                }
 630        }
 631}
 632
 633static void reuse_combine_diff(struct sline *sline, unsigned long cnt,
 634                               int i, int j)
 635{
 636        /* We have already examined parent j and we know parent i
 637         * and parent j are the same, so reuse the combined result
 638         * of parent j for parent i.
 639         */
 640        unsigned long lno, imask, jmask;
 641        imask = (1UL<<i);
 642        jmask = (1UL<<j);
 643
 644        for (lno = 0; lno <= cnt; lno++) {
 645                struct lline *ll = sline->lost_head;
 646                sline->p_lno[i] = sline->p_lno[j];
 647                while (ll) {
 648                        if (ll->parent_map & jmask)
 649                                ll->parent_map |= imask;
 650                        ll = ll->next;
 651                }
 652                if (sline->flag & jmask)
 653                        sline->flag |= imask;
 654                sline++;
 655        }
 656        /* the overall size of the file (sline[cnt]) */
 657        sline->p_lno[i] = sline->p_lno[j];
 658}
 659
 660static void dump_quoted_path(const char *head,
 661                             const char *prefix,
 662                             const char *path,
 663                             const char *c_meta, const char *c_reset)
 664{
 665        static struct strbuf buf = STRBUF_INIT;
 666
 667        strbuf_reset(&buf);
 668        strbuf_addstr(&buf, c_meta);
 669        strbuf_addstr(&buf, head);
 670        quote_two_c_style(&buf, prefix, path, 0);
 671        strbuf_addstr(&buf, c_reset);
 672        puts(buf.buf);
 673}
 674
 675static void show_patch_diff(struct combine_diff_path *elem, int num_parent,
 676                            int dense, struct rev_info *rev)
 677{
 678        struct diff_options *opt = &rev->diffopt;
 679        unsigned long result_size, cnt, lno;
 680        char *result, *cp;
 681        struct sline *sline; /* survived lines */
 682        int mode_differs = 0;
 683        int i, show_hunks;
 684        int working_tree_file = is_null_sha1(elem->sha1);
 685        int abbrev = DIFF_OPT_TST(opt, FULL_INDEX) ? 40 : DEFAULT_ABBREV;
 686        const char *a_prefix, *b_prefix;
 687        mmfile_t result_file;
 688
 689        context = opt->context;
 690        a_prefix = opt->a_prefix ? opt->a_prefix : "a/";
 691        b_prefix = opt->b_prefix ? opt->b_prefix : "b/";
 692
 693        /* Read the result of merge first */
 694        if (!working_tree_file)
 695                result = grab_blob(elem->sha1, &result_size);
 696        else {
 697                /* Used by diff-tree to read from the working tree */
 698                struct stat st;
 699                int fd = -1;
 700
 701                if (lstat(elem->path, &st) < 0)
 702                        goto deleted_file;
 703
 704                if (S_ISLNK(st.st_mode)) {
 705                        size_t len = xsize_t(st.st_size);
 706                        result_size = len;
 707                        result = xmalloc(len + 1);
 708                        if (result_size != readlink(elem->path, result, len)) {
 709                                error("readlink(%s): %s", elem->path,
 710                                      strerror(errno));
 711                                return;
 712                        }
 713                        result[len] = 0;
 714                        elem->mode = canon_mode(st.st_mode);
 715                }
 716                else if (0 <= (fd = open(elem->path, O_RDONLY)) &&
 717                         !fstat(fd, &st)) {
 718                        size_t len = xsize_t(st.st_size);
 719                        ssize_t done;
 720                        int is_file, i;
 721
 722                        elem->mode = canon_mode(st.st_mode);
 723                        /* if symlinks don't work, assume symlink if all parents
 724                         * are symlinks
 725                         */
 726                        is_file = has_symlinks;
 727                        for (i = 0; !is_file && i < num_parent; i++)
 728                                is_file = !S_ISLNK(elem->parent[i].mode);
 729                        if (!is_file)
 730                                elem->mode = canon_mode(S_IFLNK);
 731
 732                        result_size = len;
 733                        result = xmalloc(len + 1);
 734
 735                        done = read_in_full(fd, result, len);
 736                        if (done < 0)
 737                                die("read error '%s'", elem->path);
 738                        else if (done < len)
 739                                die("early EOF '%s'", elem->path);
 740
 741                        result[len] = 0;
 742
 743                        /* If not a fake symlink, apply filters, e.g. autocrlf */
 744                        if (is_file) {
 745                                struct strbuf buf = STRBUF_INIT;
 746
 747                                if (convert_to_git(elem->path, result, len, &buf, safe_crlf)) {
 748                                        free(result);
 749                                        result = strbuf_detach(&buf, &len);
 750                                        result_size = len;
 751                                }
 752                        }
 753                }
 754                else {
 755                deleted_file:
 756                        result_size = 0;
 757                        elem->mode = 0;
 758                        result = xcalloc(1, 1);
 759                }
 760
 761                if (0 <= fd)
 762                        close(fd);
 763        }
 764
 765        for (cnt = 0, cp = result; cp < result + result_size; cp++) {
 766                if (*cp == '\n')
 767                        cnt++;
 768        }
 769        if (result_size && result[result_size-1] != '\n')
 770                cnt++; /* incomplete line */
 771
 772        sline = xcalloc(cnt+2, sizeof(*sline));
 773        sline[0].bol = result;
 774        for (lno = 0; lno <= cnt + 1; lno++) {
 775                sline[lno].lost_tail = &sline[lno].lost_head;
 776                sline[lno].flag = 0;
 777        }
 778        for (lno = 0, cp = result; cp < result + result_size; cp++) {
 779                if (*cp == '\n') {
 780                        sline[lno].len = cp - sline[lno].bol;
 781                        lno++;
 782                        if (lno < cnt)
 783                                sline[lno].bol = cp + 1;
 784                }
 785        }
 786        if (result_size && result[result_size-1] != '\n')
 787                sline[cnt-1].len = result_size - (sline[cnt-1].bol - result);
 788
 789        result_file.ptr = result;
 790        result_file.size = result_size;
 791
 792        /* Even p_lno[cnt+1] is valid -- that is for the end line number
 793         * for deletion hunk at the end.
 794         */
 795        sline[0].p_lno = xcalloc((cnt+2) * num_parent, sizeof(unsigned long));
 796        for (lno = 0; lno <= cnt; lno++)
 797                sline[lno+1].p_lno = sline[lno].p_lno + num_parent;
 798
 799        for (i = 0; i < num_parent; i++) {
 800                int j;
 801                for (j = 0; j < i; j++) {
 802                        if (!hashcmp(elem->parent[i].sha1,
 803                                     elem->parent[j].sha1)) {
 804                                reuse_combine_diff(sline, cnt, i, j);
 805                                break;
 806                        }
 807                }
 808                if (i <= j)
 809                        combine_diff(elem->parent[i].sha1, &result_file, sline,
 810                                     cnt, i, num_parent);
 811                if (elem->parent[i].mode != elem->mode)
 812                        mode_differs = 1;
 813        }
 814
 815        show_hunks = make_hunks(sline, cnt, num_parent, dense);
 816
 817        if (show_hunks || mode_differs || working_tree_file) {
 818                const char *abb;
 819                int use_color = DIFF_OPT_TST(opt, COLOR_DIFF);
 820                const char *c_meta = diff_get_color(use_color, DIFF_METAINFO);
 821                const char *c_reset = diff_get_color(use_color, DIFF_RESET);
 822                int added = 0;
 823                int deleted = 0;
 824
 825                if (rev->loginfo && !rev->no_commit_id)
 826                        show_log(rev);
 827                dump_quoted_path(dense ? "diff --cc " : "diff --combined ",
 828                                 "", elem->path, c_meta, c_reset);
 829                printf("%sindex ", c_meta);
 830                for (i = 0; i < num_parent; i++) {
 831                        abb = find_unique_abbrev(elem->parent[i].sha1,
 832                                                 abbrev);
 833                        printf("%s%s", i ? "," : "", abb);
 834                }
 835                abb = find_unique_abbrev(elem->sha1, abbrev);
 836                printf("..%s%s\n", abb, c_reset);
 837
 838                if (mode_differs) {
 839                        deleted = !elem->mode;
 840
 841                        /* We say it was added if nobody had it */
 842                        added = !deleted;
 843                        for (i = 0; added && i < num_parent; i++)
 844                                if (elem->parent[i].status !=
 845                                    DIFF_STATUS_ADDED)
 846                                        added = 0;
 847                        if (added)
 848                                printf("%snew file mode %06o",
 849                                       c_meta, elem->mode);
 850                        else {
 851                                if (deleted)
 852                                        printf("%sdeleted file ", c_meta);
 853                                printf("mode ");
 854                                for (i = 0; i < num_parent; i++) {
 855                                        printf("%s%06o", i ? "," : "",
 856                                               elem->parent[i].mode);
 857                                }
 858                                if (elem->mode)
 859                                        printf("..%06o", elem->mode);
 860                        }
 861                        printf("%s\n", c_reset);
 862                }
 863                if (added)
 864                        dump_quoted_path("--- ", "", "/dev/null",
 865                                         c_meta, c_reset);
 866                else
 867                        dump_quoted_path("--- ", a_prefix, elem->path,
 868                                         c_meta, c_reset);
 869                if (deleted)
 870                        dump_quoted_path("+++ ", "", "/dev/null",
 871                                         c_meta, c_reset);
 872                else
 873                        dump_quoted_path("+++ ", b_prefix, elem->path,
 874                                         c_meta, c_reset);
 875                dump_sline(sline, cnt, num_parent,
 876                           DIFF_OPT_TST(opt, COLOR_DIFF));
 877        }
 878        free(result);
 879
 880        for (lno = 0; lno < cnt; lno++) {
 881                if (sline[lno].lost_head) {
 882                        struct lline *ll = sline[lno].lost_head;
 883                        while (ll) {
 884                                struct lline *tmp = ll;
 885                                ll = ll->next;
 886                                free(tmp);
 887                        }
 888                }
 889        }
 890        free(sline[0].p_lno);
 891        free(sline);
 892}
 893
 894#define COLONS "::::::::::::::::::::::::::::::::"
 895
 896static void show_raw_diff(struct combine_diff_path *p, int num_parent, struct rev_info *rev)
 897{
 898        struct diff_options *opt = &rev->diffopt;
 899        int i, offset;
 900        const char *prefix;
 901        int line_termination, inter_name_termination;
 902
 903        line_termination = opt->line_termination;
 904        inter_name_termination = '\t';
 905        if (!line_termination)
 906                inter_name_termination = 0;
 907
 908        if (rev->loginfo && !rev->no_commit_id)
 909                show_log(rev);
 910
 911        if (opt->output_format & DIFF_FORMAT_RAW) {
 912                offset = strlen(COLONS) - num_parent;
 913                if (offset < 0)
 914                        offset = 0;
 915                prefix = COLONS + offset;
 916
 917                /* Show the modes */
 918                for (i = 0; i < num_parent; i++) {
 919                        printf("%s%06o", prefix, p->parent[i].mode);
 920                        prefix = " ";
 921                }
 922                printf("%s%06o", prefix, p->mode);
 923
 924                /* Show sha1's */
 925                for (i = 0; i < num_parent; i++)
 926                        printf(" %s", diff_unique_abbrev(p->parent[i].sha1,
 927                                                         opt->abbrev));
 928                printf(" %s ", diff_unique_abbrev(p->sha1, opt->abbrev));
 929        }
 930
 931        if (opt->output_format & (DIFF_FORMAT_RAW | DIFF_FORMAT_NAME_STATUS)) {
 932                for (i = 0; i < num_parent; i++)
 933                        putchar(p->parent[i].status);
 934                putchar(inter_name_termination);
 935        }
 936
 937        write_name_quoted(p->path, stdout, line_termination);
 938}
 939
 940void show_combined_diff(struct combine_diff_path *p,
 941                       int num_parent,
 942                       int dense,
 943                       struct rev_info *rev)
 944{
 945        struct diff_options *opt = &rev->diffopt;
 946        if (!p->len)
 947                return;
 948        if (opt->output_format & (DIFF_FORMAT_RAW |
 949                                  DIFF_FORMAT_NAME |
 950                                  DIFF_FORMAT_NAME_STATUS))
 951                show_raw_diff(p, num_parent, rev);
 952        else if (opt->output_format & DIFF_FORMAT_PATCH)
 953                show_patch_diff(p, num_parent, dense, rev);
 954}
 955
 956void diff_tree_combined(const unsigned char *sha1,
 957                        const unsigned char parent[][20],
 958                        int num_parent,
 959                        int dense,
 960                        struct rev_info *rev)
 961{
 962        struct diff_options *opt = &rev->diffopt;
 963        struct diff_options diffopts;
 964        struct combine_diff_path *p, *paths = NULL;
 965        int i, num_paths, needsep, show_log_first;
 966
 967        diffopts = *opt;
 968        diffopts.output_format = DIFF_FORMAT_NO_OUTPUT;
 969        DIFF_OPT_SET(&diffopts, RECURSIVE);
 970        DIFF_OPT_CLR(&diffopts, ALLOW_EXTERNAL);
 971
 972        show_log_first = !!rev->loginfo && !rev->no_commit_id;
 973        needsep = 0;
 974        /* find set of paths that everybody touches */
 975        for (i = 0; i < num_parent; i++) {
 976                /* show stat against the first parent even
 977                 * when doing combined diff.
 978                 */
 979                int stat_opt = (opt->output_format &
 980                                (DIFF_FORMAT_NUMSTAT|DIFF_FORMAT_DIFFSTAT));
 981                if (i == 0 && stat_opt)
 982                        diffopts.output_format = stat_opt;
 983                else
 984                        diffopts.output_format = DIFF_FORMAT_NO_OUTPUT;
 985                diff_tree_sha1(parent[i], sha1, "", &diffopts);
 986                diffcore_std(&diffopts);
 987                paths = intersect_paths(paths, i, num_parent);
 988
 989                if (show_log_first && i == 0) {
 990                        show_log(rev);
 991                        if (rev->verbose_header && opt->output_format)
 992                                putchar(opt->line_termination);
 993                }
 994                diff_flush(&diffopts);
 995        }
 996
 997        /* find out surviving paths */
 998        for (num_paths = 0, p = paths; p; p = p->next) {
 999                if (p->len)
1000                        num_paths++;
1001        }
1002        if (num_paths) {
1003                if (opt->output_format & (DIFF_FORMAT_RAW |
1004                                          DIFF_FORMAT_NAME |
1005                                          DIFF_FORMAT_NAME_STATUS)) {
1006                        for (p = paths; p; p = p->next) {
1007                                if (p->len)
1008                                        show_raw_diff(p, num_parent, rev);
1009                        }
1010                        needsep = 1;
1011                }
1012                else if (opt->output_format &
1013                         (DIFF_FORMAT_NUMSTAT|DIFF_FORMAT_DIFFSTAT))
1014                        needsep = 1;
1015                if (opt->output_format & DIFF_FORMAT_PATCH) {
1016                        if (needsep)
1017                                putchar(opt->line_termination);
1018                        for (p = paths; p; p = p->next) {
1019                                if (p->len)
1020                                        show_patch_diff(p, num_parent, dense,
1021                                                        rev);
1022                        }
1023                }
1024        }
1025
1026        /* Clean things up */
1027        while (paths) {
1028                struct combine_diff_path *tmp = paths;
1029                paths = paths->next;
1030                free(tmp);
1031        }
1032}
1033
1034void diff_tree_combined_merge(const unsigned char *sha1,
1035                             int dense, struct rev_info *rev)
1036{
1037        int num_parent;
1038        const unsigned char (*parent)[20];
1039        struct commit *commit = lookup_commit(sha1);
1040        struct commit_list *parents;
1041
1042        /* count parents */
1043        for (parents = commit->parents, num_parent = 0;
1044             parents;
1045             parents = parents->next, num_parent++)
1046                ; /* nothing */
1047
1048        parent = xmalloc(num_parent * sizeof(*parent));
1049        for (parents = commit->parents, num_parent = 0;
1050             parents;
1051             parents = parents->next, num_parent++)
1052                hashcpy((unsigned char*)(parent + num_parent),
1053                        parents->item->object.sha1);
1054        diff_tree_combined(sha1, parent, num_parent, dense, rev);
1055}